From: Brett Creeley Add three new functions: - ice_vf_vsi_dis_single_rxq() - ice_vf_vsi_ena_single_rxq() - ice_vf_vsi_ena_single_txq() (ice_vf_vsi_dis_single_txq() was introduced earlier). Those functions wrap operations needed in the processes of enabling and disabling single Tx/Rx VF queue, which are: - check if the queue is not already in desired state - perform the dis/ena operations - bookkeeping of the queue's state. Future commit will use them from another callsite. Signed-off-by: Brett Creeley Signed-off-by: Wojciech Drewek Reviewed-by: Jedrzej Jagielski Reviewed-by: Aleksandr Loktionov Signed-off-by: Przemek Kitszel --- v2: * convert one comment to kdoc (Alex) * fix typos (Sashiko) * rebase: move ice_vf_dis_rxq_interrupt(), added to ice_vc_dis_qs_msg() by commit fb096882095e ("ice: fix VF interrupts cleanup"), into ice_vf_vsi_dis_single_rxq() --- drivers/net/ethernet/intel/ice/virt/queues.c | 117 ++++++++++++++----- 1 file changed, 89 insertions(+), 28 deletions(-) diff --git a/drivers/net/ethernet/intel/ice/virt/queues.c b/drivers/net/ethernet/intel/ice/virt/queues.c index ac7f98479b13..a22780575086 100644 --- a/drivers/net/ethernet/intel/ice/virt/queues.c +++ b/drivers/net/ethernet/intel/ice/virt/queues.c @@ -242,6 +242,57 @@ static void ice_vf_dis_rxq_interrupt(struct ice_vsi *vsi, u32 q_idx) ice_flush(hw); } +/** + * ice_vf_vsi_ena_single_rxq - enable single Rx queue based on relative q_id + * @vf: VF to enable queue for + * @vsi: VSI for the VF + * @q_id: VSI relative (0-based) queue ID + * + * Enable the Rx queue passed in. + * + * Return: 0 on success or negative on error. + */ +static int ice_vf_vsi_ena_single_rxq(struct ice_vf *vf, struct ice_vsi *vsi, + u16 q_id) +{ + int err; + + if (test_bit(q_id, vf->rxq_ena)) + return 0; + + err = ice_vsi_ctrl_one_rx_ring(vsi, true, q_id, true); + if (err) { + dev_err(ice_pf_to_dev(vsi->back), "Failed to enable Rx ring %d on VSI %d\n", + q_id, vsi->vsi_num); + return err; + } + + ice_vf_ena_rxq_interrupt(vsi, q_id); + set_bit(q_id, vf->rxq_ena); + + return 0; +} + +/** + * ice_vf_vsi_ena_single_txq - enable single Tx queue based on relative q_id + * @vf: VF to enable queue for + * @vsi: VSI for the VF + * @q_id: VSI relative (0-based) queue ID + * + * Enable the Tx queue's interrupt. Note that the Tx queue(s) should have + * already been configured/enabled in VIRTCHNL_OP_CONFIG_VSI_QUEUES so this + * function only enables the interrupt associated with the q_id. + */ +static void ice_vf_vsi_ena_single_txq(struct ice_vf *vf, struct ice_vsi *vsi, + u16 q_id) +{ + if (test_bit(q_id, vf->txq_ena)) + return; + + ice_vf_ena_txq_interrupt(vsi, q_id); + set_bit(q_id, vf->txq_ena); +} + /** * ice_vc_ena_qs_msg * @vf: pointer to the VF info @@ -290,34 +341,20 @@ int ice_vc_ena_qs_msg(struct ice_vf *vf, u8 *msg) goto error_param; } - /* Skip queue if enabled */ - if (test_bit(vf_q_id, vf->rxq_ena)) - continue; - - if (ice_vsi_ctrl_one_rx_ring(vsi, true, vf_q_id, true)) { - dev_err(ice_pf_to_dev(vsi->back), "Failed to enable Rx ring %d on VSI %d\n", - vf_q_id, vsi->vsi_num); + if (ice_vf_vsi_ena_single_rxq(vf, vsi, vf_q_id)) { v_ret = VIRTCHNL_STATUS_ERR_PARAM; goto error_param; } - - ice_vf_ena_rxq_interrupt(vsi, vf_q_id); - set_bit(vf_q_id, vf->rxq_ena); } q_map = vqs->tx_queues; for_each_set_bit(vf_q_id, &q_map, ICE_MAX_RSS_QS_PER_VF) { if (!ice_vc_isvalid_q_id(vsi, vf_q_id)) { v_ret = VIRTCHNL_STATUS_ERR_PARAM; goto error_param; } - /* Skip queue if enabled */ - if (test_bit(vf_q_id, vf->txq_ena)) - continue; - - ice_vf_ena_txq_interrupt(vsi, vf_q_id); - set_bit(vf_q_id, vf->txq_ena); + ice_vf_vsi_ena_single_txq(vf, vsi, vf_q_id); } /* Set flag to indicate that queues are enabled */ @@ -369,6 +406,41 @@ int ice_vf_vsi_dis_single_txq(struct ice_vf *vf, struct ice_vsi *vsi, u16 q_id) return 0; } +/** + * ice_vf_vsi_dis_single_rxq - disable a Rx queue for VF on relative queue ID + * @vf: VF to disable queue for + * @vsi: VSI for the VF + * @q_id: VSI relative (0-based) queue ID + * + * Attempt to disable the Rx queue passed in. If the Rx queue was successfully + * disabled then clear q_id bit in the enabled queues bitmap. + * + * Return: 0 when queue was already disabled or disabling succeeded, otherwise + * negative error code. + */ +static int ice_vf_vsi_dis_single_rxq(struct ice_vf *vf, struct ice_vsi *vsi, + u16 q_id) +{ + int err; + + if (!test_bit(q_id, vf->rxq_ena)) + return 0; + + err = ice_vsi_ctrl_one_rx_ring(vsi, false, q_id, true); + if (err) { + dev_err(ice_pf_to_dev(vsi->back), "Failed to stop Rx ring %d on VSI %d\n", + q_id, vsi->vsi_num); + return err; + } + + ice_vf_dis_rxq_interrupt(vsi, q_id); + + /* Clear enabled queues flag */ + clear_bit(q_id, vf->rxq_ena); + + return 0; +} + /** * ice_vc_dis_qs_msg * @vf: pointer to the VF info @@ -433,21 +505,10 @@ int ice_vc_dis_qs_msg(struct ice_vf *vf, u8 *msg) goto error_param; } - /* Skip queue if not enabled */ - if (!test_bit(vf_q_id, vf->rxq_ena)) - continue; - - if (ice_vsi_ctrl_one_rx_ring(vsi, false, vf_q_id, - true)) { - dev_err(ice_pf_to_dev(vsi->back), "Failed to stop Rx ring %d on VSI %d\n", - vf_q_id, vsi->vsi_num); + if (ice_vf_vsi_dis_single_rxq(vf, vsi, vf_q_id)) { v_ret = VIRTCHNL_STATUS_ERR_PARAM; goto error_param; } - - ice_vf_dis_rxq_interrupt(vsi, vf_q_id); - /* Clear enabled queues flag */ - clear_bit(vf_q_id, vf->rxq_ena); } } -- 2.51.1