Commit 11a20c71 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue 



Tony Nguyen says:

====================
100GbE Intel Wired LAN Driver Updates 2020-07-01

This series contains updates to the ice driver only.

Jacob implements a devlink region for device capabilities.

Bruce removes structs containing only one-element arrays that are either
unused or only used for indexing. Instead, use pointer arithmetic or
other indexing to access the elements. Converts "C struct hack"
variable-length types to the preferred C99 flexible array member.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents a3b658cf 66486d89

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

+1 −0
Original line number Diff line number Diff line
@@ -373,6 +373,7 @@ struct ice_pf { 
	struct devlink_port devlink_port;



	struct devlink_region *nvm_region;

	struct devlink_region *devcaps_region;



	/* OS reserved IRQ details */

	struct msix_entry *msix_entries;

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

+12 −50
Original line number Diff line number Diff line
@@ -215,13 +215,6 @@ struct ice_aqc_get_sw_cfg_resp_elem { 
#define ICE_AQC_GET_SW_CONF_RESP_IS_VF		BIT(15)

};



/* The response buffer is as follows. Note that the length of the

 * elements array varies with the length of the command response.

 */

struct ice_aqc_get_sw_cfg_resp {

	struct ice_aqc_get_sw_cfg_resp_elem elements[1];

};



/* These resource type defines are used for all switch resource

 * commands where a resource type is required, such as:

 * Get Resource Allocation command (indirect 0x0204)
@@ -274,7 +267,7 @@ struct ice_aqc_alloc_free_res_elem { 
#define ICE_AQC_RES_TYPE_VSI_PRUNE_LIST_M	\

				(0xF << ICE_AQC_RES_TYPE_VSI_PRUNE_LIST_S)

	__le16 num_elems;

	struct ice_aqc_res_elem elem[1];

	struct ice_aqc_res_elem elem[];

};



/* Add VSI (indirect 0x0210)
@@ -568,8 +561,8 @@ struct ice_sw_rule_lkup_rx_tx { 
	 * lookup-type

	 */

	__le16 hdr_len;

	u8 hdr[1];

} __packed;

	u8 hdr[];

};



/* Add/Update/Remove large action command/response entry

 * "index" is returned as part of a response to a successful Add command, and
@@ -578,7 +571,6 @@ struct ice_sw_rule_lkup_rx_tx { 
struct ice_sw_rule_lg_act {

	__le16 index; /* Index in large action table */

	__le16 size;

	__le32 act[1]; /* array of size for actions */

	/* Max number of large actions */

#define ICE_MAX_LG_ACT	4

	/* Bit 0:1 - Action type */
@@ -629,6 +621,7 @@ struct ice_sw_rule_lg_act { 
#define ICE_LG_ACT_STAT_COUNT		0x7

#define ICE_LG_ACT_STAT_COUNT_S		3

#define ICE_LG_ACT_STAT_COUNT_M		(0x7F << ICE_LG_ACT_STAT_COUNT_S)

	__le32 act[]; /* array of size for actions */

};



/* Add/Update/Remove VSI list command/response entry
@@ -638,7 +631,7 @@ struct ice_sw_rule_lg_act { 
struct ice_sw_rule_vsi_list {

	__le16 index; /* Index of VSI/Prune list */

	__le16 number_vsi;

	__le16 vsi[1]; /* Array of number_vsi VSI numbers */

	__le16 vsi[]; /* Array of number_vsi VSI numbers */

};



/* Query VSI list command/response entry */
@@ -695,14 +688,6 @@ struct ice_aqc_sched_elem_cmd { 
	__le32 addr_low;

};



/* This is the buffer for:

 * Suspend Nodes (indirect 0x0409)

 * Resume Nodes (indirect 0x040A)

 */

struct ice_aqc_suspend_resume_elem {

	__le32 teid[1];

};



struct ice_aqc_elem_info_bw {

	__le16 bw_profile_idx;

	__le16 bw_alloc;
@@ -753,15 +738,7 @@ struct ice_aqc_txsched_topo_grp_info_hdr { 


struct ice_aqc_add_elem {

	struct ice_aqc_txsched_topo_grp_info_hdr hdr;

	struct ice_aqc_txsched_elem_data generic[1];

};



struct ice_aqc_conf_elem {

	struct ice_aqc_txsched_elem_data generic[1];

};



struct ice_aqc_get_elem {

	struct ice_aqc_txsched_elem_data generic[1];

	struct ice_aqc_txsched_elem_data generic[];

};



struct ice_aqc_get_topo_elem {
@@ -772,7 +749,7 @@ struct ice_aqc_get_topo_elem { 


struct ice_aqc_delete_elem {

	struct ice_aqc_txsched_topo_grp_info_hdr hdr;

	__le32 teid[1];

	__le32 teid[];

};



/* Query Port ETS (indirect 0x040E)
@@ -835,10 +812,6 @@ struct ice_aqc_rl_profile_elem { 
	__le16 rl_encode;

};



struct ice_aqc_rl_profile_generic_elem {

	struct ice_aqc_rl_profile_elem generic[1];

};



/* Query Scheduler Resource Allocation (indirect 0x0412)

 * This indirect command retrieves the scheduler resources allocated by

 * EMP Firmware to the given PF.
@@ -1537,7 +1510,7 @@ struct ice_aqc_add_tx_qgrp { 
	__le32 parent_teid;

	u8 num_txqs;

	u8 rsvd[3];

	struct ice_aqc_add_txqs_perq txqs[1];

	struct ice_aqc_add_txqs_perq txqs[];

};



/* Disable Tx LAN Queues (indirect 0x0C31) */
@@ -1575,18 +1548,13 @@ struct ice_aqc_dis_txq_item { 
	u8 num_qs;

	u8 rsvd;

	/* The length of the q_id array varies according to num_qs */

	__le16 q_id[1];

	/* This only applies from F8 onward */

#define ICE_AQC_Q_DIS_BUF_ELEM_TYPE_S		15

#define ICE_AQC_Q_DIS_BUF_ELEM_TYPE_LAN_Q	\

			(0 << ICE_AQC_Q_DIS_BUF_ELEM_TYPE_S)

#define ICE_AQC_Q_DIS_BUF_ELEM_TYPE_RDMA_QSET	\

			(1 << ICE_AQC_Q_DIS_BUF_ELEM_TYPE_S)

};



struct ice_aqc_dis_txq {

	struct ice_aqc_dis_txq_item qgrps[1];

};

	__le16 q_id[];

} __packed;



/* Configure Firmware Logging Command (indirect 0xFF09)

 * Logging Information Read Response (indirect 0xFF10)
@@ -1636,12 +1604,7 @@ enum ice_aqc_fw_logging_mod { 
	ICE_AQC_FW_LOG_ID_MAX,

};



/* This is the buffer for both of the logging commands.

 * The entry array size depends on the datalen parameter in the descriptor.

 * There will be a total of datalen / 2 entries.

 */

struct ice_aqc_fw_logging_data {

	__le16 entry[1];

/* Defines for both above FW logging command/response buffers */

#define ICE_AQC_FW_LOG_ID_S		0

#define ICE_AQC_FW_LOG_ID_M		(0xFFF << ICE_AQC_FW_LOG_ID_S)
@@ -1654,7 +1617,6 @@ struct ice_aqc_fw_logging_data { 
#define ICE_AQC_FW_LOG_INIT_EN		BIT(13)	/* Used by command */

#define ICE_AQC_FW_LOG_FLOW_EN		BIT(14)	/* Used by command */

#define ICE_AQC_FW_LOG_ERR_EN		BIT(15)	/* Used by command */

};



/* Get/Clear FW Log (indirect 0xFF11) */

struct ice_aqc_get_clear_fw_log {
@@ -1716,7 +1678,7 @@ struct ice_aqc_get_pkg_info { 
/* Get Package Info List response buffer format (0x0C43) */

struct ice_aqc_get_pkg_info_resp {

	__le32 count;

	struct ice_aqc_get_pkg_info pkg_info[1];

	struct ice_aqc_get_pkg_info pkg_info[];

};



/* Lan Queue Overflow Event (direct, 0x1001) */

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

+1 −1
Original line number Diff line number Diff line
@@ -635,10 +635,10 @@ int 
ice_vsi_cfg_txq(struct ice_vsi *vsi, struct ice_ring *ring,

		struct ice_aqc_add_tx_qgrp *qg_buf)

{

	u8 buf_len = struct_size(qg_buf, txqs, 1);

	struct ice_tlan_ctx tlan_ctx = { 0 };

	struct ice_aqc_add_txqs_perq *txq;

	struct ice_pf *pf = vsi->back;

	u8 buf_len = sizeof(*qg_buf);

	struct ice_hw *hw = &pf->hw;

	enum ice_status status;

	u16 pf_q;

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

+102 −65
Original line number Diff line number Diff line
@@ -440,30 +440,24 @@ static void ice_cleanup_fltr_mgmt_struct(struct ice_hw *hw) 
	devm_kfree(ice_hw_to_dev(hw), sw);

}



#define ICE_FW_LOG_DESC_SIZE(n)	(sizeof(struct ice_aqc_fw_logging_data) + \

	(((n) - 1) * sizeof(((struct ice_aqc_fw_logging_data *)0)->entry)))

#define ICE_FW_LOG_DESC_SIZE_MAX	\

	ICE_FW_LOG_DESC_SIZE(ICE_AQC_FW_LOG_ID_MAX)



/**

 * ice_get_fw_log_cfg - get FW logging configuration

 * @hw: pointer to the HW struct

 */

static enum ice_status ice_get_fw_log_cfg(struct ice_hw *hw)

{

	struct ice_aqc_fw_logging_data *config;

	struct ice_aq_desc desc;

	enum ice_status status;

	__le16 *config;

	u16 size;



	size = ICE_FW_LOG_DESC_SIZE_MAX;

	size = sizeof(*config) * ICE_AQC_FW_LOG_ID_MAX;

	config = devm_kzalloc(ice_hw_to_dev(hw), size, GFP_KERNEL);

	if (!config)

		return ICE_ERR_NO_MEMORY;



	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_fw_logging_info);



	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_BUF);

	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);



	status = ice_aq_send_cmd(hw, &desc, config, size, NULL);
@@ -474,7 +468,7 @@ static enum ice_status ice_get_fw_log_cfg(struct ice_hw *hw) 
		for (i = 0; i < ICE_AQC_FW_LOG_ID_MAX; i++) {

			u16 v, m, flgs;



			v = le16_to_cpu(config->entry[i]);

			v = le16_to_cpu(config[i]);

			m = (v & ICE_AQC_FW_LOG_ID_M) >> ICE_AQC_FW_LOG_ID_S;

			flgs = (v & ICE_AQC_FW_LOG_EN_M) >> ICE_AQC_FW_LOG_EN_S;
@@ -526,11 +520,11 @@ static enum ice_status ice_get_fw_log_cfg(struct ice_hw *hw) 
 */

static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable)

{

	struct ice_aqc_fw_logging_data *data = NULL;

	struct ice_aqc_fw_logging *cmd;

	enum ice_status status = 0;

	u16 i, chgs = 0, len = 0;

	struct ice_aq_desc desc;

	__le16 *data = NULL;

	u8 actv_evnts = 0;

	void *buf = NULL;
@@ -571,8 +565,9 @@ static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable) 
				continue;



			if (!data) {

				data = devm_kzalloc(ice_hw_to_dev(hw),

						    ICE_FW_LOG_DESC_SIZE_MAX,

				data = devm_kcalloc(ice_hw_to_dev(hw),

						    sizeof(*data),

						    ICE_AQC_FW_LOG_ID_MAX,

						    GFP_KERNEL);

				if (!data)

					return ICE_ERR_NO_MEMORY;
@@ -580,7 +575,7 @@ static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable) 


			val = i << ICE_AQC_FW_LOG_ID_S;

			val |= hw->fw_log.evnts[i].cfg << ICE_AQC_FW_LOG_EN_S;

			data->entry[chgs++] = cpu_to_le16(val);

			data[chgs++] = cpu_to_le16(val);

		}



		/* Only enable FW logging if at least one module is specified.
@@ -599,7 +594,7 @@ static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable) 
				cmd->log_ctrl |= ICE_AQC_FW_LOG_UART_EN;



			buf = data;

			len = ICE_FW_LOG_DESC_SIZE(chgs);

			len = sizeof(*data) * chgs;

			desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);

		}

	}
@@ -629,7 +624,7 @@ static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable) 
				continue;

			}



			v = le16_to_cpu(data->entry[i]);

			v = le16_to_cpu(data[i]);

			m = (v & ICE_AQC_FW_LOG_ID_M) >> ICE_AQC_FW_LOG_ID_S;

			hw->fw_log.evnts[m].cur = hw->fw_log.evnts[m].cfg;

		}
@@ -1541,7 +1536,7 @@ ice_alloc_hw_res(struct ice_hw *hw, u16 type, u16 num, bool btm, u16 *res) 
	enum ice_status status;

	u16 buf_len;



	buf_len = struct_size(buf, elem, num - 1);

	buf_len = struct_size(buf, elem, num);

	buf = kzalloc(buf_len, GFP_KERNEL);

	if (!buf)

		return ICE_ERR_NO_MEMORY;
@@ -1558,7 +1553,7 @@ ice_alloc_hw_res(struct ice_hw *hw, u16 type, u16 num, bool btm, u16 *res) 
	if (status)

		goto ice_alloc_res_exit;



	memcpy(res, buf->elem, sizeof(buf->elem) * num);

	memcpy(res, buf->elem, sizeof(*buf->elem) * num);



ice_alloc_res_exit:

	kfree(buf);
@@ -1579,7 +1574,7 @@ ice_free_hw_res(struct ice_hw *hw, u16 type, u16 num, u16 *res) 
	enum ice_status status;

	u16 buf_len;



	buf_len = struct_size(buf, elem, num - 1);

	buf_len = struct_size(buf, elem, num);

	buf = kzalloc(buf_len, GFP_KERNEL);

	if (!buf)

		return ICE_ERR_NO_MEMORY;
@@ -1587,7 +1582,7 @@ ice_free_hw_res(struct ice_hw *hw, u16 type, u16 num, u16 *res) 
	/* Prepare buffer to free resource. */

	buf->num_elems = cpu_to_le16(num);

	buf->res_type = cpu_to_le16(type);

	memcpy(buf->elem, res, sizeof(buf->elem) * num);

	memcpy(buf->elem, res, sizeof(*buf->elem) * num);



	status = ice_aq_alloc_free_res(hw, num, buf, buf_len,

				       ice_aqc_opc_free_res, NULL);
@@ -1823,19 +1818,26 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
}



/**

 * ice_aq_discover_caps - query function/device capabilities

 * ice_aq_list_caps - query function/device capabilities

 * @hw: pointer to the HW struct

 * @buf: a virtual buffer to hold the capabilities

 * @buf_size: Size of the virtual buffer

 * @cap_count: cap count needed if AQ err==ENOMEM

 * @opc: capabilities type to discover - pass in the command opcode

 * @buf: a buffer to hold the capabilities

 * @buf_size: size of the buffer

 * @cap_count: if not NULL, set to the number of capabilities reported

 * @opc: capabilities type to discover, device or function

 * @cd: pointer to command details structure or NULL

 *

 * Get the function(0x000a)/device(0x000b) capabilities description from

 * the firmware.

 * Get the function (0x000A) or device (0x000B) capabilities description from

 * firmware and store it in the buffer.

 *

 * If the cap_count pointer is not NULL, then it is set to the number of

 * capabilities firmware will report. Note that if the buffer size is too

 * small, it is possible the command will return ICE_AQ_ERR_ENOMEM. The

 * cap_count will still be updated in this case. It is recommended that the

 * buffer size be set to ICE_AQ_MAX_BUF_LEN (the largest possible buffer that

 * firmware could return) to avoid this.

 */

static enum ice_status

ice_aq_discover_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count,

enum ice_status

ice_aq_list_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count,

		 enum ice_adminq_opc opc, struct ice_sq_cd *cd)

{

	struct ice_aqc_list_caps *cmd;
@@ -1849,12 +1851,43 @@ ice_aq_discover_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count, 
		return ICE_ERR_PARAM;



	ice_fill_dflt_direct_cmd_desc(&desc, opc);



	status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);



	if (cap_count)

		*cap_count = le32_to_cpu(cmd->count);



	return status;

}



/**

 * ice_aq_discover_caps - query function/device capabilities

 * @hw: pointer to the HW struct

 * @buf: a virtual buffer to hold the capabilities

 * @buf_size: Size of the virtual buffer

 * @cap_count: cap count needed if AQ err==ENOMEM

 * @opc: capabilities type to discover - pass in the command opcode

 * @cd: pointer to command details structure or NULL

 *

 * Get the function(0x000a)/device(0x000b) capabilities description from

 * the firmware.

 *

 * NOTE: this function has the side effect of updating the hw->dev_caps or

 * hw->func_caps by way of calling ice_parse_caps.

 */

static enum ice_status

ice_aq_discover_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count,

		     enum ice_adminq_opc opc, struct ice_sq_cd *cd)

{

	u32 local_cap_count = 0;

	enum ice_status status;



	status = ice_aq_list_caps(hw, buf, buf_size, &local_cap_count,

				  opc, cd);

	if (!status)

		ice_parse_caps(hw, buf, le32_to_cpu(cmd->count), opc);

		ice_parse_caps(hw, buf, local_cap_count, opc);

	else if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOMEM)

		*cap_count = le32_to_cpu(cmd->count);

		*cap_count = local_cap_count;



	return status;

}
@@ -2889,10 +2922,10 @@ ice_aq_add_lan_txq(struct ice_hw *hw, u8 num_qgrps, 
		   struct ice_aqc_add_tx_qgrp *qg_list, u16 buf_size,

		   struct ice_sq_cd *cd)

{

	u16 i, sum_header_size, sum_q_size = 0;

	struct ice_aqc_add_tx_qgrp *list;

	struct ice_aqc_add_txqs *cmd;

	struct ice_aq_desc desc;

	u16 i, sum_size = 0;



	cmd = &desc.params.add_txqs;
@@ -2904,18 +2937,13 @@ ice_aq_add_lan_txq(struct ice_hw *hw, u8 num_qgrps, 
	if (num_qgrps > ICE_LAN_TXQ_MAX_QGRPS)

		return ICE_ERR_PARAM;



	sum_header_size = num_qgrps *

		(sizeof(*qg_list) - sizeof(*qg_list->txqs));



	list = qg_list;

	for (i = 0; i < num_qgrps; i++) {

		struct ice_aqc_add_txqs_perq *q = list->txqs;



		sum_q_size += list->num_txqs * sizeof(*q);

		list = (struct ice_aqc_add_tx_qgrp *)(q + list->num_txqs);

	for (i = 0, list = qg_list; i < num_qgrps; i++) {

		sum_size += struct_size(list, txqs, list->num_txqs);

		list = (struct ice_aqc_add_tx_qgrp *)(list->txqs +

						      list->num_txqs);

	}



	if (buf_size != (sum_header_size + sum_q_size))

	if (buf_size != sum_size)

		return ICE_ERR_PARAM;



	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
@@ -2943,6 +2971,7 @@ ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps, 
		   enum ice_disq_rst_src rst_src, u16 vmvf_num,

		   struct ice_sq_cd *cd)

{

	struct ice_aqc_dis_txq_item *item;

	struct ice_aqc_dis_txqs *cmd;

	struct ice_aq_desc desc;

	enum ice_status status;
@@ -2992,16 +3021,16 @@ ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps, 
	 */

	desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);



	for (i = 0; i < num_qgrps; ++i) {

		/* Calculate the size taken up by the queue IDs in this group */

		sz += qg_list[i].num_qs * sizeof(qg_list[i].q_id);



		/* Add the size of the group header */

		sz += sizeof(qg_list[i]) - sizeof(qg_list[i].q_id);

	for (i = 0, item = qg_list; i < num_qgrps; i++) {

		u16 item_size = struct_size(item, q_id, item->num_qs);



		/* If the num of queues is even, add 2 bytes of padding */

		if ((qg_list[i].num_qs % 2) == 0)

			sz += 2;

		if ((item->num_qs % 2) == 0)

			item_size += 2;



		sz += item_size;



		item = (struct ice_aqc_dis_txq_item *)((u8 *)item + item_size);

	}



	if (buf_size != sz)
@@ -3390,24 +3419,32 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues, 
		struct ice_sq_cd *cd)

{

	enum ice_status status = ICE_ERR_DOES_NOT_EXIST;

	struct ice_aqc_dis_txq_item qg_list;

	struct ice_aqc_dis_txq_item *qg_list;

	struct ice_q_ctx *q_ctx;

	u16 i;

	struct ice_hw *hw;

	u16 i, buf_size;



	if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)

		return ICE_ERR_CFG;



	hw = pi->hw;



	if (!num_queues) {

		/* if queue is disabled already yet the disable queue command

		 * has to be sent to complete the VF reset, then call

		 * ice_aq_dis_lan_txq without any queue information

		 */

		if (rst_src)

			return ice_aq_dis_lan_txq(pi->hw, 0, NULL, 0, rst_src,

			return ice_aq_dis_lan_txq(hw, 0, NULL, 0, rst_src,

						  vmvf_num, NULL);

		return ICE_ERR_CFG;

	}



	buf_size = struct_size(qg_list, q_id, 1);

	qg_list = kzalloc(buf_size, GFP_KERNEL);

	if (!qg_list)

		return ICE_ERR_NO_MEMORY;



	mutex_lock(&pi->sched_lock);



	for (i = 0; i < num_queues; i++) {
@@ -3416,23 +3453,22 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues, 
		node = ice_sched_find_node_by_teid(pi->root, q_teids[i]);

		if (!node)

			continue;

		q_ctx = ice_get_lan_q_ctx(pi->hw, vsi_handle, tc, q_handles[i]);

		q_ctx = ice_get_lan_q_ctx(hw, vsi_handle, tc, q_handles[i]);

		if (!q_ctx) {

			ice_debug(pi->hw, ICE_DBG_SCHED, "invalid queue handle%d\n",

			ice_debug(hw, ICE_DBG_SCHED, "invalid queue handle%d\n",

				  q_handles[i]);

			continue;

		}

		if (q_ctx->q_handle != q_handles[i]) {

			ice_debug(pi->hw, ICE_DBG_SCHED, "Err:handles %d %d\n",

			ice_debug(hw, ICE_DBG_SCHED, "Err:handles %d %d\n",

				  q_ctx->q_handle, q_handles[i]);

			continue;

		}

		qg_list.parent_teid = node->info.parent_teid;

		qg_list.num_qs = 1;

		qg_list.q_id[0] = cpu_to_le16(q_ids[i]);

		status = ice_aq_dis_lan_txq(pi->hw, 1, &qg_list,

					    sizeof(qg_list), rst_src, vmvf_num,

					    cd);

		qg_list->parent_teid = node->info.parent_teid;

		qg_list->num_qs = 1;

		qg_list->q_id[0] = cpu_to_le16(q_ids[i]);

		status = ice_aq_dis_lan_txq(hw, 1, qg_list, buf_size, rst_src,

					    vmvf_num, cd);



		if (status)

			break;
@@ -3440,6 +3476,7 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u16 vsi_handle, u8 tc, u8 num_queues, 
		q_ctx->q_handle = ICE_INVAL_Q_HANDLE;

	}

	mutex_unlock(&pi->sched_lock);

	kfree(qg_list);

	return status;

}
@@ -3652,14 +3689,14 @@ ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded, 
 */

enum ice_status

ice_sched_query_elem(struct ice_hw *hw, u32 node_teid,

		     struct ice_aqc_get_elem *buf)

		     struct ice_aqc_txsched_elem_data *buf)

{

	u16 buf_size, num_elem_ret = 0;

	enum ice_status status;



	buf_size = sizeof(*buf);

	memset(buf, 0, buf_size);

	buf->generic[0].node_teid = cpu_to_le32(node_teid);

	buf->node_teid = cpu_to_le32(node_teid);

	status = ice_aq_query_sched_elems(hw, 1, buf, buf_size, &num_elem_ret,

					  NULL);

	if (status || num_elem_ret != 1)

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

+4 −1
Original line number Diff line number Diff line
@@ -87,6 +87,9 @@ enum ice_status 
ice_aq_get_phy_caps(struct ice_port_info *pi, bool qual_mods, u8 report_mode,

		    struct ice_aqc_get_phy_caps_data *caps,

		    struct ice_sq_cd *cd);

enum ice_status

ice_aq_list_caps(struct ice_hw *hw, void *buf, u16 buf_size, u32 *cap_count,

		 enum ice_adminq_opc opc, struct ice_sq_cd *cd);

void

ice_update_phy_type(u64 *phy_type_low, u64 *phy_type_high,

		    u16 link_speeds_bitmap);
@@ -152,5 +155,5 @@ ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded, 
		  u64 *prev_stat, u64 *cur_stat);

enum ice_status

ice_sched_query_elem(struct ice_hw *hw, u32 node_teid,

		     struct ice_aqc_get_elem *buf);

		     struct ice_aqc_txsched_elem_data *buf);

#endif /* _ICE_COMMON_H_ */