| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Pavan Kumar Linga | 7662 | 47.61% | 5 | 33.33% |
| Alan Brady | 6504 | 40.41% | 4 | 26.67% |
| Joshua Hay | 1611 | 10.01% | 4 | 26.67% |
| Phani Burra | 281 | 1.75% | 1 | 6.67% |
| Michal Kubiak | 36 | 0.22% | 1 | 6.67% |
| Total | 16094 | 15 |
// SPDX-License-Identifier: GPL-2.0-only /* Copyright (C) 2023 Intel Corporation */ #include "idpf.h" /** * idpf_recv_event_msg - Receive virtchnl event message * @vport: virtual port structure * @ctlq_msg: message to copy from * * Receive virtchnl event message */ static void idpf_recv_event_msg(struct idpf_vport *vport, struct idpf_ctlq_msg *ctlq_msg) { struct idpf_netdev_priv *np = netdev_priv(vport->netdev); struct virtchnl2_event *v2e; bool link_status; u32 event; v2e = (struct virtchnl2_event *)ctlq_msg->ctx.indirect.payload->va; event = le32_to_cpu(v2e->event); switch (event) { case VIRTCHNL2_EVENT_LINK_CHANGE: vport->link_speed_mbps = le32_to_cpu(v2e->link_speed); link_status = v2e->link_status; if (vport->link_up == link_status) break; vport->link_up = link_status; if (np->state == __IDPF_VPORT_UP) { if (vport->link_up) { netif_carrier_on(vport->netdev); netif_tx_start_all_queues(vport->netdev); } else { netif_tx_stop_all_queues(vport->netdev); netif_carrier_off(vport->netdev); } } break; default: dev_err(&vport->adapter->pdev->dev, "Unknown event %d from PF\n", event); break; } } /** * idpf_mb_clean - Reclaim the send mailbox queue entries * @adapter: Driver specific private structure * * Reclaim the send mailbox queue entries to be used to send further messages * * Returns 0 on success, negative on failure */ static int idpf_mb_clean(struct idpf_adapter *adapter) { u16 i, num_q_msg = IDPF_DFLT_MBX_Q_LEN; struct idpf_ctlq_msg **q_msg; struct idpf_dma_mem *dma_mem; int err; q_msg = kcalloc(num_q_msg, sizeof(struct idpf_ctlq_msg *), GFP_ATOMIC); if (!q_msg) return -ENOMEM; err = idpf_ctlq_clean_sq(adapter->hw.asq, &num_q_msg, q_msg); if (err) goto err_kfree; for (i = 0; i < num_q_msg; i++) { if (!q_msg[i]) continue; dma_mem = q_msg[i]->ctx.indirect.payload; if (dma_mem) dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va, dma_mem->pa); kfree(q_msg[i]); kfree(dma_mem); } err_kfree: kfree(q_msg); return err; } /** * idpf_send_mb_msg - Send message over mailbox * @adapter: Driver specific private structure * @op: virtchnl opcode * @msg_size: size of the payload * @msg: pointer to buffer holding the payload * * Will prepare the control queue message and initiates the send api * * Returns 0 on success, negative on failure */ int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op, u16 msg_size, u8 *msg) { struct idpf_ctlq_msg *ctlq_msg; struct idpf_dma_mem *dma_mem; int err; /* If we are here and a reset is detected nothing much can be * done. This thread should silently abort and expected to * be corrected with a new run either by user or driver * flows after reset */ if (idpf_is_reset_detected(adapter)) return 0; err = idpf_mb_clean(adapter); if (err) return err; ctlq_msg = kzalloc(sizeof(*ctlq_msg), GFP_ATOMIC); if (!ctlq_msg) return -ENOMEM; dma_mem = kzalloc(sizeof(*dma_mem), GFP_ATOMIC); if (!dma_mem) { err = -ENOMEM; goto dma_mem_error; } ctlq_msg->opcode = idpf_mbq_opc_send_msg_to_cp; ctlq_msg->func_id = 0; ctlq_msg->data_len = msg_size; ctlq_msg->cookie.mbx.chnl_opcode = op; ctlq_msg->cookie.mbx.chnl_retval = 0; dma_mem->size = IDPF_CTLQ_MAX_BUF_LEN; dma_mem->va = dma_alloc_coherent(&adapter->pdev->dev, dma_mem->size, &dma_mem->pa, GFP_ATOMIC); if (!dma_mem->va) { err = -ENOMEM; goto dma_alloc_error; } memcpy(dma_mem->va, msg, msg_size); ctlq_msg->ctx.indirect.payload = dma_mem; err = idpf_ctlq_send(&adapter->hw, adapter->hw.asq, 1, ctlq_msg); if (err) goto send_error; return 0; send_error: dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va, dma_mem->pa); dma_alloc_error: kfree(dma_mem); dma_mem_error: kfree(ctlq_msg); return err; } /** * idpf_find_vport - Find vport pointer from control queue message * @adapter: driver specific private structure * @vport: address of vport pointer to copy the vport from adapters vport list * @ctlq_msg: control queue message * * Return 0 on success, error value on failure. Also this function does check * for the opcodes which expect to receive payload and return error value if * it is not the case. */ static int idpf_find_vport(struct idpf_adapter *adapter, struct idpf_vport **vport, struct idpf_ctlq_msg *ctlq_msg) { bool no_op = false, vid_found = false; int i, err = 0; char *vc_msg; u32 v_id; vc_msg = kcalloc(IDPF_CTLQ_MAX_BUF_LEN, sizeof(char), GFP_KERNEL); if (!vc_msg) return -ENOMEM; if (ctlq_msg->data_len) { size_t payload_size = ctlq_msg->ctx.indirect.payload->size; if (!payload_size) { dev_err(&adapter->pdev->dev, "Failed to receive payload buffer\n"); kfree(vc_msg); return -EINVAL; } memcpy(vc_msg, ctlq_msg->ctx.indirect.payload->va, min_t(size_t, payload_size, IDPF_CTLQ_MAX_BUF_LEN)); } switch (ctlq_msg->cookie.mbx.chnl_opcode) { case VIRTCHNL2_OP_VERSION: case VIRTCHNL2_OP_GET_CAPS: case VIRTCHNL2_OP_CREATE_VPORT: case VIRTCHNL2_OP_SET_SRIOV_VFS: case VIRTCHNL2_OP_ALLOC_VECTORS: case VIRTCHNL2_OP_DEALLOC_VECTORS: case VIRTCHNL2_OP_GET_PTYPE_INFO: goto free_vc_msg; case VIRTCHNL2_OP_ENABLE_VPORT: case VIRTCHNL2_OP_DISABLE_VPORT: case VIRTCHNL2_OP_DESTROY_VPORT: v_id = le32_to_cpu(((struct virtchnl2_vport *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_CONFIG_TX_QUEUES: v_id = le32_to_cpu(((struct virtchnl2_config_tx_queues *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_CONFIG_RX_QUEUES: v_id = le32_to_cpu(((struct virtchnl2_config_rx_queues *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_ENABLE_QUEUES: case VIRTCHNL2_OP_DISABLE_QUEUES: case VIRTCHNL2_OP_DEL_QUEUES: v_id = le32_to_cpu(((struct virtchnl2_del_ena_dis_queues *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_ADD_QUEUES: v_id = le32_to_cpu(((struct virtchnl2_add_queues *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_MAP_QUEUE_VECTOR: case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR: v_id = le32_to_cpu(((struct virtchnl2_queue_vector_maps *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_GET_STATS: v_id = le32_to_cpu(((struct virtchnl2_vport_stats *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_GET_RSS_LUT: case VIRTCHNL2_OP_SET_RSS_LUT: v_id = le32_to_cpu(((struct virtchnl2_rss_lut *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_GET_RSS_KEY: case VIRTCHNL2_OP_SET_RSS_KEY: v_id = le32_to_cpu(((struct virtchnl2_rss_key *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_EVENT: v_id = le32_to_cpu(((struct virtchnl2_event *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_LOOPBACK: v_id = le32_to_cpu(((struct virtchnl2_loopback *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE: v_id = le32_to_cpu(((struct virtchnl2_promisc_info *)vc_msg)->vport_id); break; case VIRTCHNL2_OP_ADD_MAC_ADDR: case VIRTCHNL2_OP_DEL_MAC_ADDR: v_id = le32_to_cpu(((struct virtchnl2_mac_addr_list *)vc_msg)->vport_id); break; default: no_op = true; break; } if (no_op) goto free_vc_msg; for (i = 0; i < idpf_get_max_vports(adapter); i++) { if (adapter->vport_ids[i] == v_id) { vid_found = true; break; } } if (vid_found) *vport = adapter->vports[i]; else err = -EINVAL; free_vc_msg: kfree(vc_msg); return err; } /** * idpf_copy_data_to_vc_buf - Copy the virtchnl response data into the buffer. * @adapter: driver specific private structure * @vport: virtual port structure * @ctlq_msg: msg to copy from * @err_enum: err bit to set on error * * Copies the payload from ctlq_msg into virtchnl buffer. Returns 0 on success, * negative on failure. */ static int idpf_copy_data_to_vc_buf(struct idpf_adapter *adapter, struct idpf_vport *vport, struct idpf_ctlq_msg *ctlq_msg, enum idpf_vport_vc_state err_enum) { if (ctlq_msg->cookie.mbx.chnl_retval) { if (vport) set_bit(err_enum, vport->vc_state); else set_bit(err_enum, adapter->vc_state); return -EINVAL; } if (vport) memcpy(vport->vc_msg, ctlq_msg->ctx.indirect.payload->va, min_t(int, ctlq_msg->ctx.indirect.payload->size, IDPF_CTLQ_MAX_BUF_LEN)); else memcpy(adapter->vc_msg, ctlq_msg->ctx.indirect.payload->va, min_t(int, ctlq_msg->ctx.indirect.payload->size, IDPF_CTLQ_MAX_BUF_LEN)); return 0; } /** * idpf_recv_vchnl_op - helper function with common logic when handling the * reception of VIRTCHNL OPs. * @adapter: driver specific private structure * @vport: virtual port structure * @ctlq_msg: msg to copy from * @state: state bit used on timeout check * @err_state: err bit to set on error */ static void idpf_recv_vchnl_op(struct idpf_adapter *adapter, struct idpf_vport *vport, struct idpf_ctlq_msg *ctlq_msg, enum idpf_vport_vc_state state, enum idpf_vport_vc_state err_state) { wait_queue_head_t *vchnl_wq; int err; if (vport) vchnl_wq = &vport->vchnl_wq; else vchnl_wq = &adapter->vchnl_wq; err = idpf_copy_data_to_vc_buf(adapter, vport, ctlq_msg, err_state); if (wq_has_sleeper(vchnl_wq)) { if (vport) set_bit(state, vport->vc_state); else set_bit(state, adapter->vc_state); wake_up(vchnl_wq); } else { if (!err) { dev_warn(&adapter->pdev->dev, "opcode %d received without waiting thread\n", ctlq_msg->cookie.mbx.chnl_opcode); } else { /* Clear the errors since there is no sleeper to pass * them on */ if (vport) clear_bit(err_state, vport->vc_state); else clear_bit(err_state, adapter->vc_state); } } } /** * idpf_recv_mb_msg - Receive message over mailbox * @adapter: Driver specific private structure * @op: virtchannel operation code * @msg: Received message holding buffer * @msg_size: message size * * Will receive control queue message and posts the receive buffer. Returns 0 * on success and negative on failure. */ int idpf_recv_mb_msg(struct idpf_adapter *adapter, u32 op, void *msg, int msg_size) { struct idpf_vport *vport = NULL; struct idpf_ctlq_msg ctlq_msg; struct idpf_dma_mem *dma_mem; bool work_done = false; int num_retry = 2000; u16 num_q_msg; int err; while (1) { struct idpf_vport_config *vport_config; int payload_size = 0; /* Try to get one message */ num_q_msg = 1; dma_mem = NULL; err = idpf_ctlq_recv(adapter->hw.arq, &num_q_msg, &ctlq_msg); /* If no message then decide if we have to retry based on * opcode */ if (err || !num_q_msg) { /* Increasing num_retry to consider the delayed * responses because of large number of VF's mailbox * messages. If the mailbox message is received from * the other side, we come out of the sleep cycle * immediately else we wait for more time. */ if (!op || !num_retry--) break; if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) { err = -EIO; break; } msleep(20); continue; } /* If we are here a message is received. Check if we are looking * for a specific message based on opcode. If it is different * ignore and post buffers */ if (op && ctlq_msg.cookie.mbx.chnl_opcode != op) goto post_buffs; err = idpf_find_vport(adapter, &vport, &ctlq_msg); if (err) goto post_buffs; if (ctlq_msg.data_len) payload_size = ctlq_msg.ctx.indirect.payload->size; /* All conditions are met. Either a message requested is * received or we received a message to be processed */ switch (ctlq_msg.cookie.mbx.chnl_opcode) { case VIRTCHNL2_OP_VERSION: case VIRTCHNL2_OP_GET_CAPS: if (ctlq_msg.cookie.mbx.chnl_retval) { dev_err(&adapter->pdev->dev, "Failure initializing, vc op: %u retval: %u\n", ctlq_msg.cookie.mbx.chnl_opcode, ctlq_msg.cookie.mbx.chnl_retval); err = -EBADMSG; } else if (msg) { memcpy(msg, ctlq_msg.ctx.indirect.payload->va, min_t(int, payload_size, msg_size)); } work_done = true; break; case VIRTCHNL2_OP_CREATE_VPORT: idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg, IDPF_VC_CREATE_VPORT, IDPF_VC_CREATE_VPORT_ERR); break; case VIRTCHNL2_OP_ENABLE_VPORT: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_ENA_VPORT, IDPF_VC_ENA_VPORT_ERR); break; case VIRTCHNL2_OP_DISABLE_VPORT: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_DIS_VPORT, IDPF_VC_DIS_VPORT_ERR); break; case VIRTCHNL2_OP_DESTROY_VPORT: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_DESTROY_VPORT, IDPF_VC_DESTROY_VPORT_ERR); break; case VIRTCHNL2_OP_CONFIG_TX_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_CONFIG_TXQ, IDPF_VC_CONFIG_TXQ_ERR); break; case VIRTCHNL2_OP_CONFIG_RX_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_CONFIG_RXQ, IDPF_VC_CONFIG_RXQ_ERR); break; case VIRTCHNL2_OP_ENABLE_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_ENA_QUEUES, IDPF_VC_ENA_QUEUES_ERR); break; case VIRTCHNL2_OP_DISABLE_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_DIS_QUEUES, IDPF_VC_DIS_QUEUES_ERR); break; case VIRTCHNL2_OP_ADD_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_ADD_QUEUES, IDPF_VC_ADD_QUEUES_ERR); break; case VIRTCHNL2_OP_DEL_QUEUES: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_DEL_QUEUES, IDPF_VC_DEL_QUEUES_ERR); break; case VIRTCHNL2_OP_MAP_QUEUE_VECTOR: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_MAP_IRQ, IDPF_VC_MAP_IRQ_ERR); break; case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_UNMAP_IRQ, IDPF_VC_UNMAP_IRQ_ERR); break; case VIRTCHNL2_OP_GET_STATS: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_GET_STATS, IDPF_VC_GET_STATS_ERR); break; case VIRTCHNL2_OP_GET_RSS_LUT: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_GET_RSS_LUT, IDPF_VC_GET_RSS_LUT_ERR); break; case VIRTCHNL2_OP_SET_RSS_LUT: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_SET_RSS_LUT, IDPF_VC_SET_RSS_LUT_ERR); break; case VIRTCHNL2_OP_GET_RSS_KEY: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_GET_RSS_KEY, IDPF_VC_GET_RSS_KEY_ERR); break; case VIRTCHNL2_OP_SET_RSS_KEY: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_SET_RSS_KEY, IDPF_VC_SET_RSS_KEY_ERR); break; case VIRTCHNL2_OP_SET_SRIOV_VFS: idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg, IDPF_VC_SET_SRIOV_VFS, IDPF_VC_SET_SRIOV_VFS_ERR); break; case VIRTCHNL2_OP_ALLOC_VECTORS: idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg, IDPF_VC_ALLOC_VECTORS, IDPF_VC_ALLOC_VECTORS_ERR); break; case VIRTCHNL2_OP_DEALLOC_VECTORS: idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg, IDPF_VC_DEALLOC_VECTORS, IDPF_VC_DEALLOC_VECTORS_ERR); break; case VIRTCHNL2_OP_GET_PTYPE_INFO: idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg, IDPF_VC_GET_PTYPE_INFO, IDPF_VC_GET_PTYPE_INFO_ERR); break; case VIRTCHNL2_OP_LOOPBACK: idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_LOOPBACK_STATE, IDPF_VC_LOOPBACK_STATE_ERR); break; case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE: /* This message can only be sent asynchronously. As * such we'll have lost the context in which it was * called and thus can only really report if it looks * like an error occurred. Don't bother setting ERR bit * or waking chnl_wq since no work queue will be waiting * to read the message. */ if (ctlq_msg.cookie.mbx.chnl_retval) { dev_err(&adapter->pdev->dev, "Failed to set promiscuous mode: %d\n", ctlq_msg.cookie.mbx.chnl_retval); } break; case VIRTCHNL2_OP_ADD_MAC_ADDR: vport_config = adapter->vport_config[vport->idx]; if (test_and_clear_bit(IDPF_VPORT_ADD_MAC_REQ, vport_config->flags)) { /* Message was sent asynchronously. We don't * normally print errors here, instead * prefer to handle errors in the function * calling wait_for_event. However, if * asynchronous, the context in which the * message was sent is lost. We can't really do * anything about at it this point, but we * should at a minimum indicate that it looks * like something went wrong. Also don't bother * setting ERR bit or waking vchnl_wq since no * one will be waiting to read the async * message. */ if (ctlq_msg.cookie.mbx.chnl_retval) dev_err(&adapter->pdev->dev, "Failed to add MAC address: %d\n", ctlq_msg.cookie.mbx.chnl_retval); break; } idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_ADD_MAC_ADDR, IDPF_VC_ADD_MAC_ADDR_ERR); break; case VIRTCHNL2_OP_DEL_MAC_ADDR: vport_config = adapter->vport_config[vport->idx]; if (test_and_clear_bit(IDPF_VPORT_DEL_MAC_REQ, vport_config->flags)) { /* Message was sent asynchronously like the * VIRTCHNL2_OP_ADD_MAC_ADDR */ if (ctlq_msg.cookie.mbx.chnl_retval) dev_err(&adapter->pdev->dev, "Failed to delete MAC address: %d\n", ctlq_msg.cookie.mbx.chnl_retval); break; } idpf_recv_vchnl_op(adapter, vport, &ctlq_msg, IDPF_VC_DEL_MAC_ADDR, IDPF_VC_DEL_MAC_ADDR_ERR); break; case VIRTCHNL2_OP_EVENT: idpf_recv_event_msg(vport, &ctlq_msg); break; default: dev_warn(&adapter->pdev->dev, "Unhandled virtchnl response %d\n", ctlq_msg.cookie.mbx.chnl_opcode); break; } post_buffs: if (ctlq_msg.data_len) dma_mem = ctlq_msg.ctx.indirect.payload; else num_q_msg = 0; err = idpf_ctlq_post_rx_buffs(&adapter->hw, adapter->hw.arq, &num_q_msg, &dma_mem); /* If post failed clear the only buffer we supplied */ if (err && dma_mem) dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va, dma_mem->pa); /* Applies only if we are looking for a specific opcode */ if (work_done) break; } return err; } /** * __idpf_wait_for_event - wrapper function for wait on virtchannel response * @adapter: Driver private data structure * @vport: virtual port structure * @state: check on state upon timeout * @err_check: check if this specific error bit is set * @timeout: Max time to wait * * Checks if state is set upon expiry of timeout. Returns 0 on success, * negative on failure. */ static int __idpf_wait_for_event(struct idpf_adapter *adapter, struct idpf_vport *vport, enum idpf_vport_vc_state state, enum idpf_vport_vc_state err_check, int timeout) { int time_to_wait, num_waits; wait_queue_head_t *vchnl_wq; unsigned long *vc_state; time_to_wait = ((timeout <= IDPF_MAX_WAIT) ? timeout : IDPF_MAX_WAIT); num_waits = ((timeout <= IDPF_MAX_WAIT) ? 1 : timeout / IDPF_MAX_WAIT); if (vport) { vchnl_wq = &vport->vchnl_wq; vc_state = vport->vc_state; } else { vchnl_wq = &adapter->vchnl_wq; vc_state = adapter->vc_state; } while (num_waits) { int event; /* If we are here and a reset is detected do not wait but * return. Reset timing is out of drivers control. So * while we are cleaning resources as part of reset if the * underlying HW mailbox is gone, wait on mailbox messages * is not meaningful */ if (idpf_is_reset_detected(adapter)) return 0; event = wait_event_timeout(*vchnl_wq, test_and_clear_bit(state, vc_state), msecs_to_jiffies(time_to_wait)); if (event) { if (test_and_clear_bit(err_check, vc_state)) { dev_err(&adapter->pdev->dev, "VC response error %s\n", idpf_vport_vc_state_str[err_check]); return -EINVAL; } return 0; } num_waits--; } /* Timeout occurred */ dev_err(&adapter->pdev->dev, "VC timeout, state = %s\n", idpf_vport_vc_state_str[state]); return -ETIMEDOUT; } /** * idpf_min_wait_for_event - wait for virtchannel response * @adapter: Driver private data structure * @vport: virtual port structure * @state: check on state upon timeout * @err_check: check if this specific error bit is set * * Returns 0 on success, negative on failure. */ static int idpf_min_wait_for_event(struct idpf_adapter *adapter, struct idpf_vport *vport, enum idpf_vport_vc_state state, enum idpf_vport_vc_state err_check) { return __idpf_wait_for_event(adapter, vport, state, err_check, IDPF_WAIT_FOR_EVENT_TIMEO_MIN); } /** * idpf_wait_for_event - wait for virtchannel response * @adapter: Driver private data structure * @vport: virtual port structure * @state: check on state upon timeout after 500ms * @err_check: check if this specific error bit is set * * Returns 0 on success, negative on failure. */ static int idpf_wait_for_event(struct idpf_adapter *adapter, struct idpf_vport *vport, enum idpf_vport_vc_state state, enum idpf_vport_vc_state err_check) { /* Increasing the timeout in __IDPF_INIT_SW flow to consider large * number of VF's mailbox message responses. When a message is received * on mailbox, this thread is woken up by the idpf_recv_mb_msg before * the timeout expires. Only in the error case i.e. if no message is * received on mailbox, we wait for the complete timeout which is * less likely to happen. */ return __idpf_wait_for_event(adapter, vport, state, err_check, IDPF_WAIT_FOR_EVENT_TIMEO); } /** * idpf_wait_for_marker_event - wait for software marker response * @vport: virtual port data structure * * Returns 0 success, negative on failure. **/ static int idpf_wait_for_marker_event(struct idpf_vport *vport) { int event; int i; for (i = 0; i < vport->num_txq; i++) set_bit(__IDPF_Q_SW_MARKER, vport->txqs[i]->flags); event = wait_event_timeout(vport->sw_marker_wq, test_and_clear_bit(IDPF_VPORT_SW_MARKER, vport->flags), msecs_to_jiffies(500)); for (i = 0; i < vport->num_txq; i++) clear_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags); if (event) return 0; dev_warn(&vport->adapter->pdev->dev, "Failed to receive marker packets\n"); return -ETIMEDOUT; } /** * idpf_send_ver_msg - send virtchnl version message * @adapter: Driver specific private structure * * Send virtchnl version message. Returns 0 on success, negative on failure. */ static int idpf_send_ver_msg(struct idpf_adapter *adapter) { struct virtchnl2_version_info vvi; if (adapter->virt_ver_maj) { vvi.major = cpu_to_le32(adapter->virt_ver_maj); vvi.minor = cpu_to_le32(adapter->virt_ver_min); } else { vvi.major = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MAJOR); vvi.minor = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MINOR); } return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_VERSION, sizeof(vvi), (u8 *)&vvi); } /** * idpf_recv_ver_msg - Receive virtchnl version message * @adapter: Driver specific private structure * * Receive virtchnl version message. Returns 0 on success, -EAGAIN if we need * to send version message again, otherwise negative on failure. */ static int idpf_recv_ver_msg(struct idpf_adapter *adapter) { struct virtchnl2_version_info vvi; u32 major, minor; int err; err = idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_VERSION, &vvi, sizeof(vvi)); if (err) return err; major = le32_to_cpu(vvi.major); minor = le32_to_cpu(vvi.minor); if (major > IDPF_VIRTCHNL_VERSION_MAJOR) { dev_warn(&adapter->pdev->dev, "Virtchnl major version (%d) greater than supported\n", major); return -EINVAL; } if (major == IDPF_VIRTCHNL_VERSION_MAJOR && minor > IDPF_VIRTCHNL_VERSION_MINOR) dev_warn(&adapter->pdev->dev, "Virtchnl minor version (%d) didn't match\n", minor); /* If we have a mismatch, resend version to update receiver on what * version we will use. */ if (!adapter->virt_ver_maj && major != IDPF_VIRTCHNL_VERSION_MAJOR && minor != IDPF_VIRTCHNL_VERSION_MINOR) err = -EAGAIN; adapter->virt_ver_maj = major; adapter->virt_ver_min = minor; return err; } /** * idpf_send_get_caps_msg - Send virtchnl get capabilities message * @adapter: Driver specific private structure * * Send virtchl get capabilities message. Returns 0 on success, negative on * failure. */ static int idpf_send_get_caps_msg(struct idpf_adapter *adapter) { struct virtchnl2_get_capabilities caps = { }; caps.csum_caps = cpu_to_le32(VIRTCHNL2_CAP_TX_CSUM_L3_IPV4 | VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_TCP | VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_UDP | VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_SCTP | VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_TCP | VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_UDP | VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_SCTP | VIRTCHNL2_CAP_RX_CSUM_L3_IPV4 | VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP | VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP | VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_SCTP | VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP | VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP | VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_SCTP | VIRTCHNL2_CAP_TX_CSUM_L3_SINGLE_TUNNEL | VIRTCHNL2_CAP_RX_CSUM_L3_SINGLE_TUNNEL | VIRTCHNL2_CAP_TX_CSUM_L4_SINGLE_TUNNEL | VIRTCHNL2_CAP_RX_CSUM_L4_SINGLE_TUNNEL | VIRTCHNL2_CAP_RX_CSUM_GENERIC); caps.seg_caps = cpu_to_le32(VIRTCHNL2_CAP_SEG_IPV4_TCP | VIRTCHNL2_CAP_SEG_IPV4_UDP | VIRTCHNL2_CAP_SEG_IPV4_SCTP | VIRTCHNL2_CAP_SEG_IPV6_TCP | VIRTCHNL2_CAP_SEG_IPV6_UDP | VIRTCHNL2_CAP_SEG_IPV6_SCTP | VIRTCHNL2_CAP_SEG_TX_SINGLE_TUNNEL); caps.rss_caps = cpu_to_le64(VIRTCHNL2_CAP_RSS_IPV4_TCP | VIRTCHNL2_CAP_RSS_IPV4_UDP | VIRTCHNL2_CAP_RSS_IPV4_SCTP | VIRTCHNL2_CAP_RSS_IPV4_OTHER | VIRTCHNL2_CAP_RSS_IPV6_TCP | VIRTCHNL2_CAP_RSS_IPV6_UDP | VIRTCHNL2_CAP_RSS_IPV6_SCTP | VIRTCHNL2_CAP_RSS_IPV6_OTHER); caps.hsplit_caps = cpu_to_le32(VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V4 | VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V6); caps.rsc_caps = cpu_to_le32(VIRTCHNL2_CAP_RSC_IPV4_TCP | VIRTCHNL2_CAP_RSC_IPV6_TCP); caps.other_caps = cpu_to_le64(VIRTCHNL2_CAP_SRIOV | VIRTCHNL2_CAP_MACFILTER | VIRTCHNL2_CAP_SPLITQ_QSCHED | VIRTCHNL2_CAP_PROMISC | VIRTCHNL2_CAP_LOOPBACK); return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, sizeof(caps), (u8 *)&caps); } /** * idpf_recv_get_caps_msg - Receive virtchnl get capabilities message * @adapter: Driver specific private structure * * Receive virtchnl get capabilities message. Returns 0 on success, negative on * failure. */ static int idpf_recv_get_caps_msg(struct idpf_adapter *adapter) { return idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, &adapter->caps, sizeof(struct virtchnl2_get_capabilities)); } /** * idpf_vport_alloc_max_qs - Allocate max queues for a vport * @adapter: Driver specific private structure * @max_q: vport max queue structure */ int idpf_vport_alloc_max_qs(struct idpf_adapter *adapter, struct idpf_vport_max_q *max_q) { struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues; struct virtchnl2_get_capabilities *caps = &adapter->caps; u16 default_vports = idpf_get_default_vports(adapter); int max_rx_q, max_tx_q; mutex_lock(&adapter->queue_lock); max_rx_q = le16_to_cpu(caps->max_rx_q) / default_vports; max_tx_q = le16_to_cpu(caps->max_tx_q) / default_vports; if (adapter->num_alloc_vports < default_vports) { max_q->max_rxq = min_t(u16, max_rx_q, IDPF_MAX_Q); max_q->max_txq = min_t(u16, max_tx_q, IDPF_MAX_Q); } else { max_q->max_rxq = IDPF_MIN_Q; max_q->max_txq = IDPF_MIN_Q; } max_q->max_bufq = max_q->max_rxq * IDPF_MAX_BUFQS_PER_RXQ_GRP; max_q->max_complq = max_q->max_txq; if (avail_queues->avail_rxq < max_q->max_rxq || avail_queues->avail_txq < max_q->max_txq || avail_queues->avail_bufq < max_q->max_bufq || avail_queues->avail_complq < max_q->max_complq) { mutex_unlock(&adapter->queue_lock); return -EINVAL; } avail_queues->avail_rxq -= max_q->max_rxq; avail_queues->avail_txq -= max_q->max_txq; avail_queues->avail_bufq -= max_q->max_bufq; avail_queues->avail_complq -= max_q->max_complq; mutex_unlock(&adapter->queue_lock); return 0; } /** * idpf_vport_dealloc_max_qs - Deallocate max queues of a vport * @adapter: Driver specific private structure * @max_q: vport max queue structure */ void idpf_vport_dealloc_max_qs(struct idpf_adapter *adapter, struct idpf_vport_max_q *max_q) { struct idpf_avail_queue_info *avail_queues; mutex_lock(&adapter->queue_lock); avail_queues = &adapter->avail_queues; avail_queues->avail_rxq += max_q->max_rxq; avail_queues->avail_txq += max_q->max_txq; avail_queues->avail_bufq += max_q->max_bufq; avail_queues->avail_complq += max_q->max_complq; mutex_unlock(&adapter->queue_lock); } /** * idpf_init_avail_queues - Initialize available queues on the device * @adapter: Driver specific private structure */ static void idpf_init_avail_queues(struct idpf_adapter *adapter) { struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues; struct virtchnl2_get_capabilities *caps = &adapter->caps; avail_queues->avail_rxq = le16_to_cpu(caps->max_rx_q); avail_queues->avail_txq = le16_to_cpu(caps->max_tx_q); avail_queues->avail_bufq = le16_to_cpu(caps->max_rx_bufq); avail_queues->avail_complq = le16_to_cpu(caps->max_tx_complq); } /** * idpf_get_reg_intr_vecs - Get vector queue register offset * @vport: virtual port structure * @reg_vals: Register offsets to store in * * Returns number of registers that got populated */ int idpf_get_reg_intr_vecs(struct idpf_vport *vport, struct idpf_vec_regs *reg_vals) { struct virtchnl2_vector_chunks *chunks; struct idpf_vec_regs reg_val; u16 num_vchunks, num_vec; int num_regs = 0, i, j; chunks = &vport->adapter->req_vec_chunks->vchunks; num_vchunks = le16_to_cpu(chunks->num_vchunks); for (j = 0; j < num_vchunks; j++) { struct virtchnl2_vector_chunk *chunk; u32 dynctl_reg_spacing; u32 itrn_reg_spacing; chunk = &chunks->vchunks[j]; num_vec = le16_to_cpu(chunk->num_vectors); reg_val.dyn_ctl_reg = le32_to_cpu(chunk->dynctl_reg_start); reg_val.itrn_reg = le32_to_cpu(chunk->itrn_reg_start); reg_val.itrn_index_spacing = le32_to_cpu(chunk->itrn_index_spacing); dynctl_reg_spacing = le32_to_cpu(chunk->dynctl_reg_spacing); itrn_reg_spacing = le32_to_cpu(chunk->itrn_reg_spacing); for (i = 0; i < num_vec; i++) { reg_vals[num_regs].dyn_ctl_reg = reg_val.dyn_ctl_reg; reg_vals[num_regs].itrn_reg = reg_val.itrn_reg; reg_vals[num_regs].itrn_index_spacing = reg_val.itrn_index_spacing; reg_val.dyn_ctl_reg += dynctl_reg_spacing; reg_val.itrn_reg += itrn_reg_spacing; num_regs++; } } return num_regs; } /** * idpf_vport_get_q_reg - Get the queue registers for the vport * @reg_vals: register values needing to be set * @num_regs: amount we expect to fill * @q_type: queue model * @chunks: queue regs received over mailbox * * This function parses the queue register offsets from the queue register * chunk information, with a specific queue type and stores it into the array * passed as an argument. It returns the actual number of queue registers that * are filled. */ static int idpf_vport_get_q_reg(u32 *reg_vals, int num_regs, u32 q_type, struct virtchnl2_queue_reg_chunks *chunks) { u16 num_chunks = le16_to_cpu(chunks->num_chunks); int reg_filled = 0, i; u32 reg_val; while (num_chunks--) { struct virtchnl2_queue_reg_chunk *chunk; u16 num_q; chunk = &chunks->chunks[num_chunks]; if (le32_to_cpu(chunk->type) != q_type) continue; num_q = le32_to_cpu(chunk->num_queues); reg_val = le64_to_cpu(chunk->qtail_reg_start); for (i = 0; i < num_q && reg_filled < num_regs ; i++) { reg_vals[reg_filled++] = reg_val; reg_val += le32_to_cpu(chunk->qtail_reg_spacing); } } return reg_filled; } /** * __idpf_queue_reg_init - initialize queue registers * @vport: virtual port structure * @reg_vals: registers we are initializing * @num_regs: how many registers there are in total * @q_type: queue model * * Return number of queues that are initialized */ static int __idpf_queue_reg_init(struct idpf_vport *vport, u32 *reg_vals, int num_regs, u32 q_type) { struct idpf_adapter *adapter = vport->adapter; struct idpf_queue *q; int i, j, k = 0; switch (q_type) { case VIRTCHNL2_QUEUE_TYPE_TX: for (i = 0; i < vport->num_txq_grp; i++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; for (j = 0; j < tx_qgrp->num_txq && k < num_regs; j++, k++) tx_qgrp->txqs[j]->tail = idpf_get_reg_addr(adapter, reg_vals[k]); } break; case VIRTCHNL2_QUEUE_TYPE_RX: for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u16 num_rxq = rx_qgrp->singleq.num_rxq; for (j = 0; j < num_rxq && k < num_regs; j++, k++) { q = rx_qgrp->singleq.rxqs[j]; q->tail = idpf_get_reg_addr(adapter, reg_vals[k]); } } break; case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER: for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u8 num_bufqs = vport->num_bufqs_per_qgrp; for (j = 0; j < num_bufqs && k < num_regs; j++, k++) { q = &rx_qgrp->splitq.bufq_sets[j].bufq; q->tail = idpf_get_reg_addr(adapter, reg_vals[k]); } } break; default: break; } return k; } /** * idpf_queue_reg_init - initialize queue registers * @vport: virtual port structure * * Return 0 on success, negative on failure */ int idpf_queue_reg_init(struct idpf_vport *vport) { struct virtchnl2_create_vport *vport_params; struct virtchnl2_queue_reg_chunks *chunks; struct idpf_vport_config *vport_config; u16 vport_idx = vport->idx; int num_regs, ret = 0; u32 *reg_vals; /* We may never deal with more than 256 same type of queues */ reg_vals = kzalloc(sizeof(void *) * IDPF_LARGE_MAX_Q, GFP_KERNEL); if (!reg_vals) return -ENOMEM; vport_config = vport->adapter->vport_config[vport_idx]; if (vport_config->req_qs_chunks) { struct virtchnl2_add_queues *vc_aq = (struct virtchnl2_add_queues *)vport_config->req_qs_chunks; chunks = &vc_aq->chunks; } else { vport_params = vport->adapter->vport_params_recvd[vport_idx]; chunks = &vport_params->chunks; } /* Initialize Tx queue tail register address */ num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q, VIRTCHNL2_QUEUE_TYPE_TX, chunks); if (num_regs < vport->num_txq) { ret = -EINVAL; goto free_reg_vals; } num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs, VIRTCHNL2_QUEUE_TYPE_TX); if (num_regs < vport->num_txq) { ret = -EINVAL; goto free_reg_vals; } /* Initialize Rx/buffer queue tail register address based on Rx queue * model */ if (idpf_is_queue_model_split(vport->rxq_model)) { num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q, VIRTCHNL2_QUEUE_TYPE_RX_BUFFER, chunks); if (num_regs < vport->num_bufq) { ret = -EINVAL; goto free_reg_vals; } num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs, VIRTCHNL2_QUEUE_TYPE_RX_BUFFER); if (num_regs < vport->num_bufq) { ret = -EINVAL; goto free_reg_vals; } } else { num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q, VIRTCHNL2_QUEUE_TYPE_RX, chunks); if (num_regs < vport->num_rxq) { ret = -EINVAL; goto free_reg_vals; } num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs, VIRTCHNL2_QUEUE_TYPE_RX); if (num_regs < vport->num_rxq) { ret = -EINVAL; goto free_reg_vals; } } free_reg_vals: kfree(reg_vals); return ret; } /** * idpf_send_create_vport_msg - Send virtchnl create vport message * @adapter: Driver specific private structure * @max_q: vport max queue info * * send virtchnl creae vport message * * Returns 0 on success, negative on failure */ int idpf_send_create_vport_msg(struct idpf_adapter *adapter, struct idpf_vport_max_q *max_q) { struct virtchnl2_create_vport *vport_msg; u16 idx = adapter->next_vport; int err, buf_size; buf_size = sizeof(struct virtchnl2_create_vport); if (!adapter->vport_params_reqd[idx]) { adapter->vport_params_reqd[idx] = kzalloc(buf_size, GFP_KERNEL); if (!adapter->vport_params_reqd[idx]) return -ENOMEM; } vport_msg = adapter->vport_params_reqd[idx]; vport_msg->vport_type = cpu_to_le16(VIRTCHNL2_VPORT_TYPE_DEFAULT); vport_msg->vport_index = cpu_to_le16(idx); if (adapter->req_tx_splitq) vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT); else vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE); if (adapter->req_rx_splitq) vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT); else vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE); err = idpf_vport_calc_total_qs(adapter, idx, vport_msg, max_q); if (err) { dev_err(&adapter->pdev->dev, "Enough queues are not available"); return err; } mutex_lock(&adapter->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CREATE_VPORT, buf_size, (u8 *)vport_msg); if (err) goto rel_lock; err = idpf_wait_for_event(adapter, NULL, IDPF_VC_CREATE_VPORT, IDPF_VC_CREATE_VPORT_ERR); if (err) { dev_err(&adapter->pdev->dev, "Failed to receive create vport message"); goto rel_lock; } if (!adapter->vport_params_recvd[idx]) { adapter->vport_params_recvd[idx] = kzalloc(IDPF_CTLQ_MAX_BUF_LEN, GFP_KERNEL); if (!adapter->vport_params_recvd[idx]) { err = -ENOMEM; goto rel_lock; } } vport_msg = adapter->vport_params_recvd[idx]; memcpy(vport_msg, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN); rel_lock: mutex_unlock(&adapter->vc_buf_lock); return err; } /** * idpf_check_supported_desc_ids - Verify we have required descriptor support * @vport: virtual port structure * * Return 0 on success, error on failure */ int idpf_check_supported_desc_ids(struct idpf_vport *vport) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_create_vport *vport_msg; u64 rx_desc_ids, tx_desc_ids; vport_msg = adapter->vport_params_recvd[vport->idx]; rx_desc_ids = le64_to_cpu(vport_msg->rx_desc_ids); tx_desc_ids = le64_to_cpu(vport_msg->tx_desc_ids); if (vport->rxq_model == VIRTCHNL2_QUEUE_MODEL_SPLIT) { if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M)) { dev_info(&adapter->pdev->dev, "Minimum RX descriptor support not provided, using the default\n"); vport_msg->rx_desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M); } } else { if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SQ_NIC_M)) vport->base_rxd = true; } if (vport->txq_model != VIRTCHNL2_QUEUE_MODEL_SPLIT) return 0; if ((tx_desc_ids & MIN_SUPPORT_TXDID) != MIN_SUPPORT_TXDID) { dev_info(&adapter->pdev->dev, "Minimum TX descriptor support not provided, using the default\n"); vport_msg->tx_desc_ids = cpu_to_le64(MIN_SUPPORT_TXDID); } return 0; } /** * idpf_send_destroy_vport_msg - Send virtchnl destroy vport message * @vport: virtual port data structure * * Send virtchnl destroy vport message. Returns 0 on success, negative on * failure. */ int idpf_send_destroy_vport_msg(struct idpf_vport *vport) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_vport v_id; int err; v_id.vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DESTROY_VPORT, sizeof(v_id), (u8 *)&v_id); if (err) goto rel_lock; err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DESTROY_VPORT, IDPF_VC_DESTROY_VPORT_ERR); rel_lock: mutex_unlock(&vport->vc_buf_lock); return err; } /** * idpf_send_enable_vport_msg - Send virtchnl enable vport message * @vport: virtual port data structure * * Send enable vport virtchnl message. Returns 0 on success, negative on * failure. */ int idpf_send_enable_vport_msg(struct idpf_vport *vport) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_vport v_id; int err; v_id.vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ENABLE_VPORT, sizeof(v_id), (u8 *)&v_id); if (err) goto rel_lock; err = idpf_wait_for_event(adapter, vport, IDPF_VC_ENA_VPORT, IDPF_VC_ENA_VPORT_ERR); rel_lock: mutex_unlock(&vport->vc_buf_lock); return err; } /** * idpf_send_disable_vport_msg - Send virtchnl disable vport message * @vport: virtual port data structure * * Send disable vport virtchnl message. Returns 0 on success, negative on * failure. */ int idpf_send_disable_vport_msg(struct idpf_vport *vport) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_vport v_id; int err; v_id.vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DISABLE_VPORT, sizeof(v_id), (u8 *)&v_id); if (err) goto rel_lock; err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DIS_VPORT, IDPF_VC_DIS_VPORT_ERR); rel_lock: mutex_unlock(&vport->vc_buf_lock); return err; } /** * idpf_send_config_tx_queues_msg - Send virtchnl config tx queues message * @vport: virtual port data structure * * Send config tx queues virtchnl message. Returns 0 on success, negative on * failure. */ static int idpf_send_config_tx_queues_msg(struct idpf_vport *vport) { struct virtchnl2_config_tx_queues *ctq; u32 config_sz, chunk_sz, buf_sz; int totqs, num_msgs, num_chunks; struct virtchnl2_txq_info *qi; int err = 0, i, k = 0; totqs = vport->num_txq + vport->num_complq; qi = kcalloc(totqs, sizeof(struct virtchnl2_txq_info), GFP_KERNEL); if (!qi) return -ENOMEM; /* Populate the queue info buffer with all queue context info */ for (i = 0; i < vport->num_txq_grp; i++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; int j, sched_mode; for (j = 0; j < tx_qgrp->num_txq; j++, k++) { qi[k].queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id); qi[k].model = cpu_to_le16(vport->txq_model); qi[k].type = cpu_to_le32(tx_qgrp->txqs[j]->q_type); qi[k].ring_len = cpu_to_le16(tx_qgrp->txqs[j]->desc_count); qi[k].dma_ring_addr = cpu_to_le64(tx_qgrp->txqs[j]->dma); if (idpf_is_queue_model_split(vport->txq_model)) { struct idpf_queue *q = tx_qgrp->txqs[j]; qi[k].tx_compl_queue_id = cpu_to_le16(tx_qgrp->complq->q_id); qi[k].relative_queue_id = cpu_to_le16(j); if (test_bit(__IDPF_Q_FLOW_SCH_EN, q->flags)) qi[k].sched_mode = cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_FLOW); else qi[k].sched_mode = cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE); } else { qi[k].sched_mode = cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE); } } if (!idpf_is_queue_model_split(vport->txq_model)) continue; qi[k].queue_id = cpu_to_le32(tx_qgrp->complq->q_id); qi[k].model = cpu_to_le16(vport->txq_model); qi[k].type = cpu_to_le32(tx_qgrp->complq->q_type); qi[k].ring_len = cpu_to_le16(tx_qgrp->complq->desc_count); qi[k].dma_ring_addr = cpu_to_le64(tx_qgrp->complq->dma); if (test_bit(__IDPF_Q_FLOW_SCH_EN, tx_qgrp->complq->flags)) sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_FLOW; else sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_QUEUE; qi[k].sched_mode = cpu_to_le16(sched_mode); k++; } /* Make sure accounting agrees */ if (k != totqs) { err = -EINVAL; goto error; } /* Chunk up the queue contexts into multiple messages to avoid * sending a control queue message buffer that is too large */ config_sz = sizeof(struct virtchnl2_config_tx_queues); chunk_sz = sizeof(struct virtchnl2_txq_info); num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz), totqs); num_msgs = DIV_ROUND_UP(totqs, num_chunks); buf_sz = struct_size(ctq, qinfo, num_chunks); ctq = kzalloc(buf_sz, GFP_KERNEL); if (!ctq) { err = -ENOMEM; goto error; } mutex_lock(&vport->vc_buf_lock); for (i = 0, k = 0; i < num_msgs; i++) { memset(ctq, 0, buf_sz); ctq->vport_id = cpu_to_le32(vport->vport_id); ctq->num_qinfo = cpu_to_le16(num_chunks); memcpy(ctq->qinfo, &qi[k], chunk_sz * num_chunks); err = idpf_send_mb_msg(vport->adapter, VIRTCHNL2_OP_CONFIG_TX_QUEUES, buf_sz, (u8 *)ctq); if (err) goto mbx_error; err = idpf_wait_for_event(vport->adapter, vport, IDPF_VC_CONFIG_TXQ, IDPF_VC_CONFIG_TXQ_ERR); if (err) goto mbx_error; k += num_chunks; totqs -= num_chunks; num_chunks = min(num_chunks, totqs); /* Recalculate buffer size */ buf_sz = struct_size(ctq, qinfo, num_chunks); } mbx_error: mutex_unlock(&vport->vc_buf_lock); kfree(ctq); error: kfree(qi); return err; } /** * idpf_send_config_rx_queues_msg - Send virtchnl config rx queues message * @vport: virtual port data structure * * Send config rx queues virtchnl message. Returns 0 on success, negative on * failure. */ static int idpf_send_config_rx_queues_msg(struct idpf_vport *vport) { struct virtchnl2_config_rx_queues *crq; u32 config_sz, chunk_sz, buf_sz; int totqs, num_msgs, num_chunks; struct virtchnl2_rxq_info *qi; int err = 0, i, k = 0; totqs = vport->num_rxq + vport->num_bufq; qi = kcalloc(totqs, sizeof(struct virtchnl2_rxq_info), GFP_KERNEL); if (!qi) return -ENOMEM; /* Populate the queue info buffer with all queue context info */ for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u16 num_rxq; int j; if (!idpf_is_queue_model_split(vport->rxq_model)) goto setup_rxqs; for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) { struct idpf_queue *bufq = &rx_qgrp->splitq.bufq_sets[j].bufq; qi[k].queue_id = cpu_to_le32(bufq->q_id); qi[k].model = cpu_to_le16(vport->rxq_model); qi[k].type = cpu_to_le32(bufq->q_type); qi[k].desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M); qi[k].ring_len = cpu_to_le16(bufq->desc_count); qi[k].dma_ring_addr = cpu_to_le64(bufq->dma); qi[k].data_buffer_size = cpu_to_le32(bufq->rx_buf_size); qi[k].buffer_notif_stride = bufq->rx_buf_stride; qi[k].rx_buffer_low_watermark = cpu_to_le16(bufq->rx_buffer_low_watermark); if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW)) qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC); } setup_rxqs: if (idpf_is_queue_model_split(vport->rxq_model)) num_rxq = rx_qgrp->splitq.num_rxq_sets; else num_rxq = rx_qgrp->singleq.num_rxq; for (j = 0; j < num_rxq; j++, k++) { struct idpf_queue *rxq; if (!idpf_is_queue_model_split(vport->rxq_model)) { rxq = rx_qgrp->singleq.rxqs[j]; goto common_qi_fields; } rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq; qi[k].rx_bufq1_id = cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[0].bufq.q_id); if (vport->num_bufqs_per_qgrp > IDPF_SINGLE_BUFQ_PER_RXQ_GRP) { qi[k].bufq2_ena = IDPF_BUFQ2_ENA; qi[k].rx_bufq2_id = cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[1].bufq.q_id); } qi[k].rx_buffer_low_watermark = cpu_to_le16(rxq->rx_buffer_low_watermark); if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW)) qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC); common_qi_fields: if (rxq->rx_hsplit_en) { qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_HDR_SPLIT); qi[k].hdr_buffer_size = cpu_to_le16(rxq->rx_hbuf_size); } qi[k].queue_id = cpu_to_le32(rxq->q_id); qi[k].model = cpu_to_le16(vport->rxq_model); qi[k].type = cpu_to_le32(rxq->q_type); qi[k].ring_len = cpu_to_le16(rxq->desc_count); qi[k].dma_ring_addr = cpu_to_le64(rxq->dma); qi[k].max_pkt_size = cpu_to_le32(rxq->rx_max_pkt_size); qi[k].data_buffer_size = cpu_to_le32(rxq->rx_buf_size); qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RX_DESC_SIZE_32BYTE); qi[k].desc_ids = cpu_to_le64(rxq->rxdids); } } /* Make sure accounting agrees */ if (k != totqs) { err = -EINVAL; goto error; } /* Chunk up the queue contexts into multiple messages to avoid * sending a control queue message buffer that is too large */ config_sz = sizeof(struct virtchnl2_config_rx_queues); chunk_sz = sizeof(struct virtchnl2_rxq_info); num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz), totqs); num_msgs = DIV_ROUND_UP(totqs, num_chunks); buf_sz = struct_size(crq, qinfo, num_chunks); crq = kzalloc(buf_sz, GFP_KERNEL); if (!crq) { err = -ENOMEM; goto error; } mutex_lock(&vport->vc_buf_lock); for (i = 0, k = 0; i < num_msgs; i++) { memset(crq, 0, buf_sz); crq->vport_id = cpu_to_le32(vport->vport_id); crq->num_qinfo = cpu_to_le16(num_chunks); memcpy(crq->qinfo, &qi[k], chunk_sz * num_chunks); err = idpf_send_mb_msg(vport->adapter, VIRTCHNL2_OP_CONFIG_RX_QUEUES, buf_sz, (u8 *)crq); if (err) goto mbx_error; err = idpf_wait_for_event(vport->adapter, vport, IDPF_VC_CONFIG_RXQ, IDPF_VC_CONFIG_RXQ_ERR); if (err) goto mbx_error; k += num_chunks; totqs -= num_chunks; num_chunks = min(num_chunks, totqs); /* Recalculate buffer size */ buf_sz = struct_size(crq, qinfo, num_chunks); } mbx_error: mutex_unlock(&vport->vc_buf_lock); kfree(crq); error: kfree(qi); return err; } /** * idpf_send_ena_dis_queues_msg - Send virtchnl enable or disable * queues message * @vport: virtual port data structure * @vc_op: virtchnl op code to send * * Send enable or disable queues virtchnl message. Returns 0 on success, * negative on failure. */ static int idpf_send_ena_dis_queues_msg(struct idpf_vport *vport, u32 vc_op) { u32 num_msgs, num_chunks, num_txq, num_rxq, num_q; struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_del_ena_dis_queues *eq; struct virtchnl2_queue_chunks *qcs; struct virtchnl2_queue_chunk *qc; u32 config_sz, chunk_sz, buf_sz; int i, j, k = 0, err = 0; /* validate virtchnl op */ switch (vc_op) { case VIRTCHNL2_OP_ENABLE_QUEUES: case VIRTCHNL2_OP_DISABLE_QUEUES: break; default: return -EINVAL; } num_txq = vport->num_txq + vport->num_complq; num_rxq = vport->num_rxq + vport->num_bufq; num_q = num_txq + num_rxq; buf_sz = sizeof(struct virtchnl2_queue_chunk) * num_q; qc = kzalloc(buf_sz, GFP_KERNEL); if (!qc) return -ENOMEM; for (i = 0; i < vport->num_txq_grp; i++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; for (j = 0; j < tx_qgrp->num_txq; j++, k++) { qc[k].type = cpu_to_le32(tx_qgrp->txqs[j]->q_type); qc[k].start_queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id); qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK); } } if (vport->num_txq != k) { err = -EINVAL; goto error; } if (!idpf_is_queue_model_split(vport->txq_model)) goto setup_rx; for (i = 0; i < vport->num_txq_grp; i++, k++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; qc[k].type = cpu_to_le32(tx_qgrp->complq->q_type); qc[k].start_queue_id = cpu_to_le32(tx_qgrp->complq->q_id); qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK); } if (vport->num_complq != (k - vport->num_txq)) { err = -EINVAL; goto error; } setup_rx: for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; if (idpf_is_queue_model_split(vport->rxq_model)) num_rxq = rx_qgrp->splitq.num_rxq_sets; else num_rxq = rx_qgrp->singleq.num_rxq; for (j = 0; j < num_rxq; j++, k++) { if (idpf_is_queue_model_split(vport->rxq_model)) { qc[k].start_queue_id = cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_id); qc[k].type = cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_type); } else { qc[k].start_queue_id = cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_id); qc[k].type = cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_type); } qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK); } } if (vport->num_rxq != k - (vport->num_txq + vport->num_complq)) { err = -EINVAL; goto error; } if (!idpf_is_queue_model_split(vport->rxq_model)) goto send_msg; for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) { struct idpf_queue *q; q = &rx_qgrp->splitq.bufq_sets[j].bufq; qc[k].type = cpu_to_le32(q->q_type); qc[k].start_queue_id = cpu_to_le32(q->q_id); qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK); } } if (vport->num_bufq != k - (vport->num_txq + vport->num_complq + vport->num_rxq)) { err = -EINVAL; goto error; } send_msg: /* Chunk up the queue info into multiple messages */ config_sz = sizeof(struct virtchnl2_del_ena_dis_queues); chunk_sz = sizeof(struct virtchnl2_queue_chunk); num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz), num_q); num_msgs = DIV_ROUND_UP(num_q, num_chunks); buf_sz = struct_size(eq, chunks.chunks, num_chunks); eq = kzalloc(buf_sz, GFP_KERNEL); if (!eq) { err = -ENOMEM; goto error; } mutex_lock(&vport->vc_buf_lock); for (i = 0, k = 0; i < num_msgs; i++) { memset(eq, 0, buf_sz); eq->vport_id = cpu_to_le32(vport->vport_id); eq->chunks.num_chunks = cpu_to_le16(num_chunks); qcs = &eq->chunks; memcpy(qcs->chunks, &qc[k], chunk_sz * num_chunks); err = idpf_send_mb_msg(adapter, vc_op, buf_sz, (u8 *)eq); if (err) goto mbx_error; if (vc_op == VIRTCHNL2_OP_ENABLE_QUEUES) err = idpf_wait_for_event(adapter, vport, IDPF_VC_ENA_QUEUES, IDPF_VC_ENA_QUEUES_ERR); else err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DIS_QUEUES, IDPF_VC_DIS_QUEUES_ERR); if (err) goto mbx_error; k += num_chunks; num_q -= num_chunks; num_chunks = min(num_chunks, num_q); /* Recalculate buffer size */ buf_sz = struct_size(eq, chunks.chunks, num_chunks); } mbx_error: mutex_unlock(&vport->vc_buf_lock); kfree(eq); error: kfree(qc); return err; } /** * idpf_send_map_unmap_queue_vector_msg - Send virtchnl map or unmap queue * vector message * @vport: virtual port data structure * @map: true for map and false for unmap * * Send map or unmap queue vector virtchnl message. Returns 0 on success, * negative on failure. */ int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_queue_vector_maps *vqvm; struct virtchnl2_queue_vector *vqv; u32 config_sz, chunk_sz, buf_sz; u32 num_msgs, num_chunks, num_q; int i, j, k = 0, err = 0; num_q = vport->num_txq + vport->num_rxq; buf_sz = sizeof(struct virtchnl2_queue_vector) * num_q; vqv = kzalloc(buf_sz, GFP_KERNEL); if (!vqv) return -ENOMEM; for (i = 0; i < vport->num_txq_grp; i++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; for (j = 0; j < tx_qgrp->num_txq; j++, k++) { vqv[k].queue_type = cpu_to_le32(tx_qgrp->txqs[j]->q_type); vqv[k].queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id); if (idpf_is_queue_model_split(vport->txq_model)) { vqv[k].vector_id = cpu_to_le16(tx_qgrp->complq->q_vector->v_idx); vqv[k].itr_idx = cpu_to_le32(tx_qgrp->complq->q_vector->tx_itr_idx); } else { vqv[k].vector_id = cpu_to_le16(tx_qgrp->txqs[j]->q_vector->v_idx); vqv[k].itr_idx = cpu_to_le32(tx_qgrp->txqs[j]->q_vector->tx_itr_idx); } } } if (vport->num_txq != k) { err = -EINVAL; goto error; } for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u16 num_rxq; if (idpf_is_queue_model_split(vport->rxq_model)) num_rxq = rx_qgrp->splitq.num_rxq_sets; else num_rxq = rx_qgrp->singleq.num_rxq; for (j = 0; j < num_rxq; j++, k++) { struct idpf_queue *rxq; if (idpf_is_queue_model_split(vport->rxq_model)) rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq; else rxq = rx_qgrp->singleq.rxqs[j]; vqv[k].queue_type = cpu_to_le32(rxq->q_type); vqv[k].queue_id = cpu_to_le32(rxq->q_id); vqv[k].vector_id = cpu_to_le16(rxq->q_vector->v_idx); vqv[k].itr_idx = cpu_to_le32(rxq->q_vector->rx_itr_idx); } } if (idpf_is_queue_model_split(vport->txq_model)) { if (vport->num_rxq != k - vport->num_complq) { err = -EINVAL; goto error; } } else { if (vport->num_rxq != k - vport->num_txq) { err = -EINVAL; goto error; } } /* Chunk up the vector info into multiple messages */ config_sz = sizeof(struct virtchnl2_queue_vector_maps); chunk_sz = sizeof(struct virtchnl2_queue_vector); num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz), num_q); num_msgs = DIV_ROUND_UP(num_q, num_chunks); buf_sz = struct_size(vqvm, qv_maps, num_chunks); vqvm = kzalloc(buf_sz, GFP_KERNEL); if (!vqvm) { err = -ENOMEM; goto error; } mutex_lock(&vport->vc_buf_lock); for (i = 0, k = 0; i < num_msgs; i++) { memset(vqvm, 0, buf_sz); vqvm->vport_id = cpu_to_le32(vport->vport_id); vqvm->num_qv_maps = cpu_to_le16(num_chunks); memcpy(vqvm->qv_maps, &vqv[k], chunk_sz * num_chunks); if (map) { err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_MAP_QUEUE_VECTOR, buf_sz, (u8 *)vqvm); if (!err) err = idpf_wait_for_event(adapter, vport, IDPF_VC_MAP_IRQ, IDPF_VC_MAP_IRQ_ERR); } else { err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR, buf_sz, (u8 *)vqvm); if (!err) err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_UNMAP_IRQ, IDPF_VC_UNMAP_IRQ_ERR); } if (err) goto mbx_error; k += num_chunks; num_q -= num_chunks; num_chunks = min(num_chunks, num_q); /* Recalculate buffer size */ buf_sz = struct_size(vqvm, qv_maps, num_chunks); } mbx_error: mutex_unlock(&vport->vc_buf_lock); kfree(vqvm); error: kfree(vqv); return err; } /** * idpf_send_enable_queues_msg - send enable queues virtchnl message * @vport: Virtual port private data structure * * Will send enable queues virtchnl message. Returns 0 on success, negative on * failure. */ int idpf_send_enable_queues_msg(struct idpf_vport *vport) { return idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_ENABLE_QUEUES); } /** * idpf_send_disable_queues_msg - send disable queues virtchnl message * @vport: Virtual port private data structure * * Will send disable queues virtchnl message. Returns 0 on success, negative * on failure. */ int idpf_send_disable_queues_msg(struct idpf_vport *vport) { int err, i; err = idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_DISABLE_QUEUES); if (err) return err; /* switch to poll mode as interrupts will be disabled after disable * queues virtchnl message is sent */ for (i = 0; i < vport->num_txq; i++) set_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags); /* schedule the napi to receive all the marker packets */ for (i = 0; i < vport->num_q_vectors; i++) napi_schedule(&vport->q_vectors[i].napi); return idpf_wait_for_marker_event(vport); } /** * idpf_convert_reg_to_queue_chunks - Copy queue chunk information to the right * structure * @dchunks: Destination chunks to store data to * @schunks: Source chunks to copy data from * @num_chunks: number of chunks to copy */ static void idpf_convert_reg_to_queue_chunks(struct virtchnl2_queue_chunk *dchunks, struct virtchnl2_queue_reg_chunk *schunks, u16 num_chunks) { u16 i; for (i = 0; i < num_chunks; i++) { dchunks[i].type = schunks[i].type; dchunks[i].start_queue_id = schunks[i].start_queue_id; dchunks[i].num_queues = schunks[i].num_queues; } } /** * idpf_send_delete_queues_msg - send delete queues virtchnl message * @vport: Virtual port private data structure * * Will send delete queues virtchnl message. Return 0 on success, negative on * failure. */ int idpf_send_delete_queues_msg(struct idpf_vport *vport) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_create_vport *vport_params; struct virtchnl2_queue_reg_chunks *chunks; struct virtchnl2_del_ena_dis_queues *eq; struct idpf_vport_config *vport_config; u16 vport_idx = vport->idx; int buf_size, err; u16 num_chunks; vport_config = adapter->vport_config[vport_idx]; if (vport_config->req_qs_chunks) { struct virtchnl2_add_queues *vc_aq = (struct virtchnl2_add_queues *)vport_config->req_qs_chunks; chunks = &vc_aq->chunks; } else { vport_params = adapter->vport_params_recvd[vport_idx]; chunks = &vport_params->chunks; } num_chunks = le16_to_cpu(chunks->num_chunks); buf_size = struct_size(eq, chunks.chunks, num_chunks); eq = kzalloc(buf_size, GFP_KERNEL); if (!eq) return -ENOMEM; eq->vport_id = cpu_to_le32(vport->vport_id); eq->chunks.num_chunks = cpu_to_le16(num_chunks); idpf_convert_reg_to_queue_chunks(eq->chunks.chunks, chunks->chunks, num_chunks); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEL_QUEUES, buf_size, (u8 *)eq); if (err) goto rel_lock; err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DEL_QUEUES, IDPF_VC_DEL_QUEUES_ERR); rel_lock: mutex_unlock(&vport->vc_buf_lock); kfree(eq); return err; } /** * idpf_send_config_queues_msg - Send config queues virtchnl message * @vport: Virtual port private data structure * * Will send config queues virtchnl message. Returns 0 on success, negative on * failure. */ int idpf_send_config_queues_msg(struct idpf_vport *vport) { int err; err = idpf_send_config_tx_queues_msg(vport); if (err) return err; return idpf_send_config_rx_queues_msg(vport); } /** * idpf_send_add_queues_msg - Send virtchnl add queues message * @vport: Virtual port private data structure * @num_tx_q: number of transmit queues * @num_complq: number of transmit completion queues * @num_rx_q: number of receive queues * @num_rx_bufq: number of receive buffer queues * * Returns 0 on success, negative on failure. vport _MUST_ be const here as * we should not change any fields within vport itself in this function. */ int idpf_send_add_queues_msg(const struct idpf_vport *vport, u16 num_tx_q, u16 num_complq, u16 num_rx_q, u16 num_rx_bufq) { struct idpf_adapter *adapter = vport->adapter; struct idpf_vport_config *vport_config; struct virtchnl2_add_queues aq = { }; struct virtchnl2_add_queues *vc_msg; u16 vport_idx = vport->idx; int size, err; vport_config = adapter->vport_config[vport_idx]; aq.vport_id = cpu_to_le32(vport->vport_id); aq.num_tx_q = cpu_to_le16(num_tx_q); aq.num_tx_complq = cpu_to_le16(num_complq); aq.num_rx_q = cpu_to_le16(num_rx_q); aq.num_rx_bufq = cpu_to_le16(num_rx_bufq); mutex_lock(&((struct idpf_vport *)vport)->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ADD_QUEUES, sizeof(struct virtchnl2_add_queues), (u8 *)&aq); if (err) goto rel_lock; /* We want vport to be const to prevent incidental code changes making * changes to the vport config. We're making a special exception here * to discard const to use the virtchnl. */ err = idpf_wait_for_event(adapter, (struct idpf_vport *)vport, IDPF_VC_ADD_QUEUES, IDPF_VC_ADD_QUEUES_ERR); if (err) goto rel_lock; kfree(vport_config->req_qs_chunks); vport_config->req_qs_chunks = NULL; vc_msg = (struct virtchnl2_add_queues *)vport->vc_msg; /* compare vc_msg num queues with vport num queues */ if (le16_to_cpu(vc_msg->num_tx_q) != num_tx_q || le16_to_cpu(vc_msg->num_rx_q) != num_rx_q || le16_to_cpu(vc_msg->num_tx_complq) != num_complq || le16_to_cpu(vc_msg->num_rx_bufq) != num_rx_bufq) { err = -EINVAL; goto rel_lock; } size = struct_size(vc_msg, chunks.chunks, le16_to_cpu(vc_msg->chunks.num_chunks)); vport_config->req_qs_chunks = kmemdup(vc_msg, size, GFP_KERNEL); if (!vport_config->req_qs_chunks) { err = -ENOMEM; goto rel_lock; } rel_lock: mutex_unlock(&((struct idpf_vport *)vport)->vc_buf_lock); return err; } /** * idpf_send_alloc_vectors_msg - Send virtchnl alloc vectors message * @adapter: Driver specific private structure * @num_vectors: number of vectors to be allocated * * Returns 0 on success, negative on failure. */ int idpf_send_alloc_vectors_msg(struct idpf_adapter *adapter, u16 num_vectors) { struct virtchnl2_alloc_vectors *alloc_vec, *rcvd_vec; struct virtchnl2_alloc_vectors ac = { }; u16 num_vchunks; int size, err; ac.num_vectors = cpu_to_le16(num_vectors); mutex_lock(&adapter->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ALLOC_VECTORS, sizeof(ac), (u8 *)&ac); if (err) goto rel_lock; err = idpf_wait_for_event(adapter, NULL, IDPF_VC_ALLOC_VECTORS, IDPF_VC_ALLOC_VECTORS_ERR); if (err) goto rel_lock; rcvd_vec = (struct virtchnl2_alloc_vectors *)adapter->vc_msg; num_vchunks = le16_to_cpu(rcvd_vec->vchunks.num_vchunks); size = struct_size(rcvd_vec, vchunks.vchunks, num_vchunks); if (size > sizeof(adapter->vc_msg)) { err = -EINVAL; goto rel_lock; } kfree(adapter->req_vec_chunks); adapter->req_vec_chunks = NULL; adapter->req_vec_chunks = kmemdup(adapter->vc_msg, size, GFP_KERNEL); if (!adapter->req_vec_chunks) { err = -ENOMEM; goto rel_lock; } alloc_vec = adapter->req_vec_chunks; if (le16_to_cpu(alloc_vec->num_vectors) < num_vectors) { kfree(adapter->req_vec_chunks); adapter->req_vec_chunks = NULL; err = -EINVAL; } rel_lock: mutex_unlock(&adapter->vc_buf_lock); return err; } /** * idpf_send_dealloc_vectors_msg - Send virtchnl de allocate vectors message * @adapter: Driver specific private structure * * Returns 0 on success, negative on failure. */ int idpf_send_dealloc_vectors_msg(struct idpf_adapter *adapter) { struct virtchnl2_alloc_vectors *ac = adapter->req_vec_chunks; struct virtchnl2_vector_chunks *vcs = &ac->vchunks; int buf_size, err; buf_size = struct_size(vcs, vchunks, le16_to_cpu(vcs->num_vchunks)); mutex_lock(&adapter->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEALLOC_VECTORS, buf_size, (u8 *)vcs); if (err) goto rel_lock; err = idpf_min_wait_for_event(adapter, NULL, IDPF_VC_DEALLOC_VECTORS, IDPF_VC_DEALLOC_VECTORS_ERR); if (err) goto rel_lock; kfree(adapter->req_vec_chunks); adapter->req_vec_chunks = NULL; rel_lock: mutex_unlock(&adapter->vc_buf_lock); return err; } /** * idpf_get_max_vfs - Get max number of vfs supported * @adapter: Driver specific private structure * * Returns max number of VFs */ static int idpf_get_max_vfs(struct idpf_adapter *adapter) { return le16_to_cpu(adapter->caps.max_sriov_vfs); } /** * idpf_send_set_sriov_vfs_msg - Send virtchnl set sriov vfs message * @adapter: Driver specific private structure * @num_vfs: number of virtual functions to be created * * Returns 0 on success, negative on failure. */ int idpf_send_set_sriov_vfs_msg(struct idpf_adapter *adapter, u16 num_vfs) { struct virtchnl2_sriov_vfs_info svi = { }; int err; svi.num_vfs = cpu_to_le16(num_vfs); mutex_lock(&adapter->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_SRIOV_VFS, sizeof(svi), (u8 *)&svi); if (err) goto rel_lock; err = idpf_wait_for_event(adapter, NULL, IDPF_VC_SET_SRIOV_VFS, IDPF_VC_SET_SRIOV_VFS_ERR); rel_lock: mutex_unlock(&adapter->vc_buf_lock); return err; } /** * idpf_send_get_stats_msg - Send virtchnl get statistics message * @vport: vport to get stats for * * Returns 0 on success, negative on failure. */ int idpf_send_get_stats_msg(struct idpf_vport *vport) { struct idpf_netdev_priv *np = netdev_priv(vport->netdev); struct rtnl_link_stats64 *netstats = &np->netstats; struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_vport_stats stats_msg = { }; struct virtchnl2_vport_stats *stats; int err; /* Don't send get_stats message if the link is down */ if (np->state <= __IDPF_VPORT_DOWN) return 0; stats_msg.vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_STATS, sizeof(struct virtchnl2_vport_stats), (u8 *)&stats_msg); if (err) goto rel_lock; err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_STATS, IDPF_VC_GET_STATS_ERR); if (err) goto rel_lock; stats = (struct virtchnl2_vport_stats *)vport->vc_msg; spin_lock_bh(&np->stats_lock); netstats->rx_packets = le64_to_cpu(stats->rx_unicast) + le64_to_cpu(stats->rx_multicast) + le64_to_cpu(stats->rx_broadcast); netstats->rx_bytes = le64_to_cpu(stats->rx_bytes); netstats->rx_dropped = le64_to_cpu(stats->rx_discards); netstats->rx_over_errors = le64_to_cpu(stats->rx_overflow_drop); netstats->rx_length_errors = le64_to_cpu(stats->rx_invalid_frame_length); netstats->tx_packets = le64_to_cpu(stats->tx_unicast) + le64_to_cpu(stats->tx_multicast) + le64_to_cpu(stats->tx_broadcast); netstats->tx_bytes = le64_to_cpu(stats->tx_bytes); netstats->tx_errors = le64_to_cpu(stats->tx_errors); netstats->tx_dropped = le64_to_cpu(stats->tx_discards); vport->port_stats.vport_stats = *stats; spin_unlock_bh(&np->stats_lock); rel_lock: mutex_unlock(&vport->vc_buf_lock); return err; } /** * idpf_send_get_set_rss_lut_msg - Send virtchnl get or set rss lut message * @vport: virtual port data structure * @get: flag to set or get rss look up table * * Returns 0 on success, negative on failure. */ int idpf_send_get_set_rss_lut_msg(struct idpf_vport *vport, bool get) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_rss_lut *recv_rl; struct idpf_rss_data *rss_data; struct virtchnl2_rss_lut *rl; int buf_size, lut_buf_size; int i, err; rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data; buf_size = struct_size(rl, lut, rss_data->rss_lut_size); rl = kzalloc(buf_size, GFP_KERNEL); if (!rl) return -ENOMEM; rl->vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); if (!get) { rl->lut_entries = cpu_to_le16(rss_data->rss_lut_size); for (i = 0; i < rss_data->rss_lut_size; i++) rl->lut[i] = cpu_to_le32(rss_data->rss_lut[i]); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_LUT, buf_size, (u8 *)rl); if (err) goto free_mem; err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_LUT, IDPF_VC_SET_RSS_LUT_ERR); goto free_mem; } err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_LUT, buf_size, (u8 *)rl); if (err) goto free_mem; err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_LUT, IDPF_VC_GET_RSS_LUT_ERR); if (err) goto free_mem; recv_rl = (struct virtchnl2_rss_lut *)vport->vc_msg; if (rss_data->rss_lut_size == le16_to_cpu(recv_rl->lut_entries)) goto do_memcpy; rss_data->rss_lut_size = le16_to_cpu(recv_rl->lut_entries); kfree(rss_data->rss_lut); lut_buf_size = rss_data->rss_lut_size * sizeof(u32); rss_data->rss_lut = kzalloc(lut_buf_size, GFP_KERNEL); if (!rss_data->rss_lut) { rss_data->rss_lut_size = 0; err = -ENOMEM; goto free_mem; } do_memcpy: memcpy(rss_data->rss_lut, vport->vc_msg, rss_data->rss_lut_size); free_mem: mutex_unlock(&vport->vc_buf_lock); kfree(rl); return err; } /** * idpf_send_get_set_rss_key_msg - Send virtchnl get or set rss key message * @vport: virtual port data structure * @get: flag to set or get rss look up table * * Returns 0 on success, negative on failure */ int idpf_send_get_set_rss_key_msg(struct idpf_vport *vport, bool get) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_rss_key *recv_rk; struct idpf_rss_data *rss_data; struct virtchnl2_rss_key *rk; int i, buf_size, err; rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data; buf_size = struct_size(rk, key_flex, rss_data->rss_key_size); rk = kzalloc(buf_size, GFP_KERNEL); if (!rk) return -ENOMEM; rk->vport_id = cpu_to_le32(vport->vport_id); mutex_lock(&vport->vc_buf_lock); if (get) { err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_KEY, buf_size, (u8 *)rk); if (err) goto error; err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_KEY, IDPF_VC_GET_RSS_KEY_ERR); if (err) goto error; recv_rk = (struct virtchnl2_rss_key *)vport->vc_msg; if (rss_data->rss_key_size != le16_to_cpu(recv_rk->key_len)) { rss_data->rss_key_size = min_t(u16, NETDEV_RSS_KEY_LEN, le16_to_cpu(recv_rk->key_len)); kfree(rss_data->rss_key); rss_data->rss_key = kzalloc(rss_data->rss_key_size, GFP_KERNEL); if (!rss_data->rss_key) { rss_data->rss_key_size = 0; err = -ENOMEM; goto error; } } memcpy(rss_data->rss_key, recv_rk->key_flex, rss_data->rss_key_size); } else { rk->key_len = cpu_to_le16(rss_data->rss_key_size); for (i = 0; i < rss_data->rss_key_size; i++) rk->key_flex[i] = rss_data->rss_key[i]; err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_KEY, buf_size, (u8 *)rk); if (err) goto error; err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_KEY, IDPF_VC_SET_RSS_KEY_ERR); } error: mutex_unlock(&vport->vc_buf_lock); kfree(rk); return err; } /** * idpf_fill_ptype_lookup - Fill L3 specific fields in ptype lookup table * @ptype: ptype lookup table * @pstate: state machine for ptype lookup table * @ipv4: ipv4 or ipv6 * @frag: fragmentation allowed * */ static void idpf_fill_ptype_lookup(struct idpf_rx_ptype_decoded *ptype, struct idpf_ptype_state *pstate, bool ipv4, bool frag) { if (!pstate->outer_ip || !pstate->outer_frag) { ptype->outer_ip = IDPF_RX_PTYPE_OUTER_IP; pstate->outer_ip = true; if (ipv4) ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV4; else ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV6; if (frag) { ptype->outer_frag = IDPF_RX_PTYPE_FRAG; pstate->outer_frag = true; } } else { ptype->tunnel_type = IDPF_RX_PTYPE_TUNNEL_IP_IP; pstate->tunnel_state = IDPF_PTYPE_TUNNEL_IP; if (ipv4) ptype->tunnel_end_prot = IDPF_RX_PTYPE_TUNNEL_END_IPV4; else ptype->tunnel_end_prot = IDPF_RX_PTYPE_TUNNEL_END_IPV6; if (frag) ptype->tunnel_end_frag = IDPF_RX_PTYPE_FRAG; } } /** * idpf_send_get_rx_ptype_msg - Send virtchnl for ptype info * @vport: virtual port data structure * * Returns 0 on success, negative on failure. */ int idpf_send_get_rx_ptype_msg(struct idpf_vport *vport) { struct idpf_rx_ptype_decoded *ptype_lkup = vport->rx_ptype_lkup; struct virtchnl2_get_ptype_info get_ptype_info; int max_ptype, ptypes_recvd = 0, ptype_offset; struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_get_ptype_info *ptype_info; u16 next_ptype_id = 0; int err = 0, i, j, k; if (idpf_is_queue_model_split(vport->rxq_model)) max_ptype = IDPF_RX_MAX_PTYPE; else max_ptype = IDPF_RX_MAX_BASE_PTYPE; memset(vport->rx_ptype_lkup, 0, sizeof(vport->rx_ptype_lkup)); ptype_info = kzalloc(IDPF_CTLQ_MAX_BUF_LEN, GFP_KERNEL); if (!ptype_info) return -ENOMEM; mutex_lock(&adapter->vc_buf_lock); while (next_ptype_id < max_ptype) { get_ptype_info.start_ptype_id = cpu_to_le16(next_ptype_id); if ((next_ptype_id + IDPF_RX_MAX_PTYPES_PER_BUF) > max_ptype) get_ptype_info.num_ptypes = cpu_to_le16(max_ptype - next_ptype_id); else get_ptype_info.num_ptypes = cpu_to_le16(IDPF_RX_MAX_PTYPES_PER_BUF); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_PTYPE_INFO, sizeof(struct virtchnl2_get_ptype_info), (u8 *)&get_ptype_info); if (err) goto vc_buf_unlock; err = idpf_wait_for_event(adapter, NULL, IDPF_VC_GET_PTYPE_INFO, IDPF_VC_GET_PTYPE_INFO_ERR); if (err) goto vc_buf_unlock; memcpy(ptype_info, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN); ptypes_recvd += le16_to_cpu(ptype_info->num_ptypes); if (ptypes_recvd > max_ptype) { err = -EINVAL; goto vc_buf_unlock; } next_ptype_id = le16_to_cpu(get_ptype_info.start_ptype_id) + le16_to_cpu(get_ptype_info.num_ptypes); ptype_offset = IDPF_RX_PTYPE_HDR_SZ; for (i = 0; i < le16_to_cpu(ptype_info->num_ptypes); i++) { struct idpf_ptype_state pstate = { }; struct virtchnl2_ptype *ptype; u16 id; ptype = (struct virtchnl2_ptype *) ((u8 *)ptype_info + ptype_offset); ptype_offset += IDPF_GET_PTYPE_SIZE(ptype); if (ptype_offset > IDPF_CTLQ_MAX_BUF_LEN) { err = -EINVAL; goto vc_buf_unlock; } /* 0xFFFF indicates end of ptypes */ if (le16_to_cpu(ptype->ptype_id_10) == IDPF_INVALID_PTYPE_ID) { err = 0; goto vc_buf_unlock; } if (idpf_is_queue_model_split(vport->rxq_model)) k = le16_to_cpu(ptype->ptype_id_10); else k = ptype->ptype_id_8; if (ptype->proto_id_count) ptype_lkup[k].known = 1; for (j = 0; j < ptype->proto_id_count; j++) { id = le16_to_cpu(ptype->proto_id[j]); switch (id) { case VIRTCHNL2_PROTO_HDR_GRE: if (pstate.tunnel_state == IDPF_PTYPE_TUNNEL_IP) { ptype_lkup[k].tunnel_type = IDPF_RX_PTYPE_TUNNEL_IP_GRENAT; pstate.tunnel_state |= IDPF_PTYPE_TUNNEL_IP_GRENAT; } break; case VIRTCHNL2_PROTO_HDR_MAC: ptype_lkup[k].outer_ip = IDPF_RX_PTYPE_OUTER_L2; if (pstate.tunnel_state == IDPF_TUN_IP_GRE) { ptype_lkup[k].tunnel_type = IDPF_RX_PTYPE_TUNNEL_IP_GRENAT_MAC; pstate.tunnel_state |= IDPF_PTYPE_TUNNEL_IP_GRENAT_MAC; } break; case VIRTCHNL2_PROTO_HDR_IPV4: idpf_fill_ptype_lookup(&ptype_lkup[k], &pstate, true, false); break; case VIRTCHNL2_PROTO_HDR_IPV6: idpf_fill_ptype_lookup(&ptype_lkup[k], &pstate, false, false); break; case VIRTCHNL2_PROTO_HDR_IPV4_FRAG: idpf_fill_ptype_lookup(&ptype_lkup[k], &pstate, true, true); break; case VIRTCHNL2_PROTO_HDR_IPV6_FRAG: idpf_fill_ptype_lookup(&ptype_lkup[k], &pstate, false, true); break; case VIRTCHNL2_PROTO_HDR_UDP: ptype_lkup[k].inner_prot = IDPF_RX_PTYPE_INNER_PROT_UDP; break; case VIRTCHNL2_PROTO_HDR_TCP: ptype_lkup[k].inner_prot = IDPF_RX_PTYPE_INNER_PROT_TCP; break; case VIRTCHNL2_PROTO_HDR_SCTP: ptype_lkup[k].inner_prot = IDPF_RX_PTYPE_INNER_PROT_SCTP; break; case VIRTCHNL2_PROTO_HDR_ICMP: ptype_lkup[k].inner_prot = IDPF_RX_PTYPE_INNER_PROT_ICMP; break; case VIRTCHNL2_PROTO_HDR_PAY: ptype_lkup[k].payload_layer = IDPF_RX_PTYPE_PAYLOAD_LAYER_PAY2; break; case VIRTCHNL2_PROTO_HDR_ICMPV6: case VIRTCHNL2_PROTO_HDR_IPV6_EH: case VIRTCHNL2_PROTO_HDR_PRE_MAC: case VIRTCHNL2_PROTO_HDR_POST_MAC: case VIRTCHNL2_PROTO_HDR_ETHERTYPE: case VIRTCHNL2_PROTO_HDR_SVLAN: case VIRTCHNL2_PROTO_HDR_CVLAN: case VIRTCHNL2_PROTO_HDR_MPLS: case VIRTCHNL2_PROTO_HDR_MMPLS: case VIRTCHNL2_PROTO_HDR_PTP: case VIRTCHNL2_PROTO_HDR_CTRL: case VIRTCHNL2_PROTO_HDR_LLDP: case VIRTCHNL2_PROTO_HDR_ARP: case VIRTCHNL2_PROTO_HDR_ECP: case VIRTCHNL2_PROTO_HDR_EAPOL: case VIRTCHNL2_PROTO_HDR_PPPOD: case VIRTCHNL2_PROTO_HDR_PPPOE: case VIRTCHNL2_PROTO_HDR_IGMP: case VIRTCHNL2_PROTO_HDR_AH: case VIRTCHNL2_PROTO_HDR_ESP: case VIRTCHNL2_PROTO_HDR_IKE: case VIRTCHNL2_PROTO_HDR_NATT_KEEP: case VIRTCHNL2_PROTO_HDR_L2TPV2: case VIRTCHNL2_PROTO_HDR_L2TPV2_CONTROL: case VIRTCHNL2_PROTO_HDR_L2TPV3: case VIRTCHNL2_PROTO_HDR_GTP: case VIRTCHNL2_PROTO_HDR_GTP_EH: case VIRTCHNL2_PROTO_HDR_GTPCV2: case VIRTCHNL2_PROTO_HDR_GTPC_TEID: case VIRTCHNL2_PROTO_HDR_GTPU: case VIRTCHNL2_PROTO_HDR_GTPU_UL: case VIRTCHNL2_PROTO_HDR_GTPU_DL: case VIRTCHNL2_PROTO_HDR_ECPRI: case VIRTCHNL2_PROTO_HDR_VRRP: case VIRTCHNL2_PROTO_HDR_OSPF: case VIRTCHNL2_PROTO_HDR_TUN: case VIRTCHNL2_PROTO_HDR_NVGRE: case VIRTCHNL2_PROTO_HDR_VXLAN: case VIRTCHNL2_PROTO_HDR_VXLAN_GPE: case VIRTCHNL2_PROTO_HDR_GENEVE: case VIRTCHNL2_PROTO_HDR_NSH: case VIRTCHNL2_PROTO_HDR_QUIC: case VIRTCHNL2_PROTO_HDR_PFCP: case VIRTCHNL2_PROTO_HDR_PFCP_NODE: case VIRTCHNL2_PROTO_HDR_PFCP_SESSION: case VIRTCHNL2_PROTO_HDR_RTP: case VIRTCHNL2_PROTO_HDR_NO_PROTO: break; default: break; } } } } vc_buf_unlock: mutex_unlock(&adapter->vc_buf_lock); kfree(ptype_info); return err; } /** * idpf_send_ena_dis_loopback_msg - Send virtchnl enable/disable loopback * message * @vport: virtual port data structure * * Returns 0 on success, negative on failure. */ int idpf_send_ena_dis_loopback_msg(struct idpf_vport *vport) { struct virtchnl2_loopback loopback; int err; loopback.vport_id = cpu_to_le32(vport->vport_id); loopback.enable = idpf_is_feature_ena(vport, NETIF_F_LOOPBACK); mutex_lock(&vport->vc_buf_lock); err = idpf_send_mb_msg(vport->adapter, VIRTCHNL2_OP_LOOPBACK, sizeof(loopback), (u8 *)&loopback); if (err) goto rel_lock; err = idpf_wait_for_event(vport->adapter, vport, IDPF_VC_LOOPBACK_STATE, IDPF_VC_LOOPBACK_STATE_ERR); rel_lock: mutex_unlock(&vport->vc_buf_lock); return err; } /** * idpf_find_ctlq - Given a type and id, find ctlq info * @hw: hardware struct * @type: type of ctrlq to find * @id: ctlq id to find * * Returns pointer to found ctlq info struct, NULL otherwise. */ static struct idpf_ctlq_info *idpf_find_ctlq(struct idpf_hw *hw, enum idpf_ctlq_type type, int id) { struct idpf_ctlq_info *cq, *tmp; list_for_each_entry_safe(cq, tmp, &hw->cq_list_head, cq_list) if (cq->q_id == id && cq->cq_type == type) return cq; return NULL; } /** * idpf_init_dflt_mbx - Setup default mailbox parameters and make request * @adapter: adapter info struct * * Returns 0 on success, negative otherwise */ int idpf_init_dflt_mbx(struct idpf_adapter *adapter) { struct idpf_ctlq_create_info ctlq_info[] = { { .type = IDPF_CTLQ_TYPE_MAILBOX_TX, .id = IDPF_DFLT_MBX_ID, .len = IDPF_DFLT_MBX_Q_LEN, .buf_size = IDPF_CTLQ_MAX_BUF_LEN }, { .type = IDPF_CTLQ_TYPE_MAILBOX_RX, .id = IDPF_DFLT_MBX_ID, .len = IDPF_DFLT_MBX_Q_LEN, .buf_size = IDPF_CTLQ_MAX_BUF_LEN } }; struct idpf_hw *hw = &adapter->hw; int err; adapter->dev_ops.reg_ops.ctlq_reg_init(ctlq_info); err = idpf_ctlq_init(hw, IDPF_NUM_DFLT_MBX_Q, ctlq_info); if (err) return err; hw->asq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_TX, IDPF_DFLT_MBX_ID); hw->arq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_RX, IDPF_DFLT_MBX_ID); if (!hw->asq || !hw->arq) { idpf_ctlq_deinit(hw); return -ENOENT; } adapter->state = __IDPF_STARTUP; return 0; } /** * idpf_deinit_dflt_mbx - Free up ctlqs setup * @adapter: Driver specific private data structure */ void idpf_deinit_dflt_mbx(struct idpf_adapter *adapter) { if (adapter->hw.arq && adapter->hw.asq) { idpf_mb_clean(adapter); idpf_ctlq_deinit(&adapter->hw); } adapter->hw.arq = NULL; adapter->hw.asq = NULL; } /** * idpf_vport_params_buf_rel - Release memory for MailBox resources * @adapter: Driver specific private data structure * * Will release memory to hold the vport parameters received on MailBox */ static void idpf_vport_params_buf_rel(struct idpf_adapter *adapter) { kfree(adapter->vport_params_recvd); adapter->vport_params_recvd = NULL; kfree(adapter->vport_params_reqd); adapter->vport_params_reqd = NULL; kfree(adapter->vport_ids); adapter->vport_ids = NULL; } /** * idpf_vport_params_buf_alloc - Allocate memory for MailBox resources * @adapter: Driver specific private data structure * * Will alloc memory to hold the vport parameters received on MailBox */ static int idpf_vport_params_buf_alloc(struct idpf_adapter *adapter) { u16 num_max_vports = idpf_get_max_vports(adapter); adapter->vport_params_reqd = kcalloc(num_max_vports, sizeof(*adapter->vport_params_reqd), GFP_KERNEL); if (!adapter->vport_params_reqd) return -ENOMEM; adapter->vport_params_recvd = kcalloc(num_max_vports, sizeof(*adapter->vport_params_recvd), GFP_KERNEL); if (!adapter->vport_params_recvd) goto err_mem; adapter->vport_ids = kcalloc(num_max_vports, sizeof(u32), GFP_KERNEL); if (!adapter->vport_ids) goto err_mem; if (adapter->vport_config) return 0; adapter->vport_config = kcalloc(num_max_vports, sizeof(*adapter->vport_config), GFP_KERNEL); if (!adapter->vport_config) goto err_mem; return 0; err_mem: idpf_vport_params_buf_rel(adapter); return -ENOMEM; } /** * idpf_vc_core_init - Initialize state machine and get driver specific * resources * @adapter: Driver specific private structure * * This function will initialize the state machine and request all necessary * resources required by the device driver. Once the state machine is * initialized, allocate memory to store vport specific information and also * requests required interrupts. * * Returns 0 on success, -EAGAIN function will get called again, * otherwise negative on failure. */ int idpf_vc_core_init(struct idpf_adapter *adapter) { int task_delay = 30; u16 num_max_vports; int err = 0; while (adapter->state != __IDPF_INIT_SW) { switch (adapter->state) { case __IDPF_STARTUP: if (idpf_send_ver_msg(adapter)) goto init_failed; adapter->state = __IDPF_VER_CHECK; goto restart; case __IDPF_VER_CHECK: err = idpf_recv_ver_msg(adapter); if (err == -EIO) { return err; } else if (err == -EAGAIN) { adapter->state = __IDPF_STARTUP; goto restart; } else if (err) { goto init_failed; } if (idpf_send_get_caps_msg(adapter)) goto init_failed; adapter->state = __IDPF_GET_CAPS; goto restart; case __IDPF_GET_CAPS: if (idpf_recv_get_caps_msg(adapter)) goto init_failed; adapter->state = __IDPF_INIT_SW; break; default: dev_err(&adapter->pdev->dev, "Device is in bad state: %d\n", adapter->state); goto init_failed; } break; restart: /* Give enough time before proceeding further with * state machine */ msleep(task_delay); } pci_sriov_set_totalvfs(adapter->pdev, idpf_get_max_vfs(adapter)); num_max_vports = idpf_get_max_vports(adapter); adapter->max_vports = num_max_vports; adapter->vports = kcalloc(num_max_vports, sizeof(*adapter->vports), GFP_KERNEL); if (!adapter->vports) return -ENOMEM; if (!adapter->netdevs) { adapter->netdevs = kcalloc(num_max_vports, sizeof(struct net_device *), GFP_KERNEL); if (!adapter->netdevs) { err = -ENOMEM; goto err_netdev_alloc; } } err = idpf_vport_params_buf_alloc(adapter); if (err) { dev_err(&adapter->pdev->dev, "Failed to alloc vport params buffer: %d\n", err); goto err_netdev_alloc; } /* Start the mailbox task before requesting vectors. This will ensure * vector information response from mailbox is handled */ queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0); queue_delayed_work(adapter->serv_wq, &adapter->serv_task, msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07))); err = idpf_intr_req(adapter); if (err) { dev_err(&adapter->pdev->dev, "failed to enable interrupt vectors: %d\n", err); goto err_intr_req; } idpf_init_avail_queues(adapter); /* Skew the delay for init tasks for each function based on fn number * to prevent every function from making the same call simultaneously. */ queue_delayed_work(adapter->init_wq, &adapter->init_task, msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07))); goto no_err; err_intr_req: cancel_delayed_work_sync(&adapter->serv_task); cancel_delayed_work_sync(&adapter->mbx_task); idpf_vport_params_buf_rel(adapter); err_netdev_alloc: kfree(adapter->vports); adapter->vports = NULL; no_err: return err; init_failed: /* Don't retry if we're trying to go down, just bail. */ if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) return err; if (++adapter->mb_wait_count > IDPF_MB_MAX_ERR) { dev_err(&adapter->pdev->dev, "Failed to establish mailbox communications with hardware\n"); return -EFAULT; } /* If it reached here, it is possible that mailbox queue initialization * register writes might not have taken effect. Retry to initialize * the mailbox again */ adapter->state = __IDPF_STARTUP; idpf_deinit_dflt_mbx(adapter); set_bit(IDPF_HR_DRV_LOAD, adapter->flags); queue_delayed_work(adapter->vc_event_wq, &adapter->vc_event_task, msecs_to_jiffies(task_delay)); return -EAGAIN; } /** * idpf_vc_core_deinit - Device deinit routine * @adapter: Driver specific private structure * */ void idpf_vc_core_deinit(struct idpf_adapter *adapter) { int i; idpf_deinit_task(adapter); idpf_intr_rel(adapter); /* Set all bits as we dont know on which vc_state the vhnl_wq is * waiting on and wakeup the virtchnl workqueue even if it is waiting * for the response as we are going down */ for (i = 0; i < IDPF_VC_NBITS; i++) set_bit(i, adapter->vc_state); wake_up(&adapter->vchnl_wq); cancel_delayed_work_sync(&adapter->serv_task); cancel_delayed_work_sync(&adapter->mbx_task); idpf_vport_params_buf_rel(adapter); /* Clear all the bits */ for (i = 0; i < IDPF_VC_NBITS; i++) clear_bit(i, adapter->vc_state); kfree(adapter->vports); adapter->vports = NULL; } /** * idpf_vport_alloc_vec_indexes - Get relative vector indexes * @vport: virtual port data struct * * This function requests the vector information required for the vport and * stores the vector indexes received from the 'global vector distribution' * in the vport's queue vectors array. * * Return 0 on success, error on failure */ int idpf_vport_alloc_vec_indexes(struct idpf_vport *vport) { struct idpf_vector_info vec_info; int num_alloc_vecs; vec_info.num_curr_vecs = vport->num_q_vectors; vec_info.num_req_vecs = max(vport->num_txq, vport->num_rxq); vec_info.default_vport = vport->default_vport; vec_info.index = vport->idx; num_alloc_vecs = idpf_req_rel_vector_indexes(vport->adapter, vport->q_vector_idxs, &vec_info); if (num_alloc_vecs <= 0) { dev_err(&vport->adapter->pdev->dev, "Vector distribution failed: %d\n", num_alloc_vecs); return -EINVAL; } vport->num_q_vectors = num_alloc_vecs; return 0; } /** * idpf_vport_init - Initialize virtual port * @vport: virtual port to be initialized * @max_q: vport max queue info * * Will initialize vport with the info received through MB earlier */ void idpf_vport_init(struct idpf_vport *vport, struct idpf_vport_max_q *max_q) { struct idpf_adapter *adapter = vport->adapter; struct virtchnl2_create_vport *vport_msg; struct idpf_vport_config *vport_config; u16 tx_itr[] = {2, 8, 64, 128, 256}; u16 rx_itr[] = {2, 8, 32, 96, 128}; struct idpf_rss_data *rss_data; u16 idx = vport->idx; vport_config = adapter->vport_config[idx]; rss_data = &vport_config->user_config.rss_data; vport_msg = adapter->vport_params_recvd[idx]; vport_config->max_q.max_txq = max_q->max_txq; vport_config->max_q.max_rxq = max_q->max_rxq; vport_config->max_q.max_complq = max_q->max_complq; vport_config->max_q.max_bufq = max_q->max_bufq; vport->txq_model = le16_to_cpu(vport_msg->txq_model); vport->rxq_model = le16_to_cpu(vport_msg->rxq_model); vport->vport_type = le16_to_cpu(vport_msg->vport_type); vport->vport_id = le32_to_cpu(vport_msg->vport_id); rss_data->rss_key_size = min_t(u16, NETDEV_RSS_KEY_LEN, le16_to_cpu(vport_msg->rss_key_size)); rss_data->rss_lut_size = le16_to_cpu(vport_msg->rss_lut_size); ether_addr_copy(vport->default_mac_addr, vport_msg->default_mac_addr); vport->max_mtu = le16_to_cpu(vport_msg->max_mtu) - IDPF_PACKET_HDR_PAD; /* Initialize Tx and Rx profiles for Dynamic Interrupt Moderation */ memcpy(vport->rx_itr_profile, rx_itr, IDPF_DIM_PROFILE_SLOTS); memcpy(vport->tx_itr_profile, tx_itr, IDPF_DIM_PROFILE_SLOTS); idpf_vport_init_num_qs(vport, vport_msg); idpf_vport_calc_num_q_desc(vport); idpf_vport_calc_num_q_groups(vport); idpf_vport_alloc_vec_indexes(vport); vport->crc_enable = adapter->crc_enable; } /** * idpf_get_vec_ids - Initialize vector id from Mailbox parameters * @adapter: adapter structure to get the mailbox vector id * @vecids: Array of vector ids * @num_vecids: number of vector ids * @chunks: vector ids received over mailbox * * Will initialize the mailbox vector id which is received from the * get capabilities and data queue vector ids with ids received as * mailbox parameters. * Returns number of ids filled */ int idpf_get_vec_ids(struct idpf_adapter *adapter, u16 *vecids, int num_vecids, struct virtchnl2_vector_chunks *chunks) { u16 num_chunks = le16_to_cpu(chunks->num_vchunks); int num_vecid_filled = 0; int i, j; vecids[num_vecid_filled] = adapter->mb_vector.v_idx; num_vecid_filled++; for (j = 0; j < num_chunks; j++) { struct virtchnl2_vector_chunk *chunk; u16 start_vecid, num_vec; chunk = &chunks->vchunks[j]; num_vec = le16_to_cpu(chunk->num_vectors); start_vecid = le16_to_cpu(chunk->start_vector_id); for (i = 0; i < num_vec; i++) { if ((num_vecid_filled + i) < num_vecids) { vecids[num_vecid_filled + i] = start_vecid; start_vecid++; } else { break; } } num_vecid_filled = num_vecid_filled + i; } return num_vecid_filled; } /** * idpf_vport_get_queue_ids - Initialize queue id from Mailbox parameters * @qids: Array of queue ids * @num_qids: number of queue ids * @q_type: queue model * @chunks: queue ids received over mailbox * * Will initialize all queue ids with ids received as mailbox parameters * Returns number of ids filled */ static int idpf_vport_get_queue_ids(u32 *qids, int num_qids, u16 q_type, struct virtchnl2_queue_reg_chunks *chunks) { u16 num_chunks = le16_to_cpu(chunks->num_chunks); u32 num_q_id_filled = 0, i; u32 start_q_id, num_q; while (num_chunks--) { struct virtchnl2_queue_reg_chunk *chunk; chunk = &chunks->chunks[num_chunks]; if (le32_to_cpu(chunk->type) != q_type) continue; num_q = le32_to_cpu(chunk->num_queues); start_q_id = le32_to_cpu(chunk->start_queue_id); for (i = 0; i < num_q; i++) { if ((num_q_id_filled + i) < num_qids) { qids[num_q_id_filled + i] = start_q_id; start_q_id++; } else { break; } } num_q_id_filled = num_q_id_filled + i; } return num_q_id_filled; } /** * __idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters * @vport: virtual port for which the queues ids are initialized * @qids: queue ids * @num_qids: number of queue ids * @q_type: type of queue * * Will initialize all queue ids with ids received as mailbox * parameters. Returns number of queue ids initialized. */ static int __idpf_vport_queue_ids_init(struct idpf_vport *vport, const u32 *qids, int num_qids, u32 q_type) { struct idpf_queue *q; int i, j, k = 0; switch (q_type) { case VIRTCHNL2_QUEUE_TYPE_TX: for (i = 0; i < vport->num_txq_grp; i++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; for (j = 0; j < tx_qgrp->num_txq && k < num_qids; j++, k++) { tx_qgrp->txqs[j]->q_id = qids[k]; tx_qgrp->txqs[j]->q_type = VIRTCHNL2_QUEUE_TYPE_TX; } } break; case VIRTCHNL2_QUEUE_TYPE_RX: for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u16 num_rxq; if (idpf_is_queue_model_split(vport->rxq_model)) num_rxq = rx_qgrp->splitq.num_rxq_sets; else num_rxq = rx_qgrp->singleq.num_rxq; for (j = 0; j < num_rxq && k < num_qids; j++, k++) { if (idpf_is_queue_model_split(vport->rxq_model)) q = &rx_qgrp->splitq.rxq_sets[j]->rxq; else q = rx_qgrp->singleq.rxqs[j]; q->q_id = qids[k]; q->q_type = VIRTCHNL2_QUEUE_TYPE_RX; } } break; case VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION: for (i = 0; i < vport->num_txq_grp && k < num_qids; i++, k++) { struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i]; tx_qgrp->complq->q_id = qids[k]; tx_qgrp->complq->q_type = VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION; } break; case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER: for (i = 0; i < vport->num_rxq_grp; i++) { struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i]; u8 num_bufqs = vport->num_bufqs_per_qgrp; for (j = 0; j < num_bufqs && k < num_qids; j++, k++) { q = &rx_qgrp->splitq.bufq_sets[j].bufq; q->q_id = qids[k]; q->q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER; } } break; default: break; } return k; } /** * idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters * @vport: virtual port for which the queues ids are initialized * * Will initialize all queue ids with ids received as mailbox parameters. * Returns 0 on success, negative if all the queues are not initialized. */ int idpf_vport_queue_ids_init(struct idpf_vport *vport) { struct virtchnl2_create_vport *vport_params; struct virtchnl2_queue_reg_chunks *chunks; struct idpf_vport_config *vport_config; u16 vport_idx = vport->idx; int num_ids, err = 0; u16 q_type; u32 *qids; vport_config = vport->adapter->vport_config[vport_idx]; if (vport_config->req_qs_chunks) { struct virtchnl2_add_queues *vc_aq = (struct virtchnl2_add_queues *)vport_config->req_qs_chunks; chunks = &vc_aq->chunks; } else { vport_params = vport->adapter->vport_params_recvd[vport_idx]; chunks = &vport_params->chunks; } qids = kcalloc(IDPF_MAX_QIDS, sizeof(u32), GFP_KERNEL); if (!qids) return -ENOMEM; num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, VIRTCHNL2_QUEUE_TYPE_TX, chunks); if (num_ids < vport->num_txq) { err = -EINVAL; goto mem_rel; } num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, VIRTCHNL2_QUEUE_TYPE_TX); if (num_ids < vport->num_txq) { err = -EINVAL; goto mem_rel; } num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, VIRTCHNL2_QUEUE_TYPE_RX, chunks); if (num_ids < vport->num_rxq) { err = -EINVAL; goto mem_rel; } num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, VIRTCHNL2_QUEUE_TYPE_RX); if (num_ids < vport->num_rxq) { err = -EINVAL; goto mem_rel; } if (!idpf_is_queue_model_split(vport->txq_model)) goto check_rxq; q_type = VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION; num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks); if (num_ids < vport->num_complq) { err = -EINVAL; goto mem_rel; } num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type); if (num_ids < vport->num_complq) { err = -EINVAL; goto mem_rel; } check_rxq: if (!idpf_is_queue_model_split(vport->rxq_model)) goto mem_rel; q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER; num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks); if (num_ids < vport->num_bufq) { err = -EINVAL; goto mem_rel; } num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type); if (num_ids < vport->num_bufq) err = -EINVAL; mem_rel: kfree(qids); return err; } /** * idpf_vport_adjust_qs - Adjust to new requested queues * @vport: virtual port data struct * * Renegotiate queues. Returns 0 on success, negative on failure. */ int idpf_vport_adjust_qs(struct idpf_vport *vport) { struct virtchnl2_create_vport vport_msg; int err; vport_msg.txq_model = cpu_to_le16(vport->txq_model); vport_msg.rxq_model = cpu_to_le16(vport->rxq_model); err = idpf_vport_calc_total_qs(vport->adapter, vport->idx, &vport_msg, NULL); if (err) return err; idpf_vport_init_num_qs(vport, &vport_msg); idpf_vport_calc_num_q_groups(vport); return 0; } /** * idpf_is_capability_ena - Default implementation of capability checking * @adapter: Private data struct * @all: all or one flag * @field: caps field to check for flags * @flag: flag to check * * Return true if all capabilities are supported, false otherwise */ bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all, enum idpf_cap_field field, u64 flag) { u8 *caps = (u8 *)&adapter->caps; u32 *cap_field; if (!caps) return false; if (field == IDPF_BASE_CAPS) return false; cap_field = (u32 *)(caps + field); if (all) return (*cap_field & flag) == flag; else return !!(*cap_field & flag); } /** * idpf_get_vport_id: Get vport id * @vport: virtual port structure * * Return vport id from the adapter persistent data */ u32 idpf_get_vport_id(struct idpf_vport *vport) { struct virtchnl2_create_vport *vport_msg; vport_msg = vport->adapter->vport_params_recvd[vport->idx]; return le32_to_cpu(vport_msg->vport_id); } /** * idpf_add_del_mac_filters - Add/del mac filters * @vport: Virtual port data structure * @np: Netdev private structure * @add: Add or delete flag * @async: Don't wait for return message * * Returns 0 on success, error on failure. **/ int idpf_add_del_mac_filters(struct idpf_vport *vport, struct idpf_netdev_priv *np, bool add, bool async) { struct virtchnl2_mac_addr_list *ma_list = NULL; struct idpf_adapter *adapter = np->adapter; struct idpf_vport_config *vport_config; enum idpf_vport_config_flags mac_flag; struct pci_dev *pdev = adapter->pdev; enum idpf_vport_vc_state vc, vc_err; struct virtchnl2_mac_addr *mac_addr; struct idpf_mac_filter *f, *tmp; u32 num_msgs, total_filters = 0; int i = 0, k, err = 0; u32 vop; vport_config = adapter->vport_config[np->vport_idx]; spin_lock_bh(&vport_config->mac_filter_list_lock); /* Find the number of newly added filters */ list_for_each_entry(f, &vport_config->user_config.mac_filter_list, list) { if (add && f->add) total_filters++; else if (!add && f->remove) total_filters++; } if (!total_filters) { spin_unlock_bh(&vport_config->mac_filter_list_lock); return 0; } /* Fill all the new filters into virtchannel message */ mac_addr = kcalloc(total_filters, sizeof(struct virtchnl2_mac_addr), GFP_ATOMIC); if (!mac_addr) { err = -ENOMEM; spin_unlock_bh(&vport_config->mac_filter_list_lock); goto error; } list_for_each_entry_safe(f, tmp, &vport_config->user_config.mac_filter_list, list) { if (add && f->add) { ether_addr_copy(mac_addr[i].addr, f->macaddr); i++; f->add = false; if (i == total_filters) break; } if (!add && f->remove) { ether_addr_copy(mac_addr[i].addr, f->macaddr); i++; f->remove = false; if (i == total_filters) break; } } spin_unlock_bh(&vport_config->mac_filter_list_lock); if (add) { vop = VIRTCHNL2_OP_ADD_MAC_ADDR; vc = IDPF_VC_ADD_MAC_ADDR; vc_err = IDPF_VC_ADD_MAC_ADDR_ERR; mac_flag = IDPF_VPORT_ADD_MAC_REQ; } else { vop = VIRTCHNL2_OP_DEL_MAC_ADDR; vc = IDPF_VC_DEL_MAC_ADDR; vc_err = IDPF_VC_DEL_MAC_ADDR_ERR; mac_flag = IDPF_VPORT_DEL_MAC_REQ; } /* Chunk up the filters into multiple messages to avoid * sending a control queue message buffer that is too large */ num_msgs = DIV_ROUND_UP(total_filters, IDPF_NUM_FILTERS_PER_MSG); if (!async) mutex_lock(&vport->vc_buf_lock); for (i = 0, k = 0; i < num_msgs; i++) { u32 entries_size, buf_size, num_entries; num_entries = min_t(u32, total_filters, IDPF_NUM_FILTERS_PER_MSG); entries_size = sizeof(struct virtchnl2_mac_addr) * num_entries; buf_size = struct_size(ma_list, mac_addr_list, num_entries); if (!ma_list || num_entries != IDPF_NUM_FILTERS_PER_MSG) { kfree(ma_list); ma_list = kzalloc(buf_size, GFP_ATOMIC); if (!ma_list) { err = -ENOMEM; goto list_prep_error; } } else { memset(ma_list, 0, buf_size); } ma_list->vport_id = cpu_to_le32(np->vport_id); ma_list->num_mac_addr = cpu_to_le16(num_entries); memcpy(ma_list->mac_addr_list, &mac_addr[k], entries_size); if (async) set_bit(mac_flag, vport_config->flags); err = idpf_send_mb_msg(adapter, vop, buf_size, (u8 *)ma_list); if (err) goto mbx_error; if (!async) { err = idpf_wait_for_event(adapter, vport, vc, vc_err); if (err) goto mbx_error; } k += num_entries; total_filters -= num_entries; } mbx_error: if (!async) mutex_unlock(&vport->vc_buf_lock); kfree(ma_list); list_prep_error: kfree(mac_addr); error: if (err) dev_err(&pdev->dev, "Failed to add or del mac filters %d", err); return err; } /** * idpf_set_promiscuous - set promiscuous and send message to mailbox * @adapter: Driver specific private structure * @config_data: Vport specific config data * @vport_id: Vport identifier * * Request to enable promiscuous mode for the vport. Message is sent * asynchronously and won't wait for response. Returns 0 on success, negative * on failure; */ int idpf_set_promiscuous(struct idpf_adapter *adapter, struct idpf_vport_user_config_data *config_data, u32 vport_id) { struct virtchnl2_promisc_info vpi; u16 flags = 0; int err; if (test_bit(__IDPF_PROMISC_UC, config_data->user_flags)) flags |= VIRTCHNL2_UNICAST_PROMISC; if (test_bit(__IDPF_PROMISC_MC, config_data->user_flags)) flags |= VIRTCHNL2_MULTICAST_PROMISC; vpi.vport_id = cpu_to_le32(vport_id); vpi.flags = cpu_to_le16(flags); err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE, sizeof(struct virtchnl2_promisc_info), (u8 *)&vpi); 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