nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

ice: avoid unnecessary single-member variable-length structs

Browse source 
There are a number of structures that consist of a one-element array as the
only struct member.  Some of those are unused so remove them. Others are
used to index into a buffer/array consisting of a variable number of a
different data or structure type.  Those are unnecessary since we can use
simple pointer arithmetic or index directly into the buffer to access
individual elements of the buffer/array.

Additional code cleanups were done near areas affected by this change.

Signed-off-by: Bruce Allan <bruce.w.allan@intel.com>
Tested-by: Andrew Bowers <andrewx.bowers@intel.com>
Signed-off-by: Tony Nguyen <anthony.l.nguyen@intel.com>
This commit is contained in:
Bruce Allan 2020-06-29 17:27:45 -07:00 committed by Tony Nguyen
parent 8d7aab3515
commit b3c3890489
7 changed files with 51 additions and 100 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

39
drivers/net/ethernet/intel/ice/ice_adminq_cmd.h
View file

@ -215,13 +215,6 @@ struct ice_aqc_get_sw_cfg_resp_elem {
#define ICE_AQC_GET_SW_CONF_RESP_IS_VF BIT(15) #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 /* These resource type defines are used for all switch resource
* commands where a resource type is required, such as: * commands where a resource type is required, such as:
* Get Resource Allocation command (indirect 0x0204) * Get Resource Allocation command (indirect 0x0204)
@ -695,14 +688,6 @@ struct ice_aqc_sched_elem_cmd {
__le32 addr_low; __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 { struct ice_aqc_elem_info_bw {
__le16 bw_profile_idx; __le16 bw_profile_idx;
__le16 bw_alloc; __le16 bw_alloc;
@ -756,14 +741,6 @@ struct ice_aqc_add_elem {
struct ice_aqc_txsched_elem_data generic[1]; 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_get_topo_elem { struct ice_aqc_get_topo_elem {
struct ice_aqc_txsched_topo_grp_info_hdr hdr; struct ice_aqc_txsched_topo_grp_info_hdr hdr;
struct ice_aqc_txsched_elem_data struct ice_aqc_txsched_elem_data
@ -835,10 +812,6 @@ struct ice_aqc_rl_profile_elem {
__le16 rl_encode; __le16 rl_encode;
}; };
struct ice_aqc_rl_profile_generic_elem {
struct ice_aqc_rl_profile_elem generic[1];
};
/* Query Scheduler Resource Allocation (indirect 0x0412) /* Query Scheduler Resource Allocation (indirect 0x0412)
* This indirect command retrieves the scheduler resources allocated by * This indirect command retrieves the scheduler resources allocated by
* EMP Firmware to the given PF. * EMP Firmware to the given PF.
@ -1584,10 +1557,6 @@ struct ice_aqc_dis_txq_item {
(1 << ICE_AQC_Q_DIS_BUF_ELEM_TYPE_S) (1 << ICE_AQC_Q_DIS_BUF_ELEM_TYPE_S)
}; };
struct ice_aqc_dis_txq {
struct ice_aqc_dis_txq_item qgrps[1];
};
/* Configure Firmware Logging Command (indirect 0xFF09) /* Configure Firmware Logging Command (indirect 0xFF09)
* Logging Information Read Response (indirect 0xFF10) * Logging Information Read Response (indirect 0xFF10)
* Note: The 0xFF10 command has no input parameters. * Note: The 0xFF10 command has no input parameters.
@ -1636,12 +1605,7 @@ enum ice_aqc_fw_logging_mod {
ICE_AQC_FW_LOG_ID_MAX, ICE_AQC_FW_LOG_ID_MAX,
}; };
/* This is the buffer for both of the logging commands. /* Defines for both above FW logging command/response buffers */
* 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];
#define ICE_AQC_FW_LOG_ID_S 0 #define ICE_AQC_FW_LOG_ID_S 0
#define ICE_AQC_FW_LOG_ID_M (0xFFF << ICE_AQC_FW_LOG_ID_S) #define ICE_AQC_FW_LOG_ID_M (0xFFF << ICE_AQC_FW_LOG_ID_S)
@ -1654,7 +1618,6 @@ struct ice_aqc_fw_logging_data {
#define ICE_AQC_FW_LOG_INIT_EN BIT(13) /* Used by command */ #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_FLOW_EN BIT(14) /* Used by command */
#define ICE_AQC_FW_LOG_ERR_EN BIT(15) /* Used by command */ #define ICE_AQC_FW_LOG_ERR_EN BIT(15) /* Used by command */
};
/* Get/Clear FW Log (indirect 0xFF11) */ /* Get/Clear FW Log (indirect 0xFF11) */
struct ice_aqc_get_clear_fw_log { struct ice_aqc_get_clear_fw_log {

29
drivers/net/ethernet/intel/ice/ice_common.c
View file

@ -440,30 +440,24 @@ static void ice_cleanup_fltr_mgmt_struct(struct ice_hw *hw)
devm_kfree(ice_hw_to_dev(hw), sw); 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 * ice_get_fw_log_cfg - get FW logging configuration
* @hw: pointer to the HW struct * @hw: pointer to the HW struct
*/ */
static enum ice_status ice_get_fw_log_cfg(struct ice_hw *hw) 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; struct ice_aq_desc desc;
enum ice_status status; enum ice_status status;
__le16 *config;
u16 size; 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); config = devm_kzalloc(ice_hw_to_dev(hw), size, GFP_KERNEL);
if (!config) if (!config)
return ICE_ERR_NO_MEMORY; return ICE_ERR_NO_MEMORY;
ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_fw_logging_info); 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); desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
status = ice_aq_send_cmd(hw, &desc, config, size, NULL); 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++) { for (i = 0; i < ICE_AQC_FW_LOG_ID_MAX; i++) {
u16 v, m, flgs; 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; 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; 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) 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; struct ice_aqc_fw_logging *cmd;
enum ice_status status = 0; enum ice_status status = 0;
u16 i, chgs = 0, len = 0; u16 i, chgs = 0, len = 0;
struct ice_aq_desc desc; struct ice_aq_desc desc;
__le16 *data = NULL;
u8 actv_evnts = 0; u8 actv_evnts = 0;
void *buf = NULL; void *buf = NULL;
@ -571,8 +565,9 @@ static enum ice_status ice_cfg_fw_log(struct ice_hw *hw, bool enable)
continue; continue;
if (!data) { if (!data) {
data = devm_kzalloc(ice_hw_to_dev(hw), data = devm_kcalloc(ice_hw_to_dev(hw),
ICE_FW_LOG_DESC_SIZE_MAX, sizeof(*data),
ICE_AQC_FW_LOG_ID_MAX,
GFP_KERNEL); GFP_KERNEL);
if (!data) if (!data)
return ICE_ERR_NO_MEMORY; 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 = i << ICE_AQC_FW_LOG_ID_S;
val |= hw->fw_log.evnts[i].cfg << ICE_AQC_FW_LOG_EN_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. /* 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; cmd->log_ctrl |= ICE_AQC_FW_LOG_UART_EN;
buf = data; buf = data;
len = ICE_FW_LOG_DESC_SIZE(chgs); len = sizeof(*data) * chgs;
desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD); 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; 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; 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; hw->fw_log.evnts[m].cur = hw->fw_log.evnts[m].cfg;
} }
@ -3690,14 +3685,14 @@ ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
*/ */
enum ice_status enum ice_status
ice_sched_query_elem(struct ice_hw *hw, u32 node_teid, 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; u16 buf_size, num_elem_ret = 0;
enum ice_status status; enum ice_status status;
buf_size = sizeof(*buf); buf_size = sizeof(*buf);
memset(buf, 0, buf_size); 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, status = ice_aq_query_sched_elems(hw, 1, buf, buf_size, &num_elem_ret,
NULL); NULL);
if (status || num_elem_ret != 1) if (status || num_elem_ret != 1)

2
drivers/net/ethernet/intel/ice/ice_common.h
View file

@ -155,5 +155,5 @@ ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
u64 *prev_stat, u64 *cur_stat); u64 *prev_stat, u64 *cur_stat);
enum ice_status enum ice_status
ice_sched_query_elem(struct ice_hw *hw, u32 node_teid, 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_ */ #endif /* _ICE_COMMON_H_ */

4
drivers/net/ethernet/intel/ice/ice_dcb.c
View file

@ -1362,7 +1362,7 @@ ice_update_port_tc_tree_cfg(struct ice_port_info *pi,
struct ice_aqc_port_ets_elem *buf) struct ice_aqc_port_ets_elem *buf)
{ {
struct ice_sched_node *node, *tc_node; struct ice_sched_node *node, *tc_node;
struct ice_aqc_get_elem elem; struct ice_aqc_txsched_elem_data elem;
enum ice_status status = 0; enum ice_status status = 0;
u32 teid1, teid2; u32 teid1, teid2;
u8 i, j; u8 i, j;
@ -1404,7 +1404,7 @@ ice_update_port_tc_tree_cfg(struct ice_port_info *pi,
/* new TC */ /* new TC */
status = ice_sched_query_elem(pi->hw, teid2, &elem); status = ice_sched_query_elem(pi->hw, teid2, &elem);
if (!status) if (!status)
status = ice_sched_add_node(pi, 1, &elem.generic[0]); status = ice_sched_add_node(pi, 1, &elem);
if (status) if (status)
break; break;
/* update the TC number */ /* update the TC number */

61
drivers/net/ethernet/intel/ice/ice_sched.c
View file

@ -129,7 +129,7 @@ ice_aqc_send_sched_elem_cmd(struct ice_hw *hw, enum ice_adminq_opc cmd_opc,
*/ */
enum ice_status enum ice_status
ice_aq_query_sched_elems(struct ice_hw *hw, u16 elems_req, ice_aq_query_sched_elems(struct ice_hw *hw, u16 elems_req,
struct ice_aqc_get_elem *buf, u16 buf_size, struct ice_aqc_txsched_elem_data *buf, u16 buf_size,
u16 *elems_ret, struct ice_sq_cd *cd) u16 *elems_ret, struct ice_sq_cd *cd)
{ {
return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_get_sched_elems, return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_get_sched_elems,
@ -149,8 +149,8 @@ enum ice_status
ice_sched_add_node(struct ice_port_info *pi, u8 layer, ice_sched_add_node(struct ice_port_info *pi, u8 layer,
struct ice_aqc_txsched_elem_data *info) struct ice_aqc_txsched_elem_data *info)
{ {
struct ice_aqc_txsched_elem_data elem;
struct ice_sched_node *parent; struct ice_sched_node *parent;
struct ice_aqc_get_elem elem;
struct ice_sched_node *node; struct ice_sched_node *node;
enum ice_status status; enum ice_status status;
struct ice_hw *hw; struct ice_hw *hw;
@ -195,7 +195,7 @@ ice_sched_add_node(struct ice_port_info *pi, u8 layer,
node->parent = parent; node->parent = parent;
node->tx_sched_layer = layer; node->tx_sched_layer = layer;
parent->children[parent->num_children++] = node; parent->children[parent->num_children++] = node;
memcpy(&node->info, &elem.generic[0], sizeof(node->info)); node->info = elem;
return 0; return 0;
} }
@ -423,7 +423,7 @@ ice_aq_add_sched_elems(struct ice_hw *hw, u16 grps_req,
*/ */
static enum ice_status static enum ice_status
ice_aq_cfg_sched_elems(struct ice_hw *hw, u16 elems_req, ice_aq_cfg_sched_elems(struct ice_hw *hw, u16 elems_req,
struct ice_aqc_conf_elem *buf, u16 buf_size, struct ice_aqc_txsched_elem_data *buf, u16 buf_size,
u16 *elems_cfgd, struct ice_sq_cd *cd) u16 *elems_cfgd, struct ice_sq_cd *cd)
{ {
return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_cfg_sched_elems, return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_cfg_sched_elems,
@ -443,8 +443,7 @@ ice_aq_cfg_sched_elems(struct ice_hw *hw, u16 elems_req,
* Suspend scheduling elements (0x0409) * Suspend scheduling elements (0x0409)
*/ */
static enum ice_status static enum ice_status
ice_aq_suspend_sched_elems(struct ice_hw *hw, u16 elems_req, ice_aq_suspend_sched_elems(struct ice_hw *hw, u16 elems_req, __le32 *buf,
struct ice_aqc_suspend_resume_elem *buf,
u16 buf_size, u16 *elems_ret, struct ice_sq_cd *cd) u16 buf_size, u16 *elems_ret, struct ice_sq_cd *cd)
{ {
return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_suspend_sched_elems, return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_suspend_sched_elems,
@ -464,8 +463,7 @@ ice_aq_suspend_sched_elems(struct ice_hw *hw, u16 elems_req,
* resume scheduling elements (0x040A) * resume scheduling elements (0x040A)
*/ */
static enum ice_status static enum ice_status
ice_aq_resume_sched_elems(struct ice_hw *hw, u16 elems_req, ice_aq_resume_sched_elems(struct ice_hw *hw, u16 elems_req, __le32 *buf,
struct ice_aqc_suspend_resume_elem *buf,
u16 buf_size, u16 *elems_ret, struct ice_sq_cd *cd) u16 buf_size, u16 *elems_ret, struct ice_sq_cd *cd)
{ {
return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_resume_sched_elems, return ice_aqc_send_sched_elem_cmd(hw, ice_aqc_opc_resume_sched_elems,
@ -506,9 +504,9 @@ static enum ice_status
ice_sched_suspend_resume_elems(struct ice_hw *hw, u8 num_nodes, u32 *node_teids, ice_sched_suspend_resume_elems(struct ice_hw *hw, u8 num_nodes, u32 *node_teids,
bool suspend) bool suspend)
{ {
struct ice_aqc_suspend_resume_elem *buf;
u16 i, buf_size, num_elem_ret = 0; u16 i, buf_size, num_elem_ret = 0;
enum ice_status status; enum ice_status status;
__le32 *buf;
buf_size = sizeof(*buf) * num_nodes; buf_size = sizeof(*buf) * num_nodes;
buf = devm_kzalloc(ice_hw_to_dev(hw), buf_size, GFP_KERNEL); buf = devm_kzalloc(ice_hw_to_dev(hw), buf_size, GFP_KERNEL);
@ -516,7 +514,7 @@ ice_sched_suspend_resume_elems(struct ice_hw *hw, u8 num_nodes, u32 *node_teids,
return ICE_ERR_NO_MEMORY; return ICE_ERR_NO_MEMORY;
for (i = 0; i < num_nodes; i++) for (i = 0; i < num_nodes; i++)
buf->teid[i] = cpu_to_le32(node_teids[i]); buf[i] = cpu_to_le32(node_teids[i]);
if (suspend) if (suspend)
status = ice_aq_suspend_sched_elems(hw, num_nodes, buf, status = ice_aq_suspend_sched_elems(hw, num_nodes, buf,
@ -591,7 +589,7 @@ ice_alloc_lan_q_ctx(struct ice_hw *hw, u16 vsi_handle, u8 tc, u16 new_numqs)
*/ */
static enum ice_status static enum ice_status
ice_aq_rl_profile(struct ice_hw *hw, enum ice_adminq_opc opcode, ice_aq_rl_profile(struct ice_hw *hw, enum ice_adminq_opc opcode,
u16 num_profiles, struct ice_aqc_rl_profile_generic_elem *buf, u16 num_profiles, struct ice_aqc_rl_profile_elem *buf,
u16 buf_size, u16 *num_processed, struct ice_sq_cd *cd) u16 buf_size, u16 *num_processed, struct ice_sq_cd *cd)
{ {
struct ice_aqc_rl_profile *cmd; struct ice_aqc_rl_profile *cmd;
@ -622,13 +620,11 @@ ice_aq_rl_profile(struct ice_hw *hw, enum ice_adminq_opc opcode,
*/ */
static enum ice_status static enum ice_status
ice_aq_add_rl_profile(struct ice_hw *hw, u16 num_profiles, ice_aq_add_rl_profile(struct ice_hw *hw, u16 num_profiles,
struct ice_aqc_rl_profile_generic_elem *buf, struct ice_aqc_rl_profile_elem *buf, u16 buf_size,
u16 buf_size, u16 *num_profiles_added, u16 *num_profiles_added, struct ice_sq_cd *cd)
struct ice_sq_cd *cd)
{ {
return ice_aq_rl_profile(hw, ice_aqc_opc_add_rl_profiles, return ice_aq_rl_profile(hw, ice_aqc_opc_add_rl_profiles, num_profiles,
num_profiles, buf, buf, buf_size, num_profiles_added, cd);
buf_size, num_profiles_added, cd);
} }
/** /**
@ -644,13 +640,12 @@ ice_aq_add_rl_profile(struct ice_hw *hw, u16 num_profiles,
*/ */
static enum ice_status static enum ice_status
ice_aq_remove_rl_profile(struct ice_hw *hw, u16 num_profiles, ice_aq_remove_rl_profile(struct ice_hw *hw, u16 num_profiles,
struct ice_aqc_rl_profile_generic_elem *buf, struct ice_aqc_rl_profile_elem *buf, u16 buf_size,
u16 buf_size, u16 *num_profiles_removed, u16 *num_profiles_removed, struct ice_sq_cd *cd)
struct ice_sq_cd *cd)
{ {
return ice_aq_rl_profile(hw, ice_aqc_opc_remove_rl_profiles, return ice_aq_rl_profile(hw, ice_aqc_opc_remove_rl_profiles,
num_profiles, buf, num_profiles, buf, buf_size,
buf_size, num_profiles_removed, cd); num_profiles_removed, cd);
} }
/** /**
@ -666,7 +661,7 @@ static enum ice_status
ice_sched_del_rl_profile(struct ice_hw *hw, ice_sched_del_rl_profile(struct ice_hw *hw,
struct ice_aqc_rl_profile_info *rl_info) struct ice_aqc_rl_profile_info *rl_info)
{ {
struct ice_aqc_rl_profile_generic_elem *buf; struct ice_aqc_rl_profile_elem *buf;
u16 num_profiles_removed; u16 num_profiles_removed;
enum ice_status status; enum ice_status status;
u16 num_profiles = 1; u16 num_profiles = 1;
@ -675,8 +670,7 @@ ice_sched_del_rl_profile(struct ice_hw *hw,
return ICE_ERR_IN_USE; return ICE_ERR_IN_USE;
/* Safe to remove profile ID */ /* Safe to remove profile ID */
buf = (struct ice_aqc_rl_profile_generic_elem *) buf = &rl_info->profile;
&rl_info->profile;
status = ice_aq_remove_rl_profile(hw, num_profiles, buf, sizeof(*buf), status = ice_aq_remove_rl_profile(hw, num_profiles, buf, sizeof(*buf),
&num_profiles_removed, NULL); &num_profiles_removed, NULL);
if (status || num_profiles_removed != num_profiles) if (status || num_profiles_removed != num_profiles)
@ -1867,7 +1861,7 @@ static void ice_sched_rm_unused_rl_prof(struct ice_port_info *pi)
* @node: pointer to node * @node: pointer to node
* @info: node info to update * @info: node info to update
* *
* It updates the HW DB, and local SW DB of node. It updates the scheduling * Update the HW DB, and local SW DB of node. Update the scheduling
* parameters of node from argument info data buffer (Info->data buf) and * parameters of node from argument info data buffer (Info->data buf) and
* returns success or error on config sched element failure. The caller * returns success or error on config sched element failure. The caller
* needs to hold scheduler lock. * needs to hold scheduler lock.
@ -1876,18 +1870,18 @@ static enum ice_status
ice_sched_update_elem(struct ice_hw *hw, struct ice_sched_node *node, ice_sched_update_elem(struct ice_hw *hw, struct ice_sched_node *node,
struct ice_aqc_txsched_elem_data *info) struct ice_aqc_txsched_elem_data *info)
{ {
struct ice_aqc_conf_elem buf; struct ice_aqc_txsched_elem_data buf;
enum ice_status status; enum ice_status status;
u16 elem_cfgd = 0; u16 elem_cfgd = 0;
u16 num_elems = 1; u16 num_elems = 1;
buf.generic[0] = *info; buf = *info;
/* Parent TEID is reserved field in this aq call */ /* Parent TEID is reserved field in this aq call */
buf.generic[0].parent_teid = 0; buf.parent_teid = 0;
/* Element type is reserved field in this aq call */ /* Element type is reserved field in this aq call */
buf.generic[0].data.elem_type = 0; buf.data.elem_type = 0;
/* Flags is reserved field in this aq call */ /* Flags is reserved field in this aq call */
buf.generic[0].data.flags = 0; buf.data.flags = 0;
/* Update HW DB */ /* Update HW DB */
/* Configure element node */ /* Configure element node */
@ -2131,9 +2125,9 @@ static struct ice_aqc_rl_profile_info *
ice_sched_add_rl_profile(struct ice_port_info *pi, ice_sched_add_rl_profile(struct ice_port_info *pi,
enum ice_rl_type rl_type, u32 bw, u8 layer_num) enum ice_rl_type rl_type, u32 bw, u8 layer_num)
{ {
struct ice_aqc_rl_profile_generic_elem *buf;
struct ice_aqc_rl_profile_info *rl_prof_elem; struct ice_aqc_rl_profile_info *rl_prof_elem;
u16 profiles_added = 0, num_profiles = 1; u16 profiles_added = 0, num_profiles = 1;
struct ice_aqc_rl_profile_elem *buf;
enum ice_status status; enum ice_status status;
struct ice_hw *hw; struct ice_hw *hw;
u8 profile_type; u8 profile_type;
@ -2182,8 +2176,7 @@ ice_sched_add_rl_profile(struct ice_port_info *pi,
rl_prof_elem->profile.max_burst_size = cpu_to_le16(hw->max_burst_size); rl_prof_elem->profile.max_burst_size = cpu_to_le16(hw->max_burst_size);
/* Create new entry in HW DB */ /* Create new entry in HW DB */
buf = (struct ice_aqc_rl_profile_generic_elem *) buf = &rl_prof_elem->profile;
&rl_prof_elem->profile;
status = ice_aq_add_rl_profile(hw, num_profiles, buf, sizeof(*buf), status = ice_aq_add_rl_profile(hw, num_profiles, buf, sizeof(*buf),
&profiles_added, NULL); &profiles_added, NULL);
if (status || profiles_added != num_profiles) if (status || profiles_added != num_profiles)

2
drivers/net/ethernet/intel/ice/ice_sched.h
View file

@ -56,7 +56,7 @@ struct ice_sched_agg_info {
/* FW AQ command calls */ /* FW AQ command calls */
enum ice_status enum ice_status
ice_aq_query_sched_elems(struct ice_hw *hw, u16 elems_req, ice_aq_query_sched_elems(struct ice_hw *hw, u16 elems_req,
struct ice_aqc_get_elem *buf, u16 buf_size, struct ice_aqc_txsched_elem_data *buf, u16 buf_size,
u16 *elems_ret, struct ice_sq_cd *cd); u16 *elems_ret, struct ice_sq_cd *cd);
enum ice_status ice_sched_init_port(struct ice_port_info *pi); enum ice_status ice_sched_init_port(struct ice_port_info *pi);
enum ice_status ice_sched_query_res_alloc(struct ice_hw *hw); enum ice_status ice_sched_query_res_alloc(struct ice_hw *hw);

14
drivers/net/ethernet/intel/ice/ice_switch.c
View file

@ -87,7 +87,7 @@ enum ice_status ice_init_def_sw_recp(struct ice_hw *hw)
* @num_elems: pointer to number of elements * @num_elems: pointer to number of elements
* @cd: pointer to command details structure or NULL * @cd: pointer to command details structure or NULL
* *
* Get switch configuration (0x0200) to be placed in 'buff'. * Get switch configuration (0x0200) to be placed in buf.
* This admin command returns information such as initial VSI/port number * This admin command returns information such as initial VSI/port number
* and switch ID it belongs to. * and switch ID it belongs to.
* *
@ -104,13 +104,13 @@ enum ice_status ice_init_def_sw_recp(struct ice_hw *hw)
* parsing the response buffer. * parsing the response buffer.
*/ */
static enum ice_status static enum ice_status
ice_aq_get_sw_cfg(struct ice_hw *hw, struct ice_aqc_get_sw_cfg_resp *buf, ice_aq_get_sw_cfg(struct ice_hw *hw, struct ice_aqc_get_sw_cfg_resp_elem *buf,
u16 buf_size, u16 *req_desc, u16 *num_elems, u16 buf_size, u16 *req_desc, u16 *num_elems,
struct ice_sq_cd *cd) struct ice_sq_cd *cd)
{ {
struct ice_aqc_get_sw_cfg *cmd; struct ice_aqc_get_sw_cfg *cmd;
enum ice_status status;
struct ice_aq_desc desc; struct ice_aq_desc desc;
enum ice_status status;
ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_sw_cfg); ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_sw_cfg);
cmd = &desc.params.get_sw_conf; cmd = &desc.params.get_sw_conf;
@ -550,7 +550,7 @@ ice_init_port_info(struct ice_port_info *pi, u16 vsi_port_num, u8 type,
*/ */
enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw) enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw)
{ {
struct ice_aqc_get_sw_cfg_resp *rbuf; struct ice_aqc_get_sw_cfg_resp_elem *rbuf;
enum ice_status status; enum ice_status status;
u16 req_desc = 0; u16 req_desc = 0;
u16 num_elems; u16 num_elems;
@ -568,19 +568,19 @@ enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw)
* writing a non-zero value in req_desc * writing a non-zero value in req_desc
*/ */
do { do {
struct ice_aqc_get_sw_cfg_resp_elem *ele;
status = ice_aq_get_sw_cfg(hw, rbuf, ICE_SW_CFG_MAX_BUF_LEN, status = ice_aq_get_sw_cfg(hw, rbuf, ICE_SW_CFG_MAX_BUF_LEN,
&req_desc, &num_elems, NULL); &req_desc, &num_elems, NULL);
if (status) if (status)
break; break;
for (i = 0; i < num_elems; i++) { for (i = 0, ele = rbuf; i < num_elems; i++, ele++) {
struct ice_aqc_get_sw_cfg_resp_elem *ele;
u16 pf_vf_num, swid, vsi_port_num; u16 pf_vf_num, swid, vsi_port_num;
bool is_vf = false; bool is_vf = false;
u8 res_type; u8 res_type;
ele = rbuf[i].elements;
vsi_port_num = le16_to_cpu(ele->vsi_port_num) & vsi_port_num = le16_to_cpu(ele->vsi_port_num) &
ICE_AQC_GET_SW_CONF_RESP_VSI_PORT_NUM_M; ICE_AQC_GET_SW_CONF_RESP_VSI_PORT_NUM_M;