ice: Implement iidc operations (348048e7) · Commits · EulixOS / Software / Kernel

drivers/net/ethernet/intel/ice/ice.h

+5 −3

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@
		#include "ice_switch.h"
		#include "ice_common.h"
		#include "ice_sched.h"
		#include "ice_idc_int.h"
		#include "ice_virtchnl_pf.h"
		#include "ice_sriov.h"
		#include "ice_fdir.h"
		@@ -206,9 +207,9 @@ enum ice_pf_state {
		ICE_NEEDS_RESTART,
		ICE_PREPARED_FOR_RESET, /* set by driver when prepared */
		ICE_RESET_OICR_RECV, /* set by driver after rcv reset OICR */
		ICE_PFR_REQ, /* set by driver and peers */
		ICE_CORER_REQ, /* set by driver and peers */
		ICE_GLOBR_REQ, /* set by driver and peers */
		ICE_PFR_REQ, /* set by driver */
		ICE_CORER_REQ, /* set by driver */
		ICE_GLOBR_REQ, /* set by driver */
		ICE_CORER_RECV, /* set by OICR handler */
		ICE_GLOBR_RECV, /* set by OICR handler */
		ICE_EMPR_RECV, /* set by OICR handler */
		@@ -335,6 +336,7 @@ struct ice_vsi {
		u16 req_rxq; /* User requested Rx queues */
		u16 num_rx_desc;
		u16 num_tx_desc;
		u16 qset_handle[ICE_MAX_TRAFFIC_CLASS];
		struct ice_tc_cfg tc_cfg;
		struct bpf_prog *xdp_prog;
		struct ice_ring *xdp_rings; / XDP ring array */

drivers/net/ethernet/intel/ice/ice_adminq_cmd.h

+32 −0

Original line number	Diff line number	Diff line
		@@ -1685,6 +1685,36 @@ struct ice_aqc_dis_txq_item {
		__le16 q_id[];
		} __packed;

		/* Add Tx RDMA Queue Set (indirect 0x0C33) */
		struct ice_aqc_add_rdma_qset {
		u8 num_qset_grps;
		u8 reserved[7];
		__le32 addr_high;
		__le32 addr_low;
		};

		/* This is the descriptor of each Qset entry for the Add Tx RDMA Queue Set
		* command (0x0C33). Only used within struct ice_aqc_add_rdma_qset.
		*/
		struct ice_aqc_add_tx_rdma_qset_entry {
		__le16 tx_qset_id;
		u8 rsvd[2];
		__le32 qset_teid;
		struct ice_aqc_txsched_elem info;
		};

		/* The format of the command buffer for Add Tx RDMA Queue Set(0x0C33)
		* is an array of the following structs. Please note that the length of
		* each struct ice_aqc_add_rdma_qset is variable due to the variable
		* number of queues in each group!
		*/
		struct ice_aqc_add_rdma_qset_data {
		__le32 parent_teid;
		__le16 num_qsets;
		u8 rsvd[2];
		struct ice_aqc_add_tx_rdma_qset_entry rdma_qsets[];
		};

		/* Configure Firmware Logging Command (indirect 0xFF09)
		* Logging Information Read Response (indirect 0xFF10)
		* Note: The 0xFF10 command has no input parameters.
		@@ -1881,6 +1911,7 @@ struct ice_aq_desc {
		struct ice_aqc_get_set_rss_key get_set_rss_key;
		struct ice_aqc_add_txqs add_txqs;
		struct ice_aqc_dis_txqs dis_txqs;
		struct ice_aqc_add_rdma_qset add_rdma_qset;
		struct ice_aqc_add_get_update_free_vsi vsi_cmd;
		struct ice_aqc_add_update_free_vsi_resp add_update_free_vsi_res;
		struct ice_aqc_fw_logging fw_logging;
		@@ -2029,6 +2060,7 @@ enum ice_adminq_opc {
		/* Tx queue handling commands/events */
		ice_aqc_opc_add_txqs = 0x0C30,
		ice_aqc_opc_dis_txqs = 0x0C31,
		ice_aqc_opc_add_rdma_qset = 0x0C33,

		/* package commands */
		ice_aqc_opc_download_pkg = 0x0C40,

drivers/net/ethernet/intel/ice/ice_common.c

+203 −0

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		/* Copyright (c) 2018, Intel Corporation. */

		#include "ice_common.h"
		#include "ice_lib.h"
		#include "ice_sched.h"
		#include "ice_adminq_cmd.h"
		#include "ice_flow.h"
		@@ -3650,6 +3651,52 @@ ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps,
		return status;
		}

		/**
		* ice_aq_add_rdma_qsets
		* @hw: pointer to the hardware structure
		* @num_qset_grps: Number of RDMA Qset groups
		* @qset_list: list of Qset groups to be added
		* @buf_size: size of buffer for indirect command
		* @cd: pointer to command details structure or NULL
		*
		* Add Tx RDMA Qsets (0x0C33)
		*/
		static int
		ice_aq_add_rdma_qsets(struct ice_hw *hw, u8 num_qset_grps,
		struct ice_aqc_add_rdma_qset_data *qset_list,
		u16 buf_size, struct ice_sq_cd *cd)
		{
		struct ice_aqc_add_rdma_qset_data *list;
		struct ice_aqc_add_rdma_qset *cmd;
		struct ice_aq_desc desc;
		u16 i, sum_size = 0;

		cmd = &desc.params.add_rdma_qset;

		ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_rdma_qset);

		if (num_qset_grps > ICE_LAN_TXQ_MAX_QGRPS)
		return -EINVAL;

		for (i = 0, list = qset_list; i < num_qset_grps; i++) {
		u16 num_qsets = le16_to_cpu(list->num_qsets);

		sum_size += struct_size(list, rdma_qsets, num_qsets);
		list = (struct ice_aqc_add_rdma_qset_data *)(list->rdma_qsets +
		num_qsets);
		}

		if (buf_size != sum_size)
		return -EINVAL;

		desc.flags \|= cpu_to_le16(ICE_AQ_FLAG_RD);

		cmd->num_qset_grps = num_qset_grps;

		return ice_status_to_errno(ice_aq_send_cmd(hw, &desc, qset_list,
		buf_size, cd));
		}

		/* End of FW Admin Queue command wrappers */

		/**
		@@ -4147,6 +4194,162 @@ ice_cfg_vsi_lan(struct ice_port_info *pi, u16 vsi_handle, u8 tc_bitmap,
		ICE_SCHED_NODE_OWNER_LAN);
		}

		/**
		* ice_cfg_vsi_rdma - configure the VSI RDMA queues
		* @pi: port information structure
		* @vsi_handle: software VSI handle
		* @tc_bitmap: TC bitmap
		* @max_rdmaqs: max RDMA queues array per TC
		*
		* This function adds/updates the VSI RDMA queues per TC.
		*/
		int
		ice_cfg_vsi_rdma(struct ice_port_info *pi, u16 vsi_handle, u16 tc_bitmap,
		u16 *max_rdmaqs)
		{
		return ice_status_to_errno(ice_cfg_vsi_qs(pi, vsi_handle, tc_bitmap,
		max_rdmaqs,
		ICE_SCHED_NODE_OWNER_RDMA));
		}

		/**
		* ice_ena_vsi_rdma_qset
		* @pi: port information structure
		* @vsi_handle: software VSI handle
		* @tc: TC number
		* @rdma_qset: pointer to RDMA Qset
		* @num_qsets: number of RDMA Qsets
		* @qset_teid: pointer to Qset node TEIDs
		*
		* This function adds RDMA Qset
		*/
		int
		ice_ena_vsi_rdma_qset(struct ice_port_info *pi, u16 vsi_handle, u8 tc,
		u16 rdma_qset, u16 num_qsets, u32 qset_teid)
		{
		struct ice_aqc_txsched_elem_data node = { 0 };
		struct ice_aqc_add_rdma_qset_data *buf;
		struct ice_sched_node *parent;
		enum ice_status status;
		struct ice_hw *hw;
		u16 i, buf_size;
		int ret;

		if (!pi \|\| pi->port_state != ICE_SCHED_PORT_STATE_READY)
		return -EIO;
		hw = pi->hw;

		if (!ice_is_vsi_valid(hw, vsi_handle))
		return -EINVAL;

		buf_size = struct_size(buf, rdma_qsets, num_qsets);
		buf = kzalloc(buf_size, GFP_KERNEL);
		if (!buf)
		return -ENOMEM;
		mutex_lock(&pi->sched_lock);

		parent = ice_sched_get_free_qparent(pi, vsi_handle, tc,
		ICE_SCHED_NODE_OWNER_RDMA);
		if (!parent) {
		ret = -EINVAL;
		goto rdma_error_exit;
		}
		buf->parent_teid = parent->info.node_teid;
		node.parent_teid = parent->info.node_teid;

		buf->num_qsets = cpu_to_le16(num_qsets);
		for (i = 0; i < num_qsets; i++) {
		buf->rdma_qsets[i].tx_qset_id = cpu_to_le16(rdma_qset[i]);
		buf->rdma_qsets[i].info.valid_sections =
		ICE_AQC_ELEM_VALID_GENERIC \| ICE_AQC_ELEM_VALID_CIR \|
		ICE_AQC_ELEM_VALID_EIR;
		buf->rdma_qsets[i].info.generic = 0;
		buf->rdma_qsets[i].info.cir_bw.bw_profile_idx =
		cpu_to_le16(ICE_SCHED_DFLT_RL_PROF_ID);
		buf->rdma_qsets[i].info.cir_bw.bw_alloc =
		cpu_to_le16(ICE_SCHED_DFLT_BW_WT);
		buf->rdma_qsets[i].info.eir_bw.bw_profile_idx =
		cpu_to_le16(ICE_SCHED_DFLT_RL_PROF_ID);
		buf->rdma_qsets[i].info.eir_bw.bw_alloc =
		cpu_to_le16(ICE_SCHED_DFLT_BW_WT);
		}
		ret = ice_aq_add_rdma_qsets(hw, 1, buf, buf_size, NULL);
		if (ret) {
		ice_debug(hw, ICE_DBG_RDMA, "add RDMA qset failed\n");
		goto rdma_error_exit;
		}
		node.data.elem_type = ICE_AQC_ELEM_TYPE_LEAF;
		for (i = 0; i < num_qsets; i++) {
		node.node_teid = buf->rdma_qsets[i].qset_teid;
		status = ice_sched_add_node(pi, hw->num_tx_sched_layers - 1,
		&node);
		if (status) {
		ret = ice_status_to_errno(status);
		break;
		}
		qset_teid[i] = le32_to_cpu(node.node_teid);
		}
		rdma_error_exit:
		mutex_unlock(&pi->sched_lock);
		kfree(buf);
		return ret;
		}

		/**
		* ice_dis_vsi_rdma_qset - free RDMA resources
		* @pi: port_info struct
		* @count: number of RDMA Qsets to free
		* @qset_teid: TEID of Qset node
		* @q_id: list of queue IDs being disabled
		*/
		int
		ice_dis_vsi_rdma_qset(struct ice_port_info pi, u16 count, u32 qset_teid,
		u16 *q_id)
		{
		struct ice_aqc_dis_txq_item *qg_list;
		enum ice_status status = 0;
		struct ice_hw *hw;
		u16 qg_size;
		int i;

		if (!pi \|\| pi->port_state != ICE_SCHED_PORT_STATE_READY)
		return -EIO;

		hw = pi->hw;

		qg_size = struct_size(qg_list, q_id, 1);
		qg_list = kzalloc(qg_size, GFP_KERNEL);
		if (!qg_list)
		return -ENOMEM;

		mutex_lock(&pi->sched_lock);

		for (i = 0; i < count; i++) {
		struct ice_sched_node *node;

		node = ice_sched_find_node_by_teid(pi->root, qset_teid[i]);
		if (!node)
		continue;

		qg_list->parent_teid = node->info.parent_teid;
		qg_list->num_qs = 1;
		qg_list->q_id[0] =
		cpu_to_le16(q_id[i] \|
		ICE_AQC_Q_DIS_BUF_ELEM_TYPE_RDMA_QSET);

		status = ice_aq_dis_lan_txq(hw, 1, qg_list, qg_size,
		ICE_NO_RESET, 0, NULL);
		if (status)
		break;

		ice_free_sched_node(pi, node);
		}

		mutex_unlock(&pi->sched_lock);
		kfree(qg_list);
		return ice_status_to_errno(status);
		}

		/**
		* ice_replay_pre_init - replay pre initialization
		* @hw: pointer to the HW struct

drivers/net/ethernet/intel/ice/ice_common.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -147,6 +147,15 @@ ice_aq_sff_eeprom(struct ice_hw *hw, u16 lport, u8 bus_addr,
		u16 mem_addr, u8 page, u8 set_page, u8 *data, u8 length,
		bool write, struct ice_sq_cd *cd);

		int
		ice_cfg_vsi_rdma(struct ice_port_info *pi, u16 vsi_handle, u16 tc_bitmap,
		u16 *max_rdmaqs);
		int
		ice_ena_vsi_rdma_qset(struct ice_port_info *pi, u16 vsi_handle, u8 tc,
		u16 rdma_qset, u16 num_qsets, u32 qset_teid);
		int
		ice_dis_vsi_rdma_qset(struct ice_port_info pi, u16 count, u32 qset_teid,
		u16 *q_id);
		enum ice_status
		ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues,
		u16 q_handle, u16 q_ids, u32 *q_teids,

drivers/net/ethernet/intel/ice/ice_dcb_lib.c

+19 −0

Original line number	Diff line number	Diff line
		@@ -275,6 +275,7 @@ int ice_pf_dcb_cfg(struct ice_pf pf, struct ice_dcbx_cfg new_cfg, bool locked)
		struct ice_dcbx_cfg old_cfg, curr_cfg;
		struct device *dev = ice_pf_to_dev(pf);
		int ret = ICE_DCB_NO_HW_CHG;
		struct iidc_event *event;
		struct ice_vsi *pf_vsi;

		curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
		@@ -313,6 +314,15 @@ int ice_pf_dcb_cfg(struct ice_pf pf, struct ice_dcbx_cfg new_cfg, bool locked)
		goto free_cfg;
		}

		/* Notify AUX drivers about impending change to TCs */
		event = kzalloc(sizeof(*event), GFP_KERNEL);
		if (!event)
		return -ENOMEM;

		set_bit(IIDC_EVENT_BEFORE_TC_CHANGE, event->type);
		ice_send_event_to_aux(pf, event);
		kfree(event);

		/* avoid race conditions by holding the lock while disabling and
		* re-enabling the VSI
		*/
		@@ -640,6 +650,7 @@ static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
		void ice_pf_dcb_recfg(struct ice_pf *pf)
		{
		struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
		struct iidc_event *event;
		u8 tc_map = 0;
		int v, ret;

		@@ -675,6 +686,14 @@ void ice_pf_dcb_recfg(struct ice_pf *pf)
		if (vsi->type == ICE_VSI_PF)
		ice_dcbnl_set_all(vsi);
		}
		/* Notify the AUX drivers that TC change is finished */
		event = kzalloc(sizeof(*event), GFP_KERNEL);
		if (!event)
		return;

		set_bit(IIDC_EVENT_AFTER_TC_CHANGE, event->type);
		ice_send_event_to_aux(pf, event);
		kfree(event);
		}

		/**