Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Luo bin | 6316 | 91.83% | 6 | 30.00% |
Aviad Krawczyk | 542 | 7.88% | 9 | 45.00% |
Zou Wei | 8 | 0.12% | 1 | 5.00% |
Xue Chaojing | 8 | 0.12% | 1 | 5.00% |
Zhengchao Shao | 2 | 0.03% | 1 | 5.00% |
Thomas Gleixner | 1 | 0.01% | 1 | 5.00% |
zhengbin | 1 | 0.01% | 1 | 5.00% |
Total | 6878 | 20 |
// SPDX-License-Identifier: GPL-2.0-only /* Huawei HiNIC PCI Express Linux driver * Copyright(c) 2017 Huawei Technologies Co., Ltd */ #include <linux/pci.h> #include <linux/delay.h> #include <linux/types.h> #include <linux/completion.h> #include <linux/semaphore.h> #include <linux/spinlock.h> #include <linux/workqueue.h> #include "hinic_hw_if.h" #include "hinic_hw_mgmt.h" #include "hinic_hw_csr.h" #include "hinic_hw_dev.h" #include "hinic_hw_mbox.h" #define HINIC_MBOX_INT_DST_FUNC_SHIFT 0 #define HINIC_MBOX_INT_DST_AEQN_SHIFT 10 #define HINIC_MBOX_INT_SRC_RESP_AEQN_SHIFT 12 #define HINIC_MBOX_INT_STAT_DMA_SHIFT 14 /* The size of data to be sended (unit of 4 bytes) */ #define HINIC_MBOX_INT_TX_SIZE_SHIFT 20 /* SO_RO(strong order, relax order) */ #define HINIC_MBOX_INT_STAT_DMA_SO_RO_SHIFT 25 #define HINIC_MBOX_INT_WB_EN_SHIFT 28 #define HINIC_MBOX_INT_DST_FUNC_MASK 0x3FF #define HINIC_MBOX_INT_DST_AEQN_MASK 0x3 #define HINIC_MBOX_INT_SRC_RESP_AEQN_MASK 0x3 #define HINIC_MBOX_INT_STAT_DMA_MASK 0x3F #define HINIC_MBOX_INT_TX_SIZE_MASK 0x1F #define HINIC_MBOX_INT_STAT_DMA_SO_RO_MASK 0x3 #define HINIC_MBOX_INT_WB_EN_MASK 0x1 #define HINIC_MBOX_INT_SET(val, field) \ (((val) & HINIC_MBOX_INT_##field##_MASK) << \ HINIC_MBOX_INT_##field##_SHIFT) enum hinic_mbox_tx_status { TX_NOT_DONE = 1, }; #define HINIC_MBOX_CTRL_TRIGGER_AEQE_SHIFT 0 /* specifies the issue request for the message data. * 0 - Tx request is done; * 1 - Tx request is in process. */ #define HINIC_MBOX_CTRL_TX_STATUS_SHIFT 1 #define HINIC_MBOX_CTRL_TRIGGER_AEQE_MASK 0x1 #define HINIC_MBOX_CTRL_TX_STATUS_MASK 0x1 #define HINIC_MBOX_CTRL_SET(val, field) \ (((val) & HINIC_MBOX_CTRL_##field##_MASK) << \ HINIC_MBOX_CTRL_##field##_SHIFT) #define HINIC_MBOX_HEADER_MSG_LEN_SHIFT 0 #define HINIC_MBOX_HEADER_MODULE_SHIFT 11 #define HINIC_MBOX_HEADER_SEG_LEN_SHIFT 16 #define HINIC_MBOX_HEADER_NO_ACK_SHIFT 22 #define HINIC_MBOX_HEADER_SEQID_SHIFT 24 #define HINIC_MBOX_HEADER_LAST_SHIFT 30 /* specifies the mailbox message direction * 0 - send * 1 - receive */ #define HINIC_MBOX_HEADER_DIRECTION_SHIFT 31 #define HINIC_MBOX_HEADER_CMD_SHIFT 32 #define HINIC_MBOX_HEADER_MSG_ID_SHIFT 40 #define HINIC_MBOX_HEADER_STATUS_SHIFT 48 #define HINIC_MBOX_HEADER_SRC_GLB_FUNC_IDX_SHIFT 54 #define HINIC_MBOX_HEADER_MSG_LEN_MASK 0x7FF #define HINIC_MBOX_HEADER_MODULE_MASK 0x1F #define HINIC_MBOX_HEADER_SEG_LEN_MASK 0x3F #define HINIC_MBOX_HEADER_NO_ACK_MASK 0x1 #define HINIC_MBOX_HEADER_SEQID_MASK 0x3F #define HINIC_MBOX_HEADER_LAST_MASK 0x1 #define HINIC_MBOX_HEADER_DIRECTION_MASK 0x1 #define HINIC_MBOX_HEADER_CMD_MASK 0xFF #define HINIC_MBOX_HEADER_MSG_ID_MASK 0xFF #define HINIC_MBOX_HEADER_STATUS_MASK 0x3F #define HINIC_MBOX_HEADER_SRC_GLB_FUNC_IDX_MASK 0x3FF #define HINIC_MBOX_HEADER_GET(val, field) \ (((val) >> HINIC_MBOX_HEADER_##field##_SHIFT) & \ HINIC_MBOX_HEADER_##field##_MASK) #define HINIC_MBOX_HEADER_SET(val, field) \ ((u64)((val) & HINIC_MBOX_HEADER_##field##_MASK) << \ HINIC_MBOX_HEADER_##field##_SHIFT) #define MBOX_SEGLEN_MASK \ HINIC_MBOX_HEADER_SET(HINIC_MBOX_HEADER_SEG_LEN_MASK, SEG_LEN) #define HINIC_MBOX_SEG_LEN 48 #define HINIC_MBOX_COMP_TIME 8000U #define MBOX_MSG_POLLING_TIMEOUT 8000 #define HINIC_MBOX_DATA_SIZE 2040 #define MBOX_MAX_BUF_SZ 2048UL #define MBOX_HEADER_SZ 8 #define MBOX_INFO_SZ 4 /* MBOX size is 64B, 8B for mbox_header, 4B reserved */ #define MBOX_SEG_LEN 48 #define MBOX_SEG_LEN_ALIGN 4 #define MBOX_WB_STATUS_LEN 16UL /* mbox write back status is 16B, only first 4B is used */ #define MBOX_WB_STATUS_ERRCODE_MASK 0xFFFF #define MBOX_WB_STATUS_MASK 0xFF #define MBOX_WB_ERROR_CODE_MASK 0xFF00 #define MBOX_WB_STATUS_FINISHED_SUCCESS 0xFF #define MBOX_WB_STATUS_NOT_FINISHED 0x00 #define MBOX_STATUS_FINISHED(wb) \ (((wb) & MBOX_WB_STATUS_MASK) != MBOX_WB_STATUS_NOT_FINISHED) #define MBOX_STATUS_SUCCESS(wb) \ (((wb) & MBOX_WB_STATUS_MASK) == MBOX_WB_STATUS_FINISHED_SUCCESS) #define MBOX_STATUS_ERRCODE(wb) \ ((wb) & MBOX_WB_ERROR_CODE_MASK) #define SEQ_ID_START_VAL 0 #define SEQ_ID_MAX_VAL 42 #define NO_DMA_ATTRIBUTE_VAL 0 #define HINIC_MBOX_RSP_AEQN 2 #define HINIC_MBOX_RECV_AEQN 0 #define MBOX_MSG_NO_DATA_LEN 1 #define MBOX_BODY_FROM_HDR(header) ((u8 *)(header) + MBOX_HEADER_SZ) #define MBOX_AREA(hwif) \ ((hwif)->cfg_regs_bar + HINIC_FUNC_CSR_MAILBOX_DATA_OFF) #define IS_PF_OR_PPF_SRC(src_func_idx) ((src_func_idx) < HINIC_MAX_PF_FUNCS) #define MBOX_MSG_ID_MASK 0xFF #define MBOX_MSG_ID(func_to_func) ((func_to_func)->send_msg_id) #define MBOX_MSG_ID_INC(func_to_func_mbox) (MBOX_MSG_ID(func_to_func_mbox) = \ (MBOX_MSG_ID(func_to_func_mbox) + 1) & MBOX_MSG_ID_MASK) #define FUNC_ID_OFF_SET_8B 8 /* max message counter wait to process for one function */ #define HINIC_MAX_MSG_CNT_TO_PROCESS 10 #define HINIC_QUEUE_MIN_DEPTH 6 #define HINIC_QUEUE_MAX_DEPTH 12 #define HINIC_MAX_RX_BUFFER_SIZE 15 enum hinic_hwif_direction_type { HINIC_HWIF_DIRECT_SEND = 0, HINIC_HWIF_RESPONSE = 1, }; enum mbox_send_mod { MBOX_SEND_MSG_INT, }; enum mbox_seg_type { NOT_LAST_SEG, LAST_SEG, }; enum mbox_ordering_type { STRONG_ORDER, }; enum mbox_write_back_type { WRITE_BACK = 1, }; enum mbox_aeq_trig_type { NOT_TRIGGER, TRIGGER, }; static bool check_func_id(struct hinic_hwdev *hwdev, u16 src_func_idx, const void *buf_in, u16 in_size, u16 offset) { u16 func_idx; if (in_size < offset + sizeof(func_idx)) { dev_warn(&hwdev->hwif->pdev->dev, "Receive mailbox msg len: %d less than %d Bytes is invalid\n", in_size, offset); return false; } func_idx = *((u16 *)((u8 *)buf_in + offset)); if (src_func_idx != func_idx) { dev_warn(&hwdev->hwif->pdev->dev, "Receive mailbox function id: 0x%x not equal to msg function id: 0x%x\n", src_func_idx, func_idx); return false; } return true; } bool hinic_mbox_check_func_id_8B(struct hinic_hwdev *hwdev, u16 func_idx, void *buf_in, u16 in_size) { return check_func_id(hwdev, func_idx, buf_in, in_size, FUNC_ID_OFF_SET_8B); } /** * hinic_register_pf_mbox_cb - register mbox callback for pf * @hwdev: the pointer to hw device * @mod: specific mod that the callback will handle * @callback: callback function * Return: 0 - success, negative - failure */ int hinic_register_pf_mbox_cb(struct hinic_hwdev *hwdev, enum hinic_mod_type mod, hinic_pf_mbox_cb callback) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; if (mod >= HINIC_MOD_MAX) return -EFAULT; func_to_func->pf_mbox_cb[mod] = callback; set_bit(HINIC_PF_MBOX_CB_REG, &func_to_func->pf_mbox_cb_state[mod]); return 0; } /** * hinic_register_vf_mbox_cb - register mbox callback for vf * @hwdev: the pointer to hw device * @mod: specific mod that the callback will handle * @callback: callback function * Return: 0 - success, negative - failure */ int hinic_register_vf_mbox_cb(struct hinic_hwdev *hwdev, enum hinic_mod_type mod, hinic_vf_mbox_cb callback) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; if (mod >= HINIC_MOD_MAX) return -EFAULT; func_to_func->vf_mbox_cb[mod] = callback; set_bit(HINIC_VF_MBOX_CB_REG, &func_to_func->vf_mbox_cb_state[mod]); return 0; } /** * hinic_unregister_pf_mbox_cb - unregister the mbox callback for pf * @hwdev: the pointer to hw device * @mod: specific mod that the callback will handle */ void hinic_unregister_pf_mbox_cb(struct hinic_hwdev *hwdev, enum hinic_mod_type mod) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; clear_bit(HINIC_PF_MBOX_CB_REG, &func_to_func->pf_mbox_cb_state[mod]); while (test_bit(HINIC_PF_MBOX_CB_RUNNING, &func_to_func->pf_mbox_cb_state[mod])) usleep_range(900, 1000); func_to_func->pf_mbox_cb[mod] = NULL; } /** * hinic_unregister_vf_mbox_cb - unregister the mbox callback for vf * @hwdev: the pointer to hw device * @mod: specific mod that the callback will handle */ void hinic_unregister_vf_mbox_cb(struct hinic_hwdev *hwdev, enum hinic_mod_type mod) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; clear_bit(HINIC_VF_MBOX_CB_REG, &func_to_func->vf_mbox_cb_state[mod]); while (test_bit(HINIC_VF_MBOX_CB_RUNNING, &func_to_func->vf_mbox_cb_state[mod])) usleep_range(900, 1000); func_to_func->vf_mbox_cb[mod] = NULL; } static int recv_vf_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox, void *buf_out, u16 *out_size) { hinic_vf_mbox_cb cb; int ret = 0; if (recv_mbox->mod >= HINIC_MOD_MAX) { dev_err(&func_to_func->hwif->pdev->dev, "Receive illegal mbox message, mod = %d\n", recv_mbox->mod); return -EINVAL; } set_bit(HINIC_VF_MBOX_CB_RUNNING, &func_to_func->vf_mbox_cb_state[recv_mbox->mod]); cb = func_to_func->vf_mbox_cb[recv_mbox->mod]; if (cb && test_bit(HINIC_VF_MBOX_CB_REG, &func_to_func->vf_mbox_cb_state[recv_mbox->mod])) { cb(func_to_func->hwdev, recv_mbox->cmd, recv_mbox->mbox, recv_mbox->mbox_len, buf_out, out_size); } else { dev_err(&func_to_func->hwif->pdev->dev, "VF mbox cb is not registered\n"); ret = -EINVAL; } clear_bit(HINIC_VF_MBOX_CB_RUNNING, &func_to_func->vf_mbox_cb_state[recv_mbox->mod]); return ret; } static int recv_pf_from_vf_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox, u16 src_func_idx, void *buf_out, u16 *out_size) { hinic_pf_mbox_cb cb; u16 vf_id = 0; int ret; if (recv_mbox->mod >= HINIC_MOD_MAX) { dev_err(&func_to_func->hwif->pdev->dev, "Receive illegal mbox message, mod = %d\n", recv_mbox->mod); return -EINVAL; } set_bit(HINIC_PF_MBOX_CB_RUNNING, &func_to_func->pf_mbox_cb_state[recv_mbox->mod]); cb = func_to_func->pf_mbox_cb[recv_mbox->mod]; if (cb && test_bit(HINIC_PF_MBOX_CB_REG, &func_to_func->pf_mbox_cb_state[recv_mbox->mod])) { vf_id = src_func_idx - hinic_glb_pf_vf_offset(func_to_func->hwif); ret = cb(func_to_func->hwdev, vf_id, recv_mbox->cmd, recv_mbox->mbox, recv_mbox->mbox_len, buf_out, out_size); } else { dev_err(&func_to_func->hwif->pdev->dev, "PF mbox mod(0x%x) cb is not registered\n", recv_mbox->mod); ret = -EINVAL; } clear_bit(HINIC_PF_MBOX_CB_RUNNING, &func_to_func->pf_mbox_cb_state[recv_mbox->mod]); return ret; } static bool check_mbox_seq_id_and_seg_len(struct hinic_recv_mbox *recv_mbox, u8 seq_id, u8 seg_len) { if (seq_id > SEQ_ID_MAX_VAL || seg_len > MBOX_SEG_LEN) return false; if (seq_id == 0) { recv_mbox->seq_id = seq_id; } else { if (seq_id != recv_mbox->seq_id + 1) return false; recv_mbox->seq_id = seq_id; } return true; } static void resp_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox) { spin_lock(&func_to_func->mbox_lock); if (recv_mbox->msg_info.msg_id == func_to_func->send_msg_id && func_to_func->event_flag == EVENT_START) complete(&recv_mbox->recv_done); else dev_err(&func_to_func->hwif->pdev->dev, "Mbox response timeout, current send msg id(0x%x), recv msg id(0x%x), status(0x%x)\n", func_to_func->send_msg_id, recv_mbox->msg_info.msg_id, recv_mbox->msg_info.status); spin_unlock(&func_to_func->mbox_lock); } static void recv_func_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox, u16 src_func_idx); static void recv_func_mbox_work_handler(struct work_struct *work) { struct hinic_mbox_work *mbox_work = container_of(work, struct hinic_mbox_work, work); struct hinic_recv_mbox *recv_mbox; recv_func_mbox_handler(mbox_work->func_to_func, mbox_work->recv_mbox, mbox_work->src_func_idx); recv_mbox = &mbox_work->func_to_func->mbox_send[mbox_work->src_func_idx]; atomic_dec(&recv_mbox->msg_cnt); kfree(mbox_work); } static void recv_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, void *header, struct hinic_recv_mbox *recv_mbox) { void *mbox_body = MBOX_BODY_FROM_HDR(header); struct hinic_recv_mbox *rcv_mbox_temp = NULL; u64 mbox_header = *((u64 *)header); struct hinic_mbox_work *mbox_work; u8 seq_id, seg_len; u16 src_func_idx; int pos; seq_id = HINIC_MBOX_HEADER_GET(mbox_header, SEQID); seg_len = HINIC_MBOX_HEADER_GET(mbox_header, SEG_LEN); src_func_idx = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX); if (!check_mbox_seq_id_and_seg_len(recv_mbox, seq_id, seg_len)) { dev_err(&func_to_func->hwif->pdev->dev, "Mailbox sequence and segment check fail, src func id: 0x%x, front id: 0x%x, current id: 0x%x, seg len: 0x%x\n", src_func_idx, recv_mbox->seq_id, seq_id, seg_len); recv_mbox->seq_id = SEQ_ID_MAX_VAL; return; } pos = seq_id * MBOX_SEG_LEN; memcpy((u8 *)recv_mbox->mbox + pos, mbox_body, HINIC_MBOX_HEADER_GET(mbox_header, SEG_LEN)); if (!HINIC_MBOX_HEADER_GET(mbox_header, LAST)) return; recv_mbox->cmd = HINIC_MBOX_HEADER_GET(mbox_header, CMD); recv_mbox->mod = HINIC_MBOX_HEADER_GET(mbox_header, MODULE); recv_mbox->mbox_len = HINIC_MBOX_HEADER_GET(mbox_header, MSG_LEN); recv_mbox->ack_type = HINIC_MBOX_HEADER_GET(mbox_header, NO_ACK); recv_mbox->msg_info.msg_id = HINIC_MBOX_HEADER_GET(mbox_header, MSG_ID); recv_mbox->msg_info.status = HINIC_MBOX_HEADER_GET(mbox_header, STATUS); recv_mbox->seq_id = SEQ_ID_MAX_VAL; if (HINIC_MBOX_HEADER_GET(mbox_header, DIRECTION) == HINIC_HWIF_RESPONSE) { resp_mbox_handler(func_to_func, recv_mbox); return; } if (atomic_read(&recv_mbox->msg_cnt) > HINIC_MAX_MSG_CNT_TO_PROCESS) { dev_warn(&func_to_func->hwif->pdev->dev, "This function(%u) have %d message wait to process,can't add to work queue\n", src_func_idx, atomic_read(&recv_mbox->msg_cnt)); return; } rcv_mbox_temp = kmemdup(recv_mbox, sizeof(*rcv_mbox_temp), GFP_KERNEL); if (!rcv_mbox_temp) return; rcv_mbox_temp->mbox = kmemdup(recv_mbox->mbox, MBOX_MAX_BUF_SZ, GFP_KERNEL); if (!rcv_mbox_temp->mbox) goto err_alloc_rcv_mbox_msg; rcv_mbox_temp->buf_out = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL); if (!rcv_mbox_temp->buf_out) goto err_alloc_rcv_mbox_buf; mbox_work = kzalloc(sizeof(*mbox_work), GFP_KERNEL); if (!mbox_work) goto err_alloc_mbox_work; mbox_work->func_to_func = func_to_func; mbox_work->recv_mbox = rcv_mbox_temp; mbox_work->src_func_idx = src_func_idx; atomic_inc(&recv_mbox->msg_cnt); INIT_WORK(&mbox_work->work, recv_func_mbox_work_handler); queue_work(func_to_func->workq, &mbox_work->work); return; err_alloc_mbox_work: kfree(rcv_mbox_temp->buf_out); err_alloc_rcv_mbox_buf: kfree(rcv_mbox_temp->mbox); err_alloc_rcv_mbox_msg: kfree(rcv_mbox_temp); } static int set_vf_mbox_random_id(struct hinic_hwdev *hwdev, u16 func_id) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; struct hinic_set_random_id rand_info = {0}; u16 out_size = sizeof(rand_info); struct hinic_pfhwdev *pfhwdev; int ret; pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev); rand_info.version = HINIC_CMD_VER_FUNC_ID; rand_info.func_idx = func_id; rand_info.vf_in_pf = func_id - hinic_glb_pf_vf_offset(hwdev->hwif); rand_info.random_id = get_random_u32(); func_to_func->vf_mbx_rand_id[func_id] = rand_info.random_id; ret = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM, HINIC_MGMT_CMD_SET_VF_RANDOM_ID, &rand_info, sizeof(rand_info), &rand_info, &out_size, HINIC_MGMT_MSG_SYNC); if ((rand_info.status != HINIC_MGMT_CMD_UNSUPPORTED && rand_info.status) || !out_size || ret) { dev_err(&hwdev->hwif->pdev->dev, "Set VF random id failed, err: %d, status: 0x%x, out size: 0x%x\n", ret, rand_info.status, out_size); return -EIO; } if (rand_info.status == HINIC_MGMT_CMD_UNSUPPORTED) return rand_info.status; func_to_func->vf_mbx_old_rand_id[func_id] = func_to_func->vf_mbx_rand_id[func_id]; return 0; } static void update_random_id_work_handler(struct work_struct *work) { struct hinic_mbox_work *mbox_work = container_of(work, struct hinic_mbox_work, work); struct hinic_mbox_func_to_func *func_to_func; u16 src = mbox_work->src_func_idx; func_to_func = mbox_work->func_to_func; if (set_vf_mbox_random_id(func_to_func->hwdev, src)) dev_warn(&func_to_func->hwdev->hwif->pdev->dev, "Update VF id: 0x%x random id failed\n", mbox_work->src_func_idx); kfree(mbox_work); } static bool check_vf_mbox_random_id(struct hinic_mbox_func_to_func *func_to_func, u8 *header) { struct hinic_hwdev *hwdev = func_to_func->hwdev; struct hinic_mbox_work *mbox_work = NULL; u64 mbox_header = *((u64 *)header); u16 offset, src; u32 random_id; int vf_in_pf; src = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX); if (IS_PF_OR_PPF_SRC(src) || !func_to_func->support_vf_random) return true; if (!HINIC_IS_PPF(hwdev->hwif)) { offset = hinic_glb_pf_vf_offset(hwdev->hwif); vf_in_pf = src - offset; if (vf_in_pf < 1 || vf_in_pf > hwdev->nic_cap.max_vf) { dev_warn(&hwdev->hwif->pdev->dev, "Receive vf id(0x%x) is invalid, vf id should be from 0x%x to 0x%x\n", src, offset + 1, hwdev->nic_cap.max_vf + offset); return false; } } random_id = be32_to_cpu(*(u32 *)(header + MBOX_SEG_LEN + MBOX_HEADER_SZ)); if (random_id == func_to_func->vf_mbx_rand_id[src] || random_id == func_to_func->vf_mbx_old_rand_id[src]) return true; dev_warn(&hwdev->hwif->pdev->dev, "The mailbox random id(0x%x) of func_id(0x%x) doesn't match with pf reservation(0x%x)\n", random_id, src, func_to_func->vf_mbx_rand_id[src]); mbox_work = kzalloc(sizeof(*mbox_work), GFP_KERNEL); if (!mbox_work) return false; mbox_work->func_to_func = func_to_func; mbox_work->src_func_idx = src; INIT_WORK(&mbox_work->work, update_random_id_work_handler); queue_work(func_to_func->workq, &mbox_work->work); return false; } static void hinic_mbox_func_aeqe_handler(void *handle, void *header, u8 size) { struct hinic_mbox_func_to_func *func_to_func; u64 mbox_header = *((u64 *)header); struct hinic_recv_mbox *recv_mbox; u64 src, dir; func_to_func = ((struct hinic_hwdev *)handle)->func_to_func; dir = HINIC_MBOX_HEADER_GET(mbox_header, DIRECTION); src = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX); if (src >= HINIC_MAX_FUNCTIONS) { dev_err(&func_to_func->hwif->pdev->dev, "Mailbox source function id:%u is invalid\n", (u32)src); return; } if (!check_vf_mbox_random_id(func_to_func, header)) return; recv_mbox = (dir == HINIC_HWIF_DIRECT_SEND) ? &func_to_func->mbox_send[src] : &func_to_func->mbox_resp[src]; recv_mbox_handler(func_to_func, (u64 *)header, recv_mbox); } static void hinic_mbox_self_aeqe_handler(void *handle, void *header, u8 size) { struct hinic_mbox_func_to_func *func_to_func; struct hinic_send_mbox *send_mbox; func_to_func = ((struct hinic_hwdev *)handle)->func_to_func; send_mbox = &func_to_func->send_mbox; complete(&send_mbox->send_done); } static void clear_mbox_status(struct hinic_send_mbox *mbox) { *mbox->wb_status = 0; /* clear mailbox write back status */ wmb(); } static void mbox_copy_header(struct hinic_hwdev *hwdev, struct hinic_send_mbox *mbox, u64 *header) { u32 i, idx_max = MBOX_HEADER_SZ / sizeof(u32); u32 *data = (u32 *)header; for (i = 0; i < idx_max; i++) __raw_writel(*(data + i), mbox->data + i * sizeof(u32)); } static void mbox_copy_send_data(struct hinic_hwdev *hwdev, struct hinic_send_mbox *mbox, void *seg, u16 seg_len) { u8 mbox_max_buf[MBOX_SEG_LEN] = {0}; u32 data_len, chk_sz = sizeof(u32); u32 *data = seg; u32 i, idx_max; /* The mbox message should be aligned in 4 bytes. */ if (seg_len % chk_sz) { memcpy(mbox_max_buf, seg, seg_len); data = (u32 *)mbox_max_buf; } data_len = seg_len; idx_max = ALIGN(data_len, chk_sz) / chk_sz; for (i = 0; i < idx_max; i++) __raw_writel(*(data + i), mbox->data + MBOX_HEADER_SZ + i * sizeof(u32)); } static void write_mbox_msg_attr(struct hinic_mbox_func_to_func *func_to_func, u16 dst_func, u16 dst_aeqn, u16 seg_len, int poll) { u16 rsp_aeq = (dst_aeqn == 0) ? 0 : HINIC_MBOX_RSP_AEQN; u32 mbox_int, mbox_ctrl; mbox_int = HINIC_MBOX_INT_SET(dst_func, DST_FUNC) | HINIC_MBOX_INT_SET(dst_aeqn, DST_AEQN) | HINIC_MBOX_INT_SET(rsp_aeq, SRC_RESP_AEQN) | HINIC_MBOX_INT_SET(NO_DMA_ATTRIBUTE_VAL, STAT_DMA) | HINIC_MBOX_INT_SET(ALIGN(MBOX_SEG_LEN + MBOX_HEADER_SZ + MBOX_INFO_SZ, MBOX_SEG_LEN_ALIGN) >> 2, TX_SIZE) | HINIC_MBOX_INT_SET(STRONG_ORDER, STAT_DMA_SO_RO) | HINIC_MBOX_INT_SET(WRITE_BACK, WB_EN); hinic_hwif_write_reg(func_to_func->hwif, HINIC_FUNC_CSR_MAILBOX_INT_OFFSET_OFF, mbox_int); wmb(); /* writing the mbox int attributes */ mbox_ctrl = HINIC_MBOX_CTRL_SET(TX_NOT_DONE, TX_STATUS); if (poll) mbox_ctrl |= HINIC_MBOX_CTRL_SET(NOT_TRIGGER, TRIGGER_AEQE); else mbox_ctrl |= HINIC_MBOX_CTRL_SET(TRIGGER, TRIGGER_AEQE); hinic_hwif_write_reg(func_to_func->hwif, HINIC_FUNC_CSR_MAILBOX_CONTROL_OFF, mbox_ctrl); } static void dump_mox_reg(struct hinic_hwdev *hwdev) { u32 val; val = hinic_hwif_read_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_CONTROL_OFF); dev_err(&hwdev->hwif->pdev->dev, "Mailbox control reg: 0x%x\n", val); val = hinic_hwif_read_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_INT_OFFSET_OFF); dev_err(&hwdev->hwif->pdev->dev, "Mailbox interrupt offset: 0x%x\n", val); } static u16 get_mbox_status(struct hinic_send_mbox *mbox) { /* write back is 16B, but only use first 4B */ u64 wb_val = be64_to_cpu(*mbox->wb_status); rmb(); /* verify reading before check */ return (u16)(wb_val & MBOX_WB_STATUS_ERRCODE_MASK); } static int wait_for_mbox_seg_completion(struct hinic_mbox_func_to_func *func_to_func, int poll, u16 *wb_status) { struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox; struct hinic_hwdev *hwdev = func_to_func->hwdev; struct completion *done = &send_mbox->send_done; u32 cnt = 0; unsigned long jif; if (poll) { while (cnt < MBOX_MSG_POLLING_TIMEOUT) { *wb_status = get_mbox_status(send_mbox); if (MBOX_STATUS_FINISHED(*wb_status)) break; usleep_range(900, 1000); cnt++; } if (cnt == MBOX_MSG_POLLING_TIMEOUT) { dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment timeout, wb status: 0x%x\n", *wb_status); dump_mox_reg(hwdev); return -ETIMEDOUT; } } else { jif = msecs_to_jiffies(HINIC_MBOX_COMP_TIME); if (!wait_for_completion_timeout(done, jif)) { dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment timeout\n"); dump_mox_reg(hwdev); hinic_dump_aeq_info(hwdev); return -ETIMEDOUT; } *wb_status = get_mbox_status(send_mbox); } return 0; } static int send_mbox_seg(struct hinic_mbox_func_to_func *func_to_func, u64 header, u16 dst_func, void *seg, u16 seg_len, int poll, void *msg_info) { struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox; u16 seq_dir = HINIC_MBOX_HEADER_GET(header, DIRECTION); struct hinic_hwdev *hwdev = func_to_func->hwdev; struct completion *done = &send_mbox->send_done; u8 num_aeqs = hwdev->hwif->attr.num_aeqs; u16 dst_aeqn, wb_status = 0, errcode; if (num_aeqs >= 4) dst_aeqn = (seq_dir == HINIC_HWIF_DIRECT_SEND) ? HINIC_MBOX_RECV_AEQN : HINIC_MBOX_RSP_AEQN; else dst_aeqn = 0; if (!poll) init_completion(done); clear_mbox_status(send_mbox); mbox_copy_header(hwdev, send_mbox, &header); mbox_copy_send_data(hwdev, send_mbox, seg, seg_len); write_mbox_msg_attr(func_to_func, dst_func, dst_aeqn, seg_len, poll); wmb(); /* writing the mbox msg attributes */ if (wait_for_mbox_seg_completion(func_to_func, poll, &wb_status)) return -ETIMEDOUT; if (!MBOX_STATUS_SUCCESS(wb_status)) { dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment to function %d error, wb status: 0x%x\n", dst_func, wb_status); errcode = MBOX_STATUS_ERRCODE(wb_status); return errcode ? errcode : -EFAULT; } return 0; } static int send_mbox_to_func(struct hinic_mbox_func_to_func *func_to_func, enum hinic_mod_type mod, u16 cmd, void *msg, u16 msg_len, u16 dst_func, enum hinic_hwif_direction_type direction, enum hinic_mbox_ack_type ack_type, struct mbox_msg_info *msg_info) { struct hinic_hwdev *hwdev = func_to_func->hwdev; u16 seg_len = MBOX_SEG_LEN; u8 *msg_seg = (u8 *)msg; u16 left = msg_len; u32 seq_id = 0; u64 header = 0; int err = 0; down(&func_to_func->msg_send_sem); header = HINIC_MBOX_HEADER_SET(msg_len, MSG_LEN) | HINIC_MBOX_HEADER_SET(mod, MODULE) | HINIC_MBOX_HEADER_SET(seg_len, SEG_LEN) | HINIC_MBOX_HEADER_SET(ack_type, NO_ACK) | HINIC_MBOX_HEADER_SET(SEQ_ID_START_VAL, SEQID) | HINIC_MBOX_HEADER_SET(NOT_LAST_SEG, LAST) | HINIC_MBOX_HEADER_SET(direction, DIRECTION) | HINIC_MBOX_HEADER_SET(cmd, CMD) | /* The vf's offset to it's associated pf */ HINIC_MBOX_HEADER_SET(msg_info->msg_id, MSG_ID) | HINIC_MBOX_HEADER_SET(msg_info->status, STATUS) | HINIC_MBOX_HEADER_SET(hinic_global_func_id_hw(hwdev->hwif), SRC_GLB_FUNC_IDX); while (!(HINIC_MBOX_HEADER_GET(header, LAST))) { if (left <= HINIC_MBOX_SEG_LEN) { header &= ~MBOX_SEGLEN_MASK; header |= HINIC_MBOX_HEADER_SET(left, SEG_LEN); header |= HINIC_MBOX_HEADER_SET(LAST_SEG, LAST); seg_len = left; } err = send_mbox_seg(func_to_func, header, dst_func, msg_seg, seg_len, MBOX_SEND_MSG_INT, msg_info); if (err) { dev_err(&hwdev->hwif->pdev->dev, "Failed to send mbox seg, seq_id=0x%llx\n", HINIC_MBOX_HEADER_GET(header, SEQID)); goto err_send_mbox_seg; } left -= HINIC_MBOX_SEG_LEN; msg_seg += HINIC_MBOX_SEG_LEN; seq_id++; header &= ~(HINIC_MBOX_HEADER_SET(HINIC_MBOX_HEADER_SEQID_MASK, SEQID)); header |= HINIC_MBOX_HEADER_SET(seq_id, SEQID); } err_send_mbox_seg: up(&func_to_func->msg_send_sem); return err; } static void response_for_recv_func_mbox(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox, int err, u16 out_size, u16 src_func_idx) { struct mbox_msg_info msg_info = {0}; if (recv_mbox->ack_type == MBOX_ACK) { msg_info.msg_id = recv_mbox->msg_info.msg_id; if (err == HINIC_MBOX_PF_BUSY_ACTIVE_FW) msg_info.status = HINIC_MBOX_PF_BUSY_ACTIVE_FW; else if (err == HINIC_MBOX_VF_CMD_ERROR) msg_info.status = HINIC_MBOX_VF_CMD_ERROR; else if (err) msg_info.status = HINIC_MBOX_PF_SEND_ERR; /* if no data needs to response, set out_size to 1 */ if (!out_size || err) out_size = MBOX_MSG_NO_DATA_LEN; send_mbox_to_func(func_to_func, recv_mbox->mod, recv_mbox->cmd, recv_mbox->buf_out, out_size, src_func_idx, HINIC_HWIF_RESPONSE, MBOX_ACK, &msg_info); } } static void recv_func_mbox_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *recv_mbox, u16 src_func_idx) { void *buf_out = recv_mbox->buf_out; u16 out_size = MBOX_MAX_BUF_SZ; int err = 0; if (HINIC_IS_VF(func_to_func->hwif)) { err = recv_vf_mbox_handler(func_to_func, recv_mbox, buf_out, &out_size); } else { if (IS_PF_OR_PPF_SRC(src_func_idx)) dev_warn(&func_to_func->hwif->pdev->dev, "Unsupported pf2pf mbox msg\n"); else err = recv_pf_from_vf_mbox_handler(func_to_func, recv_mbox, src_func_idx, buf_out, &out_size); } response_for_recv_func_mbox(func_to_func, recv_mbox, err, out_size, src_func_idx); kfree(recv_mbox->buf_out); kfree(recv_mbox->mbox); kfree(recv_mbox); } static void set_mbox_to_func_event(struct hinic_mbox_func_to_func *func_to_func, enum mbox_event_state event_flag) { spin_lock(&func_to_func->mbox_lock); func_to_func->event_flag = event_flag; spin_unlock(&func_to_func->mbox_lock); } static int mbox_resp_info_handler(struct hinic_mbox_func_to_func *func_to_func, struct hinic_recv_mbox *mbox_for_resp, enum hinic_mod_type mod, u16 cmd, void *buf_out, u16 *out_size) { int err; if (mbox_for_resp->msg_info.status) { err = mbox_for_resp->msg_info.status; if (err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) dev_err(&func_to_func->hwif->pdev->dev, "Mbox response error(0x%x)\n", mbox_for_resp->msg_info.status); return err; } if (buf_out && out_size) { if (*out_size < mbox_for_resp->mbox_len) { dev_err(&func_to_func->hwif->pdev->dev, "Invalid response mbox message length: %d for mod %d cmd %d, should less than: %d\n", mbox_for_resp->mbox_len, mod, cmd, *out_size); return -EFAULT; } if (mbox_for_resp->mbox_len) memcpy(buf_out, mbox_for_resp->mbox, mbox_for_resp->mbox_len); *out_size = mbox_for_resp->mbox_len; } return 0; } int hinic_mbox_to_func(struct hinic_mbox_func_to_func *func_to_func, enum hinic_mod_type mod, u16 cmd, u16 dst_func, void *buf_in, u16 in_size, void *buf_out, u16 *out_size, u32 timeout) { struct hinic_recv_mbox *mbox_for_resp; struct mbox_msg_info msg_info = {0}; unsigned long timeo; int err; mbox_for_resp = &func_to_func->mbox_resp[dst_func]; down(&func_to_func->mbox_send_sem); init_completion(&mbox_for_resp->recv_done); msg_info.msg_id = MBOX_MSG_ID_INC(func_to_func); set_mbox_to_func_event(func_to_func, EVENT_START); err = send_mbox_to_func(func_to_func, mod, cmd, buf_in, in_size, dst_func, HINIC_HWIF_DIRECT_SEND, MBOX_ACK, &msg_info); if (err) { dev_err(&func_to_func->hwif->pdev->dev, "Send mailbox failed, msg_id: %d\n", msg_info.msg_id); set_mbox_to_func_event(func_to_func, EVENT_FAIL); goto err_send_mbox; } timeo = msecs_to_jiffies(timeout ? timeout : HINIC_MBOX_COMP_TIME); if (!wait_for_completion_timeout(&mbox_for_resp->recv_done, timeo)) { set_mbox_to_func_event(func_to_func, EVENT_TIMEOUT); dev_err(&func_to_func->hwif->pdev->dev, "Send mbox msg timeout, msg_id: %d\n", msg_info.msg_id); hinic_dump_aeq_info(func_to_func->hwdev); err = -ETIMEDOUT; goto err_send_mbox; } set_mbox_to_func_event(func_to_func, EVENT_END); err = mbox_resp_info_handler(func_to_func, mbox_for_resp, mod, cmd, buf_out, out_size); err_send_mbox: up(&func_to_func->mbox_send_sem); return err; } static int mbox_func_params_valid(struct hinic_mbox_func_to_func *func_to_func, void *buf_in, u16 in_size) { if (in_size > HINIC_MBOX_DATA_SIZE) { dev_err(&func_to_func->hwif->pdev->dev, "Mbox msg len(%d) exceed limit(%d)\n", in_size, HINIC_MBOX_DATA_SIZE); return -EINVAL; } return 0; } int hinic_mbox_to_pf(struct hinic_hwdev *hwdev, enum hinic_mod_type mod, u8 cmd, void *buf_in, u16 in_size, void *buf_out, u16 *out_size, u32 timeout) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; int err = mbox_func_params_valid(func_to_func, buf_in, in_size); if (err) return err; if (!HINIC_IS_VF(hwdev->hwif)) { dev_err(&hwdev->hwif->pdev->dev, "Params error, func_type: %d\n", HINIC_FUNC_TYPE(hwdev->hwif)); return -EINVAL; } return hinic_mbox_to_func(func_to_func, mod, cmd, hinic_pf_id_of_vf_hw(hwdev->hwif), buf_in, in_size, buf_out, out_size, timeout); } int hinic_mbox_to_vf(struct hinic_hwdev *hwdev, enum hinic_mod_type mod, u16 vf_id, u8 cmd, void *buf_in, u16 in_size, void *buf_out, u16 *out_size, u32 timeout) { struct hinic_mbox_func_to_func *func_to_func; u16 dst_func_idx; int err; if (!hwdev) return -EINVAL; func_to_func = hwdev->func_to_func; err = mbox_func_params_valid(func_to_func, buf_in, in_size); if (err) return err; if (HINIC_IS_VF(hwdev->hwif)) { dev_err(&hwdev->hwif->pdev->dev, "Params error, func_type: %d\n", HINIC_FUNC_TYPE(hwdev->hwif)); return -EINVAL; } if (!vf_id) { dev_err(&hwdev->hwif->pdev->dev, "VF id(%d) error!\n", vf_id); return -EINVAL; } /* vf_offset_to_pf + vf_id is the vf's global function id of vf in * this pf */ dst_func_idx = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id; return hinic_mbox_to_func(func_to_func, mod, cmd, dst_func_idx, buf_in, in_size, buf_out, out_size, timeout); } static int init_mbox_info(struct hinic_recv_mbox *mbox_info) { int err; mbox_info->seq_id = SEQ_ID_MAX_VAL; mbox_info->mbox = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL); if (!mbox_info->mbox) return -ENOMEM; mbox_info->buf_out = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL); if (!mbox_info->buf_out) { err = -ENOMEM; goto err_alloc_buf_out; } atomic_set(&mbox_info->msg_cnt, 0); return 0; err_alloc_buf_out: kfree(mbox_info->mbox); return err; } static void clean_mbox_info(struct hinic_recv_mbox *mbox_info) { kfree(mbox_info->buf_out); kfree(mbox_info->mbox); } static int alloc_mbox_info(struct hinic_hwdev *hwdev, struct hinic_recv_mbox *mbox_info) { u16 func_idx, i; int err; for (func_idx = 0; func_idx < HINIC_MAX_FUNCTIONS; func_idx++) { err = init_mbox_info(&mbox_info[func_idx]); if (err) { dev_err(&hwdev->hwif->pdev->dev, "Failed to init function %d mbox info\n", func_idx); goto err_init_mbox_info; } } return 0; err_init_mbox_info: for (i = 0; i < func_idx; i++) clean_mbox_info(&mbox_info[i]); return err; } static void free_mbox_info(struct hinic_recv_mbox *mbox_info) { u16 func_idx; for (func_idx = 0; func_idx < HINIC_MAX_FUNCTIONS; func_idx++) clean_mbox_info(&mbox_info[func_idx]); } static void prepare_send_mbox(struct hinic_mbox_func_to_func *func_to_func) { struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox; send_mbox->data = MBOX_AREA(func_to_func->hwif); } static int alloc_mbox_wb_status(struct hinic_mbox_func_to_func *func_to_func) { struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox; struct hinic_hwdev *hwdev = func_to_func->hwdev; u32 addr_h, addr_l; send_mbox->wb_vaddr = dma_alloc_coherent(&hwdev->hwif->pdev->dev, MBOX_WB_STATUS_LEN, &send_mbox->wb_paddr, GFP_KERNEL); if (!send_mbox->wb_vaddr) return -ENOMEM; send_mbox->wb_status = send_mbox->wb_vaddr; addr_h = upper_32_bits(send_mbox->wb_paddr); addr_l = lower_32_bits(send_mbox->wb_paddr); hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_H_OFF, addr_h); hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_L_OFF, addr_l); return 0; } static void free_mbox_wb_status(struct hinic_mbox_func_to_func *func_to_func) { struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox; struct hinic_hwdev *hwdev = func_to_func->hwdev; hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_H_OFF, 0); hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_L_OFF, 0); dma_free_coherent(&hwdev->hwif->pdev->dev, MBOX_WB_STATUS_LEN, send_mbox->wb_vaddr, send_mbox->wb_paddr); } bool hinic_mbox_check_cmd_valid(struct hinic_hwdev *hwdev, struct vf_cmd_check_handle *cmd_handle, u16 vf_id, u8 cmd, void *buf_in, u16 in_size, u8 size) { u16 src_idx = vf_id + hinic_glb_pf_vf_offset(hwdev->hwif); int i; for (i = 0; i < size; i++) { if (cmd == cmd_handle[i].cmd) { if (cmd_handle[i].check_cmd) return cmd_handle[i].check_cmd(hwdev, src_idx, buf_in, in_size); else return true; } } dev_err(&hwdev->hwif->pdev->dev, "PF Receive VF(%d) unsupported cmd(0x%x)\n", vf_id + hinic_glb_pf_vf_offset(hwdev->hwif), cmd); return false; } static bool hinic_cmdq_check_vf_ctxt(struct hinic_hwdev *hwdev, struct hinic_cmdq_ctxt *cmdq_ctxt) { struct hinic_cmdq_ctxt_info *ctxt_info = &cmdq_ctxt->ctxt_info; u64 curr_pg_pfn, wq_block_pfn; if (cmdq_ctxt->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif) || cmdq_ctxt->cmdq_type > HINIC_MAX_CMDQ_TYPES) return false; curr_pg_pfn = HINIC_CMDQ_CTXT_PAGE_INFO_GET (ctxt_info->curr_wqe_page_pfn, CURR_WQE_PAGE_PFN); wq_block_pfn = HINIC_CMDQ_CTXT_BLOCK_INFO_GET (ctxt_info->wq_block_pfn, WQ_BLOCK_PFN); /* VF must use 0-level CLA */ if (curr_pg_pfn != wq_block_pfn) return false; return true; } static bool check_cmdq_ctxt(struct hinic_hwdev *hwdev, u16 func_idx, void *buf_in, u16 in_size) { if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size)) return false; return hinic_cmdq_check_vf_ctxt(hwdev, buf_in); } #define HW_CTX_QPS_VALID(hw_ctxt) \ ((hw_ctxt)->rq_depth >= HINIC_QUEUE_MIN_DEPTH && \ (hw_ctxt)->rq_depth <= HINIC_QUEUE_MAX_DEPTH && \ (hw_ctxt)->sq_depth >= HINIC_QUEUE_MIN_DEPTH && \ (hw_ctxt)->sq_depth <= HINIC_QUEUE_MAX_DEPTH && \ (hw_ctxt)->rx_buf_sz_idx <= HINIC_MAX_RX_BUFFER_SIZE) static bool hw_ctxt_qps_param_valid(struct hinic_cmd_hw_ioctxt *hw_ctxt) { if (HW_CTX_QPS_VALID(hw_ctxt)) return true; if (!hw_ctxt->rq_depth && !hw_ctxt->sq_depth && !hw_ctxt->rx_buf_sz_idx) return true; return false; } static bool check_hwctxt(struct hinic_hwdev *hwdev, u16 func_idx, void *buf_in, u16 in_size) { struct hinic_cmd_hw_ioctxt *hw_ctxt = buf_in; if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size)) return false; if (hw_ctxt->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif)) return false; if (hw_ctxt->set_cmdq_depth) { if (hw_ctxt->cmdq_depth >= HINIC_QUEUE_MIN_DEPTH && hw_ctxt->cmdq_depth <= HINIC_QUEUE_MAX_DEPTH) return true; return false; } return hw_ctxt_qps_param_valid(hw_ctxt); } static bool check_set_wq_page_size(struct hinic_hwdev *hwdev, u16 func_idx, void *buf_in, u16 in_size) { struct hinic_wq_page_size *page_size_info = buf_in; if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size)) return false; if (page_size_info->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif)) return false; if (((1U << page_size_info->page_size) * SZ_4K) != HINIC_DEFAULT_WQ_PAGE_SIZE) return false; return true; } static struct vf_cmd_check_handle hw_cmd_support_vf[] = { {HINIC_COMM_CMD_START_FLR, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_DMA_ATTR_SET, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_CMDQ_CTXT_SET, check_cmdq_ctxt}, {HINIC_COMM_CMD_CMDQ_CTXT_GET, check_cmdq_ctxt}, {HINIC_COMM_CMD_HWCTXT_SET, check_hwctxt}, {HINIC_COMM_CMD_HWCTXT_GET, check_hwctxt}, {HINIC_COMM_CMD_SQ_HI_CI_SET, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_RES_STATE_SET, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_IO_RES_CLEAR, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_CEQ_CTRL_REG_WR_BY_UP, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_MSI_CTRL_REG_WR_BY_UP, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_MSI_CTRL_REG_RD_BY_UP, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_L2NIC_RESET, hinic_mbox_check_func_id_8B}, {HINIC_COMM_CMD_PAGESIZE_SET, check_set_wq_page_size}, }; static int comm_pf_mbox_handler(void *handle, u16 vf_id, u8 cmd, void *buf_in, u16 in_size, void *buf_out, u16 *out_size) { u8 size = ARRAY_SIZE(hw_cmd_support_vf); struct hinic_hwdev *hwdev = handle; struct hinic_pfhwdev *pfhwdev; int err = 0; pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev); if (!hinic_mbox_check_cmd_valid(handle, hw_cmd_support_vf, vf_id, cmd, buf_in, in_size, size)) { dev_err(&hwdev->hwif->pdev->dev, "PF Receive VF: %d common cmd: 0x%x or mbox len: 0x%x is invalid\n", vf_id + hinic_glb_pf_vf_offset(hwdev->hwif), cmd, in_size); return HINIC_MBOX_VF_CMD_ERROR; } if (cmd == HINIC_COMM_CMD_START_FLR) { *out_size = 0; } else { err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM, cmd, buf_in, in_size, buf_out, out_size, HINIC_MGMT_MSG_SYNC); if (err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW) dev_err(&hwdev->hwif->pdev->dev, "PF mbox common callback handler err: %d\n", err); } return err; } int hinic_func_to_func_init(struct hinic_hwdev *hwdev) { struct hinic_mbox_func_to_func *func_to_func; struct hinic_pfhwdev *pfhwdev; int err; pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev); func_to_func = kzalloc(sizeof(*func_to_func), GFP_KERNEL); if (!func_to_func) return -ENOMEM; hwdev->func_to_func = func_to_func; func_to_func->hwdev = hwdev; func_to_func->hwif = hwdev->hwif; sema_init(&func_to_func->mbox_send_sem, 1); sema_init(&func_to_func->msg_send_sem, 1); spin_lock_init(&func_to_func->mbox_lock); func_to_func->workq = create_singlethread_workqueue(HINIC_MBOX_WQ_NAME); if (!func_to_func->workq) { dev_err(&hwdev->hwif->pdev->dev, "Failed to initialize MBOX workqueue\n"); err = -ENOMEM; goto err_create_mbox_workq; } err = alloc_mbox_info(hwdev, func_to_func->mbox_send); if (err) { dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mem for mbox_active\n"); goto err_alloc_mbox_for_send; } err = alloc_mbox_info(hwdev, func_to_func->mbox_resp); if (err) { dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mem for mbox_passive\n"); goto err_alloc_mbox_for_resp; } err = alloc_mbox_wb_status(func_to_func); if (err) { dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mbox write back status\n"); goto err_alloc_wb_status; } prepare_send_mbox(func_to_func); hinic_aeq_register_hw_cb(&hwdev->aeqs, HINIC_MBX_FROM_FUNC, &pfhwdev->hwdev, hinic_mbox_func_aeqe_handler); hinic_aeq_register_hw_cb(&hwdev->aeqs, HINIC_MBX_SEND_RSLT, &pfhwdev->hwdev, hinic_mbox_self_aeqe_handler); if (!HINIC_IS_VF(hwdev->hwif)) hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_COMM, comm_pf_mbox_handler); return 0; err_alloc_wb_status: free_mbox_info(func_to_func->mbox_resp); err_alloc_mbox_for_resp: free_mbox_info(func_to_func->mbox_send); err_alloc_mbox_for_send: destroy_workqueue(func_to_func->workq); err_create_mbox_workq: kfree(func_to_func); return err; } void hinic_func_to_func_free(struct hinic_hwdev *hwdev) { struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func; hinic_aeq_unregister_hw_cb(&hwdev->aeqs, HINIC_MBX_FROM_FUNC); hinic_aeq_unregister_hw_cb(&hwdev->aeqs, HINIC_MBX_SEND_RSLT); hinic_unregister_pf_mbox_cb(hwdev, HINIC_MOD_COMM); /* destroy workqueue before free related mbox resources in case of * illegal resource access */ destroy_workqueue(func_to_func->workq); free_mbox_wb_status(func_to_func); free_mbox_info(func_to_func->mbox_resp); free_mbox_info(func_to_func->mbox_send); kfree(func_to_func); } int hinic_vf_mbox_random_id_init(struct hinic_hwdev *hwdev) { u16 vf_offset; u8 vf_in_pf; int err = 0; if (HINIC_IS_VF(hwdev->hwif)) return 0; vf_offset = hinic_glb_pf_vf_offset(hwdev->hwif); for (vf_in_pf = 1; vf_in_pf <= hwdev->nic_cap.max_vf; vf_in_pf++) { err = set_vf_mbox_random_id(hwdev, vf_offset + vf_in_pf); if (err) break; } if (err == HINIC_MGMT_CMD_UNSUPPORTED) { hwdev->func_to_func->support_vf_random = false; err = 0; dev_warn(&hwdev->hwif->pdev->dev, "Mgmt is unsupported to set VF%d random id\n", vf_in_pf - 1); } else if (!err) { hwdev->func_to_func->support_vf_random = true; } return err; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1