* [PATCH v11 04/22] wifi: nxpwifi: add initial 802.11ax support for STA and AP modes
From: Jeff Chen @ 2026-04-28 19:40 UTC (permalink / raw)
To: linux-wireless
Cc: linux-kernel, ulf.hansson, johannes, francesco, wyatt.hsu,
s.hauer, Jeff Chen
In-Reply-To: <20260428194021.785252-1-jeff.chen_1@nxp.com>
Add initial 802.11ax support for both station and AP roles, enabling HE
capability negotiation and configuration through firmware assisted
commands.
Convert HE elements from cfg80211 into firmware TLVs and append them to
HOST_CMD_802_11_ASSOCIATE when operating as a station. For AP mode,
convert HE elements into parameters for HOST_CMD_11AX_CFG and provide
them to the firmware for configuration.
Handle HE MAC/PHY capabilities, MCS maps, and Target Wake Time (TWT)
negotiation. Add support for additional 11ax-specific firmware commands,
including OBSS PD, beamforming, TXOMI, and broadcast TWT.
Signed-off-by: Jeff Chen <jeff.chen_1@nxp.com>
---
drivers/net/wireless/nxp/nxpwifi/11ax.c | 594 ++++++++++++++++++++++++
drivers/net/wireless/nxp/nxpwifi/11ax.h | 73 +++
2 files changed, 667 insertions(+)
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ax.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ax.h
diff --git a/drivers/net/wireless/nxp/nxpwifi/11ax.c b/drivers/net/wireless/nxp/nxpwifi/11ax.c
new file mode 100644
index 000000000000..cc47c435eb70
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11ax.c
@@ -0,0 +1,594 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* nxpwifi: 802.11ax (HE) support
+ * Copyright (C) 2011-2024 NXP
+ */
+
+#include "cfg.h"
+#include "fw.h"
+#include "main.h"
+#include "11ax.h"
+
+void nxpwifi_update_11ax_cap(struct nxpwifi_adapter *adapter,
+ struct hw_spec_extension *hw_he_cap)
+{
+ struct nxpwifi_private *priv;
+ struct nxpwifi_ie_types_he_cap *he_cap = NULL;
+ struct nxpwifi_ie_types_he_cap *user_he_cap = NULL;
+ u8 header_len = sizeof(struct nxpwifi_ie_types_header);
+ u16 data_len = le16_to_cpu(hw_he_cap->header.len);
+ bool he_cap_2g = false;
+ int i;
+
+ if ((data_len + header_len) > sizeof(adapter->hw_he_cap)) {
+ nxpwifi_dbg(adapter, ERROR,
+ "hw_he_cap too big, len=%d\n",
+ data_len);
+ return;
+ }
+
+ he_cap = (struct nxpwifi_ie_types_he_cap *)hw_he_cap;
+
+ if (he_cap->he_phy_cap[0] &
+ (AX_2G_40MHZ_SUPPORT | AX_2G_20MHZ_SUPPORT)) {
+ adapter->hw_2g_he_cap_len = data_len + header_len;
+ memcpy(adapter->hw_2g_he_cap, (u8 *)hw_he_cap,
+ adapter->hw_2g_he_cap_len);
+ adapter->fw_bands |= BAND_GAX;
+ he_cap_2g = true;
+ nxpwifi_dbg_dump(adapter, CMD_D, "2.4G HE capability element ",
+ adapter->hw_2g_he_cap,
+ adapter->hw_2g_he_cap_len);
+ } else {
+ adapter->hw_he_cap_len = data_len + header_len;
+ memcpy(adapter->hw_he_cap, (u8 *)hw_he_cap,
+ adapter->hw_he_cap_len);
+ adapter->fw_bands |= BAND_AAX;
+ nxpwifi_dbg_dump(adapter, CMD_D, "5G HE capability element ",
+ adapter->hw_he_cap,
+ adapter->hw_he_cap_len);
+ }
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+
+ if (he_cap_2g) {
+ priv->user_2g_he_cap_len = adapter->hw_2g_he_cap_len;
+ memcpy(priv->user_2g_he_cap, adapter->hw_2g_he_cap,
+ sizeof(adapter->hw_2g_he_cap));
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->user_2g_he_cap;
+ } else {
+ priv->user_he_cap_len = adapter->hw_he_cap_len;
+ memcpy(priv->user_he_cap, adapter->hw_he_cap,
+ sizeof(adapter->hw_he_cap));
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->user_he_cap;
+ }
+
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_STA)
+ user_he_cap->he_mac_cap[0] &=
+ ~HE_MAC_CAP_TWT_RESP_SUPPORT;
+ else
+ user_he_cap->he_mac_cap[0] &=
+ ~HE_MAC_CAP_TWT_REQ_SUPPORT;
+ }
+
+ adapter->is_hw_11ax_capable = true;
+}
+
+bool nxpwifi_11ax_bandconfig_allowed(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc)
+{
+ u16 bss_band = bss_desc->bss_band;
+
+ if (bss_desc->disable_11n)
+ return false;
+
+ if (bss_band & BAND_G)
+ return (priv->config_bands & BAND_GAX);
+ else if (bss_band & BAND_A)
+ return (priv->config_bands & BAND_AAX);
+
+ return false;
+}
+
+int nxpwifi_fill_he_cap_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_ie_types_he_cap *he_cap,
+ u16 bands)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct nxpwifi_ie_types_he_cap *hw_he_cap = NULL;
+ u16 rx_nss, tx_nss;
+ u8 nss;
+ u16 cfg_value;
+ u16 hw_value;
+ int ret_len;
+
+ if (bands & BAND_A) {
+ memcpy(he_cap, priv->user_he_cap, priv->user_he_cap_len);
+ hw_he_cap = (struct nxpwifi_ie_types_he_cap *)adapter->hw_he_cap;
+ ret_len = priv->user_he_cap_len;
+ } else {
+ memcpy(he_cap, priv->user_2g_he_cap, priv->user_2g_he_cap_len);
+ hw_he_cap = (struct nxpwifi_ie_types_he_cap *)adapter->hw_2g_he_cap;
+ ret_len = priv->user_2g_he_cap_len;
+ }
+
+ if (bands & BAND_A) {
+ rx_nss = GET_RXMCSSUPP(adapter->user_htstream >> 8);
+ tx_nss = GET_TXMCSSUPP(adapter->user_htstream >> 8) & 0x0f;
+ } else {
+ rx_nss = GET_RXMCSSUPP(adapter->user_htstream);
+ tx_nss = GET_TXMCSSUPP(adapter->user_htstream) & 0x0f;
+ }
+
+ for (nss = 1; nss <= 8; nss++) {
+ cfg_value = nxpwifi_get_he_nss_mcs(he_cap->rx_mcs_80, nss);
+ hw_value = nxpwifi_get_he_nss_mcs(hw_he_cap->rx_mcs_80, nss);
+ if (rx_nss != 0 && nss > rx_nss)
+ cfg_value = NO_NSS_SUPPORT;
+ if (hw_value == NO_NSS_SUPPORT || cfg_value == NO_NSS_SUPPORT)
+ nxpwifi_set_he_nss_mcs(&he_cap->rx_mcs_80, nss,
+ NO_NSS_SUPPORT);
+ else
+ nxpwifi_set_he_nss_mcs(&he_cap->rx_mcs_80, nss,
+ min(cfg_value, hw_value));
+ }
+
+ for (nss = 1; nss <= 8; nss++) {
+ cfg_value = nxpwifi_get_he_nss_mcs(he_cap->tx_mcs_80, nss);
+ hw_value = nxpwifi_get_he_nss_mcs(hw_he_cap->tx_mcs_80, nss);
+ if (tx_nss != 0 && nss > tx_nss)
+ cfg_value = NO_NSS_SUPPORT;
+ if (hw_value == NO_NSS_SUPPORT || cfg_value == NO_NSS_SUPPORT)
+ nxpwifi_set_he_nss_mcs(&he_cap->tx_mcs_80, nss,
+ NO_NSS_SUPPORT);
+ else
+ nxpwifi_set_he_nss_mcs(&he_cap->tx_mcs_80, nss,
+ min(cfg_value, hw_value));
+ }
+
+ return ret_len;
+}
+
+int nxpwifi_cmd_append_11ax_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer)
+{
+ struct nxpwifi_ie_types_he_cap *he_cap = NULL;
+ int ret_len;
+
+ if (!bss_desc->bcn_he_cap)
+ return -EOPNOTSUPP;
+
+ he_cap = (struct nxpwifi_ie_types_he_cap *)*buffer;
+ ret_len = nxpwifi_fill_he_cap_tlv(priv, he_cap, bss_desc->bss_band);
+ *buffer += ret_len;
+
+ return ret_len;
+}
+
+int nxpwifi_cmd_11ax_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ax_he_cfg *ax_cfg)
+{
+ struct host_cmd_11ax_cfg *he_cfg = &cmd->params.ax_cfg;
+ u16 cmd_size;
+ struct nxpwifi_ie_types_header *header;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11AX_CFG);
+ cmd_size = sizeof(struct host_cmd_11ax_cfg) + S_DS_GEN;
+
+ he_cfg->action = cpu_to_le16(cmd_action);
+ he_cfg->band_config = ax_cfg->band;
+
+ if (ax_cfg->he_cap_cfg.len &&
+ ax_cfg->he_cap_cfg.ext_id == WLAN_EID_EXT_HE_CAPABILITY) {
+ header = (struct nxpwifi_ie_types_header *)he_cfg->tlv;
+ header->type = cpu_to_le16(ax_cfg->he_cap_cfg.id);
+ header->len = cpu_to_le16(ax_cfg->he_cap_cfg.len);
+ memcpy(he_cfg->tlv + sizeof(*header),
+ &ax_cfg->he_cap_cfg.ext_id,
+ ax_cfg->he_cap_cfg.len);
+ cmd_size += (sizeof(*header) + ax_cfg->he_cap_cfg.len);
+ }
+
+ cmd->size = cpu_to_le16(cmd_size);
+
+ return 0;
+}
+
+int nxpwifi_ret_11ax_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_11ax_he_cfg *ax_cfg)
+{
+ struct host_cmd_11ax_cfg *he_cfg = &resp->params.ax_cfg;
+ struct nxpwifi_ie_types_header *header;
+ u16 left_len, tlv_type, tlv_len;
+ u8 ext_id;
+ struct nxpwifi_11ax_he_cap_cfg *he_cap = &ax_cfg->he_cap_cfg;
+
+ left_len = le16_to_cpu(resp->size) - sizeof(*he_cfg) - S_DS_GEN;
+ header = (struct nxpwifi_ie_types_header *)he_cfg->tlv;
+
+ while (left_len > sizeof(*header)) {
+ tlv_type = le16_to_cpu(header->type);
+ tlv_len = le16_to_cpu(header->len);
+
+ if (tlv_type == TLV_TYPE_EXTENSION_ID) {
+ ext_id = *((u8 *)header + sizeof(*header) + 1);
+ if (ext_id == WLAN_EID_EXT_HE_CAPABILITY) {
+ he_cap->id = tlv_type;
+ he_cap->len = tlv_len;
+ memcpy((u8 *)&he_cap->ext_id,
+ (u8 *)header + sizeof(*header) + 1,
+ tlv_len);
+ if (he_cfg->band_config & BIT(1)) {
+ memcpy(priv->user_he_cap,
+ (u8 *)header,
+ sizeof(*header) + tlv_len);
+ priv->user_he_cap_len =
+ sizeof(*header) + tlv_len;
+ } else {
+ memcpy(priv->user_2g_he_cap,
+ (u8 *)header,
+ sizeof(*header) + tlv_len);
+ priv->user_2g_he_cap_len =
+ sizeof(*header) + tlv_len;
+ }
+ }
+ }
+
+ left_len -= (sizeof(*header) + tlv_len);
+ header = (struct nxpwifi_ie_types_header *)((u8 *)header +
+ sizeof(*header) +
+ tlv_len);
+ }
+
+ return 0;
+}
+
+int nxpwifi_cmd_11ax_cmd(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ax_cmd_cfg *ax_cmd)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct host_cmd_11ax_cmd *he_cmd = &cmd->params.ax_cmd;
+ u16 cmd_size;
+ struct nxpwifi_11ax_sr_cmd *sr_cmd;
+ struct nxpwifi_ie_types_data *tlv;
+ struct nxpwifi_11ax_beam_cmd *beam_cmd;
+ struct nxpwifi_11ax_htc_cmd *htc_cmd;
+ struct nxpwifi_11ax_txomi_cmd *txmoi_cmd;
+ struct nxpwifi_11ax_toltime_cmd *toltime_cmd;
+ struct nxpwifi_11ax_txop_cmd *txop_cmd;
+ struct nxpwifi_11ax_set_bsrp_cmd *set_bsrp_cmd;
+ struct nxpwifi_11ax_llde_cmd *llde_cmd;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11AX_CMD);
+ cmd_size = sizeof(struct host_cmd_11ax_cmd) + S_DS_GEN;
+
+ he_cmd->action = cpu_to_le16(cmd_action);
+ he_cmd->sub_id = cpu_to_le16(ax_cmd->sub_id);
+
+ switch (ax_cmd->sub_command) {
+ case NXPWIFI_11AXCMD_SR_SUBID:
+ sr_cmd = (struct nxpwifi_11ax_sr_cmd *)&ax_cmd->param;
+
+ tlv = (struct nxpwifi_ie_types_data *)he_cmd->val;
+ tlv->header.type = cpu_to_le16(sr_cmd->type);
+ tlv->header.len = cpu_to_le16(sr_cmd->len);
+ memcpy(tlv->data, sr_cmd->param.obss_pd_offset.offset,
+ sr_cmd->len);
+ cmd_size += (sizeof(tlv->header) + sr_cmd->len);
+ break;
+ case NXPWIFI_11AXCMD_BEAM_SUBID:
+ beam_cmd = (struct nxpwifi_11ax_beam_cmd *)&ax_cmd->param;
+
+ he_cmd->val[0] = beam_cmd->value;
+ cmd_size += sizeof(*beam_cmd);
+ break;
+ case NXPWIFI_11AXCMD_HTC_SUBID:
+ htc_cmd = (struct nxpwifi_11ax_htc_cmd *)&ax_cmd->param;
+
+ he_cmd->val[0] = htc_cmd->value;
+ cmd_size += sizeof(*htc_cmd);
+ break;
+ case NXPWIFI_11AXCMD_TXOMI_SUBID:
+ txmoi_cmd = (struct nxpwifi_11ax_txomi_cmd *)&ax_cmd->param;
+
+ memcpy((void *)he_cmd->val, txmoi_cmd, sizeof(*txmoi_cmd));
+ cmd_size += sizeof(*txmoi_cmd);
+ break;
+ case NXPWIFI_11AXCMD_OBSS_TOLTIME_SUBID:
+ toltime_cmd = (struct nxpwifi_11ax_toltime_cmd *)&ax_cmd->param;
+
+ memcpy(he_cmd->val, &toltime_cmd->tol_time,
+ sizeof(toltime_cmd->tol_time));
+ cmd_size += sizeof(*toltime_cmd);
+ break;
+ case NXPWIFI_11AXCMD_TXOPRTS_SUBID:
+ txop_cmd = (struct nxpwifi_11ax_txop_cmd *)&ax_cmd->param;
+
+ memcpy(he_cmd->val, &txop_cmd->rts_thres,
+ sizeof(txop_cmd->rts_thres));
+ cmd_size += sizeof(*txop_cmd);
+ break;
+ case NXPWIFI_11AXCMD_SET_BSRP_SUBID:
+ set_bsrp_cmd = (struct nxpwifi_11ax_set_bsrp_cmd *)&ax_cmd->param;
+
+ he_cmd->val[0] = set_bsrp_cmd->value;
+ cmd_size += sizeof(*set_bsrp_cmd);
+ break;
+ case NXPWIFI_11AXCMD_LLDE_SUBID:
+ llde_cmd = (struct nxpwifi_11ax_llde_cmd *)&ax_cmd->param;
+
+ memcpy((void *)he_cmd->val, llde_cmd, sizeof(*llde_cmd));
+ cmd_size += sizeof(*llde_cmd);
+ break;
+ default:
+ nxpwifi_dbg(adapter, ERROR,
+ "%s: Unknown sub command: %d\n",
+ __func__, ax_cmd->sub_command);
+ return -EINVAL;
+ }
+
+ cmd->size = cpu_to_le16(cmd_size);
+
+ return 0;
+}
+
+int nxpwifi_ret_11ax_cmd(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_11ax_cmd_cfg *ax_cmd)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct host_cmd_11ax_cmd *he_cmd = &resp->params.ax_cmd;
+ struct nxpwifi_ie_types_data *tlv;
+
+ ax_cmd->sub_id = le16_to_cpu(he_cmd->sub_id);
+
+ switch (ax_cmd->sub_command) {
+ case NXPWIFI_11AXCMD_SR_SUBID:
+ tlv = (struct nxpwifi_ie_types_data *)he_cmd->val;
+ memcpy(ax_cmd->param.sr_cfg.param.obss_pd_offset.offset,
+ tlv->data,
+ ax_cmd->param.sr_cfg.len);
+ break;
+ case NXPWIFI_11AXCMD_BEAM_SUBID:
+ ax_cmd->param.beam_cfg.value = *he_cmd->val;
+ break;
+ case NXPWIFI_11AXCMD_HTC_SUBID:
+ ax_cmd->param.htc_cfg.value = *he_cmd->val;
+ break;
+ case NXPWIFI_11AXCMD_TXOMI_SUBID:
+ memcpy(&ax_cmd->param.txomi_cfg,
+ he_cmd->val, sizeof(ax_cmd->param.txomi_cfg));
+ break;
+ case NXPWIFI_11AXCMD_OBSS_TOLTIME_SUBID:
+ memcpy(&ax_cmd->param.toltime_cfg.tol_time,
+ he_cmd->val, sizeof(ax_cmd->param.toltime_cfg));
+ break;
+ case NXPWIFI_11AXCMD_TXOPRTS_SUBID:
+ memcpy(&ax_cmd->param.txop_cfg.rts_thres,
+ he_cmd->val, sizeof(ax_cmd->param.txop_cfg));
+ break;
+ case NXPWIFI_11AXCMD_SET_BSRP_SUBID:
+ ax_cmd->param.setbsrp_cfg.value = *he_cmd->val;
+ break;
+ case NXPWIFI_11AXCMD_LLDE_SUBID:
+ memcpy(&ax_cmd->param.llde_cfg,
+ he_cmd->val, sizeof(ax_cmd->param.llde_cfg));
+ break;
+ default:
+ nxpwifi_dbg(adapter, ERROR,
+ "%s: Unknown sub command: %d\n",
+ __func__, ax_cmd->sub_command);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static u8 nxpwifi_is_ap_11ax_twt_supported(struct nxpwifi_bssdescriptor *bss_desc)
+{
+ struct element *ext_cap;
+
+ if (!bss_desc->bcn_he_cap)
+ return false;
+ if (!(bss_desc->bcn_he_cap->mac_cap_info[0] & HE_MAC_CAP_TWT_RESP_SUPPORT))
+ return false;
+ if (!bss_desc->bcn_ext_cap)
+ return false;
+ ext_cap = (struct element *)bss_desc->bcn_ext_cap;
+
+ if (!(ext_cap->data[9] & WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT))
+ return false;
+ return true;
+}
+
+bool nxpwifi_is_11ax_twt_supported(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc)
+{
+ struct nxpwifi_ie_types_he_cap *user_he_cap;
+ struct nxpwifi_ie_types_he_cap *hw_he_cap;
+
+ if (bss_desc && (!nxpwifi_is_ap_11ax_twt_supported(bss_desc))) {
+ nxpwifi_dbg(priv->adapter, MSG,
+ "AP don't support twt feature\n");
+ return false;
+ }
+
+ if (bss_desc->bss_band & BAND_A) {
+ hw_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->adapter->hw_he_cap;
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->user_he_cap;
+ } else {
+ hw_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->adapter->hw_2g_he_cap;
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)
+ priv->user_2g_he_cap;
+ }
+
+ if (!(hw_he_cap->he_mac_cap[0] & HE_MAC_CAP_TWT_REQ_SUPPORT)) {
+ nxpwifi_dbg(priv->adapter, MSG,
+ "FW don't support TWT\n");
+ return false;
+ }
+
+ if (!(user_he_cap->he_mac_cap[0] & HE_MAC_CAP_TWT_REQ_SUPPORT)) {
+ nxpwifi_dbg(priv->adapter, MSG,
+ "USER HE_MAC_CAP don't support TWT\n");
+ return false;
+ }
+
+ return true;
+}
+
+u8 nxpwifi_is_sta_11ax_twt_req_supported(struct nxpwifi_private *priv)
+{
+ struct nxpwifi_ie_types_he_cap *user_he_cap;
+ u8 ret = 0;
+
+ if (ISSUPP_11AXENABLED(priv->adapter->fw_cap_ext) &&
+ (priv->config_bands & BAND_GAX || priv->config_bands & BAND_AAX)) {
+ if (priv->config_bands & BAND_AAX)
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)priv->user_he_cap;
+ else
+ user_he_cap = (struct nxpwifi_ie_types_he_cap *)priv->user_2g_he_cap;
+ ret = user_he_cap->he_mac_cap[0] & HE_MAC_CAP_TWT_REQ_SUPPORT;
+ }
+
+ return ret;
+}
+
+int nxpwifi_cmd_twt_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_twt_cfg *twt_cfg)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct host_cmd_twt_cfg *twt_cfg_cmd = &cmd->params.twt_cfg;
+ struct nxpwifi_twt_setup *twt_setup;
+ struct nxpwifi_twt_teardown *twt_teardown;
+ struct nxpwifi_twt_report *twt_report;
+ struct nxpwifi_twt_information *twt_information;
+ struct nxpwifi_btwt_ap_config *btwt_ap_config;
+ u8 i;
+ u16 cmd_size;
+
+ cmd->command = cpu_to_le16(HOST_CMD_TWT_CFG);
+ cmd_size = sizeof(struct host_cmd_twt_cfg) + S_DS_GEN;
+
+ twt_cfg_cmd->action = cpu_to_le16(cmd_action);
+ twt_cfg_cmd->sub_id = cpu_to_le16(twt_cfg->sub_id);
+
+ switch (twt_cfg->sub_id) {
+ case NXPWIFI_11AX_TWT_SETUP_SUBID:
+ twt_setup = (struct nxpwifi_twt_setup *)
+ twt_cfg_cmd->val;
+
+ memset(twt_setup, 0x00, sizeof(struct nxpwifi_twt_setup));
+ twt_setup->implicit = twt_cfg->param.twt_setup.implicit;
+ twt_setup->announced = twt_cfg->param.twt_setup.announced;
+ twt_setup->trigger_enabled = twt_cfg->param.twt_setup.trigger_enabled;
+ twt_setup->twt_info_disabled = twt_cfg->param.twt_setup.twt_info_disabled;
+ twt_setup->negotiation_type = twt_cfg->param.twt_setup.negotiation_type;
+ twt_setup->twt_wakeup_duration =
+ twt_cfg->param.twt_setup.twt_wakeup_duration;
+ twt_setup->flow_identifier = twt_cfg->param.twt_setup.flow_identifier;
+ twt_setup->hard_constraint = twt_cfg->param.twt_setup.hard_constraint;
+ twt_setup->twt_exponent = twt_cfg->param.twt_setup.twt_exponent;
+ twt_setup->twt_mantissa = twt_cfg->param.twt_setup.twt_mantissa;
+ twt_setup->twt_request = twt_cfg->param.twt_setup.twt_request;
+ twt_setup->bcn_miss_threshold = twt_cfg->param.twt_setup.bcn_miss_threshold;
+ cmd_size += sizeof(struct nxpwifi_twt_setup);
+ break;
+ case NXPWIFI_11AX_TWT_TEARDOWN_SUBID:
+ twt_teardown = (struct nxpwifi_twt_teardown *)
+ twt_cfg_cmd->val;
+ memset(twt_teardown, 0x00,
+ sizeof(struct nxpwifi_twt_teardown));
+ twt_teardown->flow_identifier =
+ twt_cfg->param.twt_teardown.flow_identifier;
+ twt_teardown->negotiation_type =
+ twt_cfg->param.twt_teardown.negotiation_type;
+ twt_teardown->teardown_all_twt =
+ twt_cfg->param.twt_teardown.teardown_all_twt;
+ cmd_size += sizeof(struct nxpwifi_twt_teardown);
+ break;
+ case NXPWIFI_11AX_TWT_REPORT_SUBID:
+ twt_report = (struct nxpwifi_twt_report *)
+ twt_cfg_cmd->val;
+ memset(twt_report, 0x00, sizeof(struct nxpwifi_twt_report));
+ twt_report->type = twt_cfg->param.twt_report.type;
+ cmd_size += sizeof(struct nxpwifi_twt_report);
+ break;
+ case NXPWIFI_11AX_TWT_INFORMATION_SUBID:
+ twt_information = (struct nxpwifi_twt_information *)
+ twt_cfg_cmd->val;
+ memset(twt_information, 0x00,
+ sizeof(struct nxpwifi_twt_information));
+ twt_information->flow_identifier =
+ twt_cfg->param.twt_information.flow_identifier;
+ twt_information->suspend_duration =
+ twt_cfg->param.twt_information.suspend_duration;
+ cmd_size += sizeof(struct nxpwifi_twt_information);
+ break;
+ case NXPWIFI_11AX_BTWT_AP_CONFIG_SUBID:
+ btwt_ap_config = (struct nxpwifi_btwt_ap_config *)
+ twt_cfg_cmd->val;
+ memset(btwt_ap_config, 0x00,
+ sizeof(struct nxpwifi_btwt_ap_config));
+ btwt_ap_config->ap_bcast_bet_sta_wait =
+ twt_cfg->param.btwt_ap_config.ap_bcast_bet_sta_wait;
+ btwt_ap_config->ap_bcast_offset =
+ twt_cfg->param.btwt_ap_config.ap_bcast_offset;
+ btwt_ap_config->bcast_twtli =
+ twt_cfg->param.btwt_ap_config.bcast_twtli;
+ btwt_ap_config->count =
+ twt_cfg->param.btwt_ap_config.count;
+ for (i = 0; i < BTWT_AGREEMENT_MAX; i++) {
+ btwt_ap_config->btwt_sets[i].btwt_id =
+ twt_cfg->param.btwt_ap_config.btwt_sets[i].btwt_id;
+ btwt_ap_config->btwt_sets[i].ap_bcast_mantissa =
+ twt_cfg->param.btwt_ap_config.btwt_sets[i].ap_bcast_mantissa;
+ btwt_ap_config->btwt_sets[i].ap_bcast_exponent =
+ twt_cfg->param.btwt_ap_config.btwt_sets[i].ap_bcast_exponent;
+ btwt_ap_config->btwt_sets[i].nominalwake =
+ twt_cfg->param.btwt_ap_config.btwt_sets[i].nominalwake;
+ }
+
+ cmd_size += sizeof(struct nxpwifi_btwt_ap_config);
+ break;
+ default:
+ nxpwifi_dbg(adapter, ERROR,
+ "Unknown sub id: %d\n", twt_cfg->sub_id);
+ return -EINVAL;
+ }
+
+ cmd->size = cpu_to_le16(cmd_size);
+
+ return 0;
+}
+
+int nxpwifi_ret_twt_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_twt_cfg *twt_cfg)
+{
+ struct host_cmd_twt_cfg *twt_cfg_cmd = &resp->params.twt_cfg;
+ u16 action;
+
+ action = le16_to_cpu(twt_cfg_cmd->action);
+ twt_cfg->sub_id = le16_to_cpu(twt_cfg_cmd->sub_id);
+
+ if (action == HOST_ACT_GEN_GET &&
+ twt_cfg->sub_id == NXPWIFI_11AX_TWT_REPORT_SUBID) {
+ struct nxpwifi_twt_report *twt_report =
+ (struct nxpwifi_twt_report *)twt_cfg_cmd->val;
+
+ memcpy(&twt_cfg->param.twt_report, twt_report, sizeof(struct nxpwifi_twt_report));
+ }
+
+ return 0;
+}
diff --git a/drivers/net/wireless/nxp/nxpwifi/11ax.h b/drivers/net/wireless/nxp/nxpwifi/11ax.h
new file mode 100644
index 000000000000..2eda69f19763
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11ax.h
@@ -0,0 +1,73 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * nxpwifi: 802.11ax support
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#ifndef _NXPWIFI_11AX_H_
+#define _NXPWIFI_11AX_H_
+
+/* device support 2.4G 40MHZ */
+#define AX_2G_40MHZ_SUPPORT BIT(1)
+/* device support 2.4G 242 tone RUs */
+#define AX_2G_20MHZ_SUPPORT BIT(5)
+
+/* Get HE MCS map code for n spatial streams (0..3). */
+static inline u16
+nxpwifi_get_he_nss_mcs(__le16 mcs_map_set, int nss) {
+ return ((le16_to_cpu(mcs_map_set) >> (2 * (nss - 1))) & 0x3);
+}
+
+static inline void
+nxpwifi_set_he_nss_mcs(__le16 *mcs_map_set, int nss, int value) {
+ u16 temp;
+
+ temp = le16_to_cpu(*mcs_map_set);
+ temp |= ((value & 0x3) << (2 * (nss - 1)));
+ *mcs_map_set = cpu_to_le16(temp);
+}
+
+bool nxpwifi_is_11ax_twt_supported(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc);
+
+void nxpwifi_update_11ax_cap(struct nxpwifi_adapter *adapter,
+ struct hw_spec_extension *hw_he_cap);
+
+bool nxpwifi_11ax_bandconfig_allowed(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc);
+
+int nxpwifi_cmd_append_11ax_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer);
+
+int nxpwifi_fill_he_cap_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_ie_types_he_cap *he_cap,
+ u16 bands);
+int nxpwifi_cmd_11ax_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ax_he_cfg *ax_cfg);
+
+int nxpwifi_ret_11ax_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_11ax_he_cfg *ax_cfg);
+
+int nxpwifi_cmd_11ax_cmd(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ax_cmd_cfg *ax_cmd);
+
+int nxpwifi_ret_11ax_cmd(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_11ax_cmd_cfg *ax_cmd);
+
+int nxpwifi_cmd_twt_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_twt_cfg *twt_cfg);
+
+int nxpwifi_ret_twt_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp,
+ struct nxpwifi_twt_cfg *twt_cfg);
+
+u8 nxpwifi_is_sta_11ax_twt_req_supported(struct nxpwifi_private *priv);
+
+#endif /* _NXPWIFI_11AX_H_ */
--
2.34.1
^ permalink raw reply related
* [PATCH v11 03/22] wifi: nxpwifi: add initial 802.11ac support for STA and AP modes
From: Jeff Chen @ 2026-04-28 19:40 UTC (permalink / raw)
To: linux-wireless
Cc: linux-kernel, ulf.hansson, johannes, francesco, wyatt.hsu,
s.hauer, Jeff Chen
In-Reply-To: <20260428194021.785252-1-jeff.chen_1@nxp.com>
Add initial 802.11ac support for both station and AP roles, enabling
VHT capability negotiation and configuration through firmware assisted
commands.
For station mode, convert VHT elements from cfg80211 into firmware TLVs
and append them to HOST_CMD_802_11_ASSOCIATE. For AP mode, convert
VHT elements into parameters for HOST_CMD_11AC_CFG and pass them to the
firmware for configuration.
Handle VHT capabilities, VHT operation, and operating mode notification
elements to allow proper setup of 802.11ac features.
Signed-off-by: Jeff Chen <jeff.chen_1@nxp.com>
---
drivers/net/wireless/nxp/nxpwifi/11ac.c | 280 ++++++++++++++++++++++++
drivers/net/wireless/nxp/nxpwifi/11ac.h | 33 +++
2 files changed, 313 insertions(+)
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.h
diff --git a/drivers/net/wireless/nxp/nxpwifi/11ac.c b/drivers/net/wireless/nxp/nxpwifi/11ac.c
new file mode 100644
index 000000000000..117d06c35401
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11ac.c
@@ -0,0 +1,280 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * nxpwifi 802.11ac helpers
+ * Copyright 2011-2024 NXP
+ */
+
+#include "cfg.h"
+#include "fw.h"
+#include "main.h"
+#include "11ac.h"
+
+/* Map VHT MCS/NSS to highest data rate (Mbps), long GI. */
+static const u16 max_rate_lgi_80MHZ[8][3] = {
+ {0x124, 0x15F, 0x186}, /* NSS = 1 */
+ {0x249, 0x2BE, 0x30C}, /* NSS = 2 */
+ {0x36D, 0x41D, 0x492}, /* NSS = 3 */
+ {0x492, 0x57C, 0x618}, /* NSS = 4 */
+ {0x5B6, 0x6DB, 0x79E}, /* NSS = 5 */
+ {0x6DB, 0x83A, 0x0}, /* NSS = 6 */
+ {0x7FF, 0x999, 0xAAA}, /* NSS = 7 */
+ {0x924, 0xAF8, 0xC30} /* NSS = 8 */
+};
+
+static const u16 max_rate_lgi_160MHZ[8][3] = {
+ {0x249, 0x2BE, 0x30C}, /* NSS = 1 */
+ {0x492, 0x57C, 0x618}, /* NSS = 2 */
+ {0x6DB, 0x83A, 0x0}, /* NSS = 3 */
+ {0x924, 0xAF8, 0xC30}, /* NSS = 4 */
+ {0xB6D, 0xDB6, 0xF3C}, /* NSS = 5 */
+ {0xDB6, 0x1074, 0x1248}, /* NSS = 6 */
+ {0xFFF, 0x1332, 0x1554}, /* NSS = 7 */
+ {0x1248, 0x15F0, 0x1860} /* NSS = 8 */
+};
+
+/* Convert 2-bit MCS map to highest long-GI VHT data rate. */
+static u16
+nxpwifi_convert_mcsmap_to_maxrate(struct nxpwifi_private *priv,
+ u16 bands, u16 mcs_map)
+{
+ u8 i, nss, mcs;
+ u16 max_rate = 0;
+ u32 usr_vht_cap_info = 0;
+ struct nxpwifi_adapter *adapter = priv->adapter;
+
+ if (bands & BAND_AAC)
+ usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_a;
+ else
+ usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_bg;
+
+ /* Find max supported NSS. */
+ nss = 1;
+ for (i = 1; i <= 8; i++) {
+ mcs = GET_VHTNSSMCS(mcs_map, i);
+ if (mcs < IEEE80211_VHT_MCS_NOT_SUPPORTED)
+ nss = i;
+ }
+ mcs = GET_VHTNSSMCS(mcs_map, nss);
+
+ /* If not supported, fall back to 0-9. */
+ if (mcs == IEEE80211_VHT_MCS_NOT_SUPPORTED)
+ mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
+
+ if (u32_get_bits(usr_vht_cap_info, IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK)) {
+ /* Support 160 MHz. */
+ max_rate = max_rate_lgi_160MHZ[nss - 1][mcs];
+ if (!max_rate)
+ /* MCS9 not supported in NSS6. */
+ max_rate = max_rate_lgi_160MHZ[nss - 1][mcs - 1];
+ } else {
+ max_rate = max_rate_lgi_80MHZ[nss - 1][mcs];
+ if (!max_rate)
+ /* MCS9 not supported in NSS3. */
+ max_rate = max_rate_lgi_80MHZ[nss - 1][mcs - 1];
+ }
+
+ return max_rate;
+}
+
+static void
+nxpwifi_fill_vht_cap_info(struct nxpwifi_private *priv,
+ struct ieee80211_vht_cap *vht_cap, u16 bands)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+
+ if (bands & BAND_A)
+ vht_cap->vht_cap_info =
+ cpu_to_le32(adapter->usr_dot_11ac_dev_cap_a);
+ else
+ vht_cap->vht_cap_info =
+ cpu_to_le32(adapter->usr_dot_11ac_dev_cap_bg);
+}
+
+void
+nxpwifi_fill_vht_cap_tlv(struct nxpwifi_private *priv,
+ struct ieee80211_vht_cap *vht_cap, u16 bands)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ u16 mcs_map_user, mcs_map_resp, mcs_map_result;
+ u16 mcs_user, mcs_resp, nss, tmp;
+
+ /* Fill VHT capability info. */
+ nxpwifi_fill_vht_cap_info(priv, vht_cap, bands);
+
+ /* RX MCS set: min(user, AP). */
+ mcs_map_user = GET_DEVRXMCSMAP(adapter->usr_dot_11ac_mcs_support);
+ mcs_map_resp = le16_to_cpu(vht_cap->supp_mcs.rx_mcs_map);
+ mcs_map_result = 0;
+
+ for (nss = 1; nss <= 8; nss++) {
+ mcs_user = GET_VHTNSSMCS(mcs_map_user, nss);
+ mcs_resp = GET_VHTNSSMCS(mcs_map_resp, nss);
+
+ if (mcs_user == IEEE80211_VHT_MCS_NOT_SUPPORTED ||
+ mcs_resp == IEEE80211_VHT_MCS_NOT_SUPPORTED)
+ SET_VHTNSSMCS(mcs_map_result, nss,
+ IEEE80211_VHT_MCS_NOT_SUPPORTED);
+ else
+ SET_VHTNSSMCS(mcs_map_result, nss,
+ min(mcs_user, mcs_resp));
+ }
+
+ vht_cap->supp_mcs.rx_mcs_map = cpu_to_le16(mcs_map_result);
+
+ tmp = nxpwifi_convert_mcsmap_to_maxrate(priv, bands, mcs_map_result);
+ vht_cap->supp_mcs.rx_highest = cpu_to_le16(tmp);
+
+ /* TX MCS set: min(user, AP). */
+ mcs_map_user = GET_DEVTXMCSMAP(adapter->usr_dot_11ac_mcs_support);
+ mcs_map_resp = le16_to_cpu(vht_cap->supp_mcs.tx_mcs_map);
+ mcs_map_result = 0;
+
+ for (nss = 1; nss <= 8; nss++) {
+ mcs_user = GET_VHTNSSMCS(mcs_map_user, nss);
+ mcs_resp = GET_VHTNSSMCS(mcs_map_resp, nss);
+ if (mcs_user == IEEE80211_VHT_MCS_NOT_SUPPORTED ||
+ mcs_resp == IEEE80211_VHT_MCS_NOT_SUPPORTED)
+ SET_VHTNSSMCS(mcs_map_result, nss,
+ IEEE80211_VHT_MCS_NOT_SUPPORTED);
+ else
+ SET_VHTNSSMCS(mcs_map_result, nss,
+ min(mcs_user, mcs_resp));
+ }
+
+ vht_cap->supp_mcs.tx_mcs_map = cpu_to_le16(mcs_map_result);
+
+ tmp = nxpwifi_convert_mcsmap_to_maxrate(priv, bands, mcs_map_result);
+ vht_cap->supp_mcs.tx_highest = cpu_to_le16(tmp);
+}
+
+int nxpwifi_cmd_append_11ac_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer)
+{
+ struct nxpwifi_ie_types_vhtcap *vht_cap;
+ struct nxpwifi_ie_types_oper_mode_ntf *oper_ntf;
+ struct ieee_types_oper_mode_ntf *ieee_oper_ntf;
+ struct nxpwifi_ie_types_vht_oper *vht_op;
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ u8 supp_chwd_set;
+ u32 usr_vht_cap_info;
+ int ret_len = 0;
+
+ if (bss_desc->bss_band & BAND_A)
+ usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_a;
+ else
+ usr_vht_cap_info = adapter->usr_dot_11ac_dev_cap_bg;
+
+ /* VHT Capabilities element. */
+ if (bss_desc->bcn_vht_cap) {
+ vht_cap = (struct nxpwifi_ie_types_vhtcap *)*buffer;
+ memset(vht_cap, 0, sizeof(*vht_cap));
+ vht_cap->header.type = cpu_to_le16(WLAN_EID_VHT_CAPABILITY);
+ vht_cap->header.len =
+ cpu_to_le16(sizeof(struct ieee80211_vht_cap));
+ memcpy((u8 *)vht_cap + sizeof(struct nxpwifi_ie_types_header),
+ (u8 *)bss_desc->bcn_vht_cap,
+ le16_to_cpu(vht_cap->header.len));
+
+ nxpwifi_fill_vht_cap_tlv(priv, &vht_cap->vht_cap,
+ bss_desc->bss_band);
+ *buffer += sizeof(*vht_cap);
+ ret_len += sizeof(*vht_cap);
+ }
+
+ /* VHT Operation element. */
+ if (bss_desc->bcn_vht_oper) {
+ if (priv->bss_mode == NL80211_IFTYPE_STATION) {
+ vht_op = (struct nxpwifi_ie_types_vht_oper *)*buffer;
+ memset(vht_op, 0, sizeof(*vht_op));
+ vht_op->header.type =
+ cpu_to_le16(WLAN_EID_VHT_OPERATION);
+ vht_op->header.len = cpu_to_le16(sizeof(*vht_op) -
+ sizeof(struct nxpwifi_ie_types_header));
+ memcpy((u8 *)vht_op +
+ sizeof(struct nxpwifi_ie_types_header),
+ (u8 *)bss_desc->bcn_vht_oper,
+ le16_to_cpu(vht_op->header.len));
+
+ /* Negotiate channel width; keep peer's center freq. */
+ supp_chwd_set = u32_get_bits(usr_vht_cap_info,
+ IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK);
+
+ switch (supp_chwd_set) {
+ case 0:
+ vht_op->chan_width =
+ min_t(u8, IEEE80211_VHT_CHANWIDTH_80MHZ,
+ bss_desc->bcn_vht_oper->chan_width);
+ break;
+ case 1:
+ vht_op->chan_width =
+ min_t(u8, IEEE80211_VHT_CHANWIDTH_160MHZ,
+ bss_desc->bcn_vht_oper->chan_width);
+ break;
+ case 2:
+ vht_op->chan_width =
+ min_t(u8, IEEE80211_VHT_CHANWIDTH_80P80MHZ,
+ bss_desc->bcn_vht_oper->chan_width);
+ break;
+ default:
+ vht_op->chan_width =
+ IEEE80211_VHT_CHANWIDTH_USE_HT;
+ break;
+ }
+
+ *buffer += sizeof(*vht_op);
+ ret_len += sizeof(*vht_op);
+ }
+ }
+
+ /* Operating Mode Notification element. */
+ if (bss_desc->oper_mode) {
+ ieee_oper_ntf = bss_desc->oper_mode;
+ oper_ntf = (void *)*buffer;
+ memset(oper_ntf, 0, sizeof(*oper_ntf));
+ oper_ntf->header.type = cpu_to_le16(WLAN_EID_OPMODE_NOTIF);
+ oper_ntf->header.len = cpu_to_le16(sizeof(u8));
+ oper_ntf->oper_mode = ieee_oper_ntf->oper_mode;
+ *buffer += sizeof(*oper_ntf);
+ ret_len += sizeof(*oper_ntf);
+ }
+
+ return ret_len;
+}
+
+int nxpwifi_cmd_11ac_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ac_vht_cfg *cfg)
+{
+ struct host_cmd_11ac_vht_cfg *vhtcfg = &cmd->params.vht_cfg;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11AC_CFG);
+ cmd->size = cpu_to_le16(sizeof(struct host_cmd_11ac_vht_cfg) +
+ S_DS_GEN);
+ vhtcfg->action = cpu_to_le16(cmd_action);
+ vhtcfg->band_config = cfg->band_config;
+ vhtcfg->misc_config = cfg->misc_config;
+ vhtcfg->cap_info = cpu_to_le32(cfg->cap_info);
+ vhtcfg->mcs_tx_set = cpu_to_le32(cfg->mcs_tx_set);
+ vhtcfg->mcs_rx_set = cpu_to_le32(cfg->mcs_rx_set);
+
+ return 0;
+}
+
+/* Initialize BlockAck parameters for 11ac. */
+void nxpwifi_set_11ac_ba_params(struct nxpwifi_private *priv)
+{
+ priv->add_ba_param.timeout = NXPWIFI_DEFAULT_BLOCK_ACK_TIMEOUT;
+
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_UAP) {
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_11AC_UAP_AMPDU_DEF_TXWINSIZE;
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_11AC_UAP_AMPDU_DEF_RXWINSIZE;
+ } else {
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_11AC_STA_AMPDU_DEF_TXWINSIZE;
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_11AC_STA_AMPDU_DEF_RXWINSIZE;
+ }
+}
diff --git a/drivers/net/wireless/nxp/nxpwifi/11ac.h b/drivers/net/wireless/nxp/nxpwifi/11ac.h
new file mode 100644
index 000000000000..edc01b35d5b8
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11ac.h
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * nxpwifi: 802.11ac (VHT) definitions
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#ifndef _NXPWIFI_11AC_H_
+#define _NXPWIFI_11AC_H_
+
+#define VHT_CFG_2GHZ BIT(0)
+#define VHT_CFG_5GHZ BIT(1)
+
+enum vht_cfg_misc_config {
+ VHT_CAP_TX_OPERATION = 1,
+ VHT_CAP_ASSOCIATION,
+ VHT_CAP_UAP_ONLY
+};
+
+#define DEFAULT_VHT_MCS_SET 0xfffe
+#define DISABLE_VHT_MCS_SET 0xffff
+
+#define VHT_BW_80_160_80P80 BIT(2)
+
+int nxpwifi_cmd_append_11ac_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer);
+int nxpwifi_cmd_11ac_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_11ac_vht_cfg *cfg);
+void nxpwifi_fill_vht_cap_tlv(struct nxpwifi_private *priv,
+ struct ieee80211_vht_cap *vht_cap, u16 bands);
+#endif /* _NXPWIFI_11AC_H_ */
--
2.34.1
^ permalink raw reply related
* [PATCH v11 02/22] wifi: nxpwifi: add 802.11n support for STA and AP modes
From: Jeff Chen @ 2026-04-28 19:40 UTC (permalink / raw)
To: linux-wireless
Cc: linux-kernel, ulf.hansson, johannes, francesco, wyatt.hsu,
s.hauer, Jeff Chen
In-Reply-To: <20260428194021.785252-1-jeff.chen_1@nxp.com>
Add 802.11n capability support for both station and AP roles.
Convert HT elements from cfg80211 into firmware TLVs and append them to
HOST_CMD_802_11_ASSOCIATE when operating as a station. Generate the
corresponding HT elements for HOST_CMD_UAP_SYS_CONFIG when operating as
an AP.
Implement AMSDU aggregation and blockack reorder buffer handling in the
driver due to firmware resource limitations.
Add the required logic and files to enable 802.11n functionality across
both roles.
Signed-off-by: Jeff Chen <jeff.chen_1@nxp.com>
---
drivers/net/wireless/nxp/nxpwifi/11n.c | 837 ++++++++++++++++++
drivers/net/wireless/nxp/nxpwifi/11n.h | 158 ++++
drivers/net/wireless/nxp/nxpwifi/11n_aggr.c | 251 ++++++
drivers/net/wireless/nxp/nxpwifi/11n_aggr.h | 21 +
.../net/wireless/nxp/nxpwifi/11n_rxreorder.c | 826 +++++++++++++++++
.../net/wireless/nxp/nxpwifi/11n_rxreorder.h | 71 ++
6 files changed, 2164 insertions(+)
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n.c b/drivers/net/wireless/nxp/nxpwifi/11n.c
new file mode 100644
index 000000000000..e46c5053d509
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n.c
@@ -0,0 +1,837 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * nxpwifi 802.11n helpers
+ * Copyright 2011-2024 NXP
+ */
+
+#include "cfg.h"
+#include "util.h"
+#include "fw.h"
+#include "main.h"
+#include "cmdevt.h"
+#include "wmm.h"
+#include "11n.h"
+#include "11ax.h"
+
+/*
+ * Fills HT capability information field, AMPDU Parameters field, HT extended
+ * capability field, and supported MCS set fields.
+ *
+ * HT capability information field, AMPDU Parameters field, supported MCS set
+ * fields are retrieved from cfg80211 stack
+ *
+ * RD responder bit to set to clear in the extended capability header.
+ */
+int nxpwifi_fill_cap_info(struct nxpwifi_private *priv, u8 radio_type,
+ struct ieee80211_ht_cap *ht_cap)
+{
+ u16 ht_cap_info;
+ u16 bcn_ht_cap = le16_to_cpu(ht_cap->cap_info);
+ u16 ht_ext_cap = le16_to_cpu(ht_cap->extended_ht_cap_info);
+ struct ieee80211_supported_band *sband =
+ priv->wdev.wiphy->bands[radio_type];
+
+ if (WARN_ON_ONCE(!sband)) {
+ nxpwifi_dbg(priv->adapter, ERROR, "Invalid radio type!\n");
+ return -EINVAL;
+ }
+
+ ht_cap->ampdu_params_info =
+ (AMPDU_FACTOR_64K & IEEE80211_HT_AMPDU_PARM_FACTOR) |
+ ((priv->adapter->hw_mpdu_density <<
+ IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT) &
+ IEEE80211_HT_AMPDU_PARM_DENSITY);
+
+ memcpy((u8 *)&ht_cap->mcs, &sband->ht_cap.mcs,
+ sizeof(sband->ht_cap.mcs));
+
+ if (priv->bss_mode == NL80211_IFTYPE_STATION ||
+ (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
+ priv->adapter->sec_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_NONE))
+ /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
+ SETHT_MCS32(ht_cap->mcs.rx_mask);
+
+ /* Clear RD responder bit */
+ ht_ext_cap &= ~IEEE80211_HT_EXT_CAP_RD_RESPONDER;
+
+ ht_cap_info = sband->ht_cap.cap;
+ if (bcn_ht_cap) {
+ if (!(bcn_ht_cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40))
+ ht_cap_info &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
+ if (!(bcn_ht_cap & IEEE80211_HT_CAP_SGI_40))
+ ht_cap_info &= ~IEEE80211_HT_CAP_SGI_40;
+ if (!(bcn_ht_cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
+ ht_cap_info &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT;
+ }
+ ht_cap->cap_info = cpu_to_le16(ht_cap_info);
+ ht_cap->extended_ht_cap_info = cpu_to_le16(ht_ext_cap);
+
+ if (ISSUPP_BEAMFORMING(priv->adapter->hw_dot_11n_dev_cap))
+ ht_cap->tx_BF_cap_info = cpu_to_le32(NXPWIFI_DEF_11N_TX_BF_CAP);
+
+ return 0;
+}
+
+/* Return BA stream entry that matches the requested status. */
+static struct nxpwifi_tx_ba_stream_tbl *
+nxpwifi_get_ba_status(struct nxpwifi_private *priv, int tid,
+ enum nxpwifi_ba_status ba_status)
+{
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl, *found = NULL;
+
+ guard(rcu)();
+ list_for_each_entry_rcu(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr[tid], list) {
+ if (tx_ba_tsr_tbl->ba_status == ba_status) {
+ found = tx_ba_tsr_tbl;
+ break;
+ }
+ }
+ return found;
+}
+
+/* Handle DELBA command response (recreate or continue ADDBA as needed). */
+int nxpwifi_ret_11n_delba(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp)
+{
+ int tid;
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tbl;
+ struct host_cmd_ds_11n_delba *del_ba = &resp->params.del_ba;
+ u16 del_ba_param_set = le16_to_cpu(del_ba->del_ba_param_set);
+
+ tid = del_ba_param_set >> DELBA_TID_POS;
+ if (del_ba->del_result == BA_RESULT_SUCCESS) {
+ nxpwifi_del_ba_tbl(priv, tid, del_ba->peer_mac_addr,
+ TYPE_DELBA_SENT,
+ INITIATOR_BIT(del_ba_param_set));
+
+ tx_ba_tbl = nxpwifi_get_ba_status(priv, tid, BA_SETUP_INPROGRESS);
+ if (tx_ba_tbl)
+ nxpwifi_send_addba(priv, tx_ba_tbl->tid,
+ tx_ba_tbl->ra);
+ } else {
+ /*
+ * In case of failure, recreate the deleted stream in case
+ * we initiated the DELBA
+ */
+ if (!INITIATOR_BIT(del_ba_param_set))
+ return 0;
+
+ nxpwifi_create_ba_tbl(priv, del_ba->peer_mac_addr, tid,
+ BA_SETUP_INPROGRESS);
+
+ tx_ba_tbl = nxpwifi_get_ba_status(priv, tid, BA_SETUP_INPROGRESS);
+
+ if (tx_ba_tbl)
+ nxpwifi_del_ba_tbl(priv, tx_ba_tbl->tid, tx_ba_tbl->ra,
+ TYPE_DELBA_SENT, true);
+ }
+
+ return 0;
+}
+
+/* Handle ADDBA response; delete BA stream on failure. */
+int nxpwifi_ret_11n_addba_req(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp)
+{
+ int tid, tid_down;
+ struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &resp->params.add_ba_rsp;
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tbl;
+ struct nxpwifi_ra_list_tbl *ra_list;
+ u16 block_ack_param_set = le16_to_cpu(add_ba_rsp->block_ack_param_set);
+
+ add_ba_rsp->ssn = cpu_to_le16((le16_to_cpu(add_ba_rsp->ssn))
+ & SSN_MASK);
+
+ tid = u16_get_bits(block_ack_param_set, IEEE80211_ADDBA_PARAM_TID_MASK);
+
+ tid_down = nxpwifi_wmm_downgrade_tid(priv, tid);
+ ra_list = nxpwifi_wmm_get_ralist_node(priv, tid_down,
+ add_ba_rsp->peer_mac_addr);
+ if (le16_to_cpu(add_ba_rsp->status_code) != BA_RESULT_SUCCESS) {
+ if (ra_list) {
+ ra_list->ba_status = BA_SETUP_NONE;
+ ra_list->amsdu_in_ampdu = false;
+ }
+ nxpwifi_del_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr,
+ TYPE_DELBA_SENT, true);
+ if (add_ba_rsp->add_rsp_result != BA_RESULT_TIMEOUT)
+ priv->aggr_prio_tbl[tid].ampdu_ap =
+ BA_STREAM_NOT_ALLOWED;
+ return 0;
+ }
+
+ guard(rcu)();
+ tx_ba_tbl = nxpwifi_get_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr);
+ if (tx_ba_tbl) {
+ nxpwifi_dbg(priv->adapter, EVENT, "info: BA stream complete\n");
+ tx_ba_tbl->ba_status = BA_SETUP_COMPLETE;
+ if ((block_ack_param_set & IEEE80211_ADDBA_PARAM_AMSDU_MASK) &&
+ priv->add_ba_param.tx_amsdu &&
+ priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED)
+ tx_ba_tbl->amsdu = true;
+ else
+ tx_ba_tbl->amsdu = false;
+ if (ra_list) {
+ ra_list->amsdu_in_ampdu = tx_ba_tbl->amsdu;
+ ra_list->ba_status = BA_SETUP_COMPLETE;
+ }
+ } else {
+ nxpwifi_dbg(priv->adapter, ERROR, "BA stream not created\n");
+ }
+
+ return 0;
+}
+
+/*
+ * Reconfigure Tx buffer command.
+ * Set command ID/action/size; set Tx buffer size on SET; ensure little-endian.
+ */
+int nxpwifi_cmd_recfg_tx_buf(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, int cmd_action,
+ u16 *buf_size)
+{
+ struct host_cmd_ds_txbuf_cfg *tx_buf = &cmd->params.tx_buf;
+ u16 action = (u16)cmd_action;
+
+ cmd->command = cpu_to_le16(HOST_CMD_RECONFIGURE_TX_BUFF);
+ cmd->size =
+ cpu_to_le16(sizeof(struct host_cmd_ds_txbuf_cfg) + S_DS_GEN);
+ tx_buf->action = cpu_to_le16(action);
+ switch (action) {
+ case HOST_ACT_GEN_SET:
+ nxpwifi_dbg(priv->adapter, CMD,
+ "cmd: set tx_buf=%d\n", *buf_size);
+ tx_buf->buff_size = cpu_to_le16(*buf_size);
+ break;
+ case HOST_ACT_GEN_GET:
+ default:
+ tx_buf->buff_size = 0;
+ break;
+ }
+ return 0;
+}
+
+/*
+ * AMSDU aggregation control command.
+ * Set ID/action/size; set AMSDU params on SET; ensure little-endian.
+ */
+int nxpwifi_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command *cmd,
+ int cmd_action,
+ struct nxpwifi_ds_11n_amsdu_aggr_ctrl *aa_ctrl)
+{
+ struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl =
+ &cmd->params.amsdu_aggr_ctrl;
+ u16 action = (u16)cmd_action;
+
+ cmd->command = cpu_to_le16(HOST_CMD_AMSDU_AGGR_CTRL);
+ cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_amsdu_aggr_ctrl)
+ + S_DS_GEN);
+ amsdu_ctrl->action = cpu_to_le16(action);
+ switch (action) {
+ case HOST_ACT_GEN_SET:
+ amsdu_ctrl->enable = cpu_to_le16(aa_ctrl->enable);
+ amsdu_ctrl->curr_buf_size = 0;
+ break;
+ case HOST_ACT_GEN_GET:
+ default:
+ amsdu_ctrl->curr_buf_size = 0;
+ break;
+ }
+ return 0;
+}
+
+/*
+ * 11n configuration command.
+ * Set action, HT Tx capability/info, and misc config when 11ac HW is present.
+ */
+int nxpwifi_cmd_11n_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_ds_11n_tx_cfg *txcfg)
+{
+ struct host_cmd_ds_11n_cfg *htcfg = &cmd->params.htcfg;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11N_CFG);
+ cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_11n_cfg) + S_DS_GEN);
+ htcfg->action = cpu_to_le16(cmd_action);
+ htcfg->ht_tx_cap = cpu_to_le16(txcfg->tx_htcap);
+ htcfg->ht_tx_info = cpu_to_le16(txcfg->tx_htinfo);
+
+ if (priv->adapter->is_hw_11ac_capable)
+ htcfg->misc_config = cpu_to_le16(txcfg->misc_config);
+
+ return 0;
+}
+
+/*
+ * Append 11n TLVs to the caller-owned buffer.
+ * Caller allocates space; no size checks here.
+ * May add: HT Cap, HT Operation + channel list, 20/40 BSS Coexistence,
+ * and Extended Capabilities (HS2/TWT bits when applicable).
+ */
+int
+nxpwifi_cmd_append_11n_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer)
+{
+ struct nxpwifi_ie_types_htcap *ht_cap;
+ struct nxpwifi_ie_types_chan_list_param_set *chan_list;
+ struct nxpwifi_chan_scan_param_set *chan_param;
+ struct nxpwifi_ie_types_2040bssco *bss_co_2040;
+ struct nxpwifi_ie_types_extcap *ext_cap;
+ int ret_len = 0;
+ struct ieee80211_supported_band *sband;
+ struct element *hdr;
+ u8 radio_type;
+
+ if (!buffer || !*buffer)
+ return ret_len;
+
+ radio_type = nxpwifi_band_to_radio_type((u8)bss_desc->bss_band);
+ sband = priv->wdev.wiphy->bands[radio_type];
+
+ if (bss_desc->bcn_ht_cap) {
+ ht_cap = (struct nxpwifi_ie_types_htcap *)*buffer;
+ memset(ht_cap, 0, sizeof(struct nxpwifi_ie_types_htcap));
+ ht_cap->header.type = cpu_to_le16(WLAN_EID_HT_CAPABILITY);
+ ht_cap->header.len =
+ cpu_to_le16(sizeof(struct ieee80211_ht_cap));
+ memcpy((u8 *)ht_cap + sizeof(struct nxpwifi_ie_types_header),
+ (u8 *)bss_desc->bcn_ht_cap,
+ le16_to_cpu(ht_cap->header.len));
+
+ nxpwifi_fill_cap_info(priv, radio_type, &ht_cap->ht_cap);
+ /* Update HT40 capability from current channel. */
+ if (bss_desc->bcn_ht_oper) {
+ u8 ht_param = bss_desc->bcn_ht_oper->ht_param;
+ u8 radio =
+ nxpwifi_band_to_radio_type(bss_desc->bss_band);
+ int freq =
+ ieee80211_channel_to_frequency(bss_desc->channel,
+ radio);
+ struct ieee80211_channel *chan =
+ ieee80211_get_channel(priv->adapter->wiphy, freq);
+
+ switch (ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
+ case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
+ if (chan->flags & IEEE80211_CHAN_NO_HT40PLUS) {
+ ht_cap->ht_cap.cap_info &=
+ cpu_to_le16
+ (~IEEE80211_HT_CAP_SUP_WIDTH_20_40);
+ ht_cap->ht_cap.cap_info &=
+ cpu_to_le16(~IEEE80211_HT_CAP_SGI_40);
+ }
+ break;
+ case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
+ if (chan->flags & IEEE80211_CHAN_NO_HT40MINUS) {
+ ht_cap->ht_cap.cap_info &=
+ cpu_to_le16
+ (~IEEE80211_HT_CAP_SUP_WIDTH_20_40);
+ ht_cap->ht_cap.cap_info &=
+ cpu_to_le16(~IEEE80211_HT_CAP_SGI_40);
+ }
+ break;
+ }
+ }
+
+ *buffer += sizeof(struct nxpwifi_ie_types_htcap);
+ ret_len += sizeof(struct nxpwifi_ie_types_htcap);
+ }
+
+ if (bss_desc->bcn_ht_oper) {
+ chan_list =
+ (struct nxpwifi_ie_types_chan_list_param_set *)*buffer;
+ chan_param = chan_list->chan_scan_param;
+ memset(chan_list, 0, struct_size(chan_list, chan_scan_param, 1));
+ chan_list->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
+ chan_list->header.len = cpu_to_le16(sizeof(*chan_param));
+ chan_param->chan_number = bss_desc->bcn_ht_oper->primary_chan;
+ chan_param->band_cfg =
+ nxpwifi_band_to_radio_type((u8)bss_desc->bss_band);
+
+ if (ISSUPP_11ACENABLED(priv->adapter->fw_cap_info) &&
+ bss_desc->bcn_vht_oper &&
+ bss_desc->bcn_vht_oper->chan_width ==
+ IEEE80211_VHT_CHANWIDTH_80MHZ) {
+ SET_SECONDARYCHAN(chan_param->band_cfg,
+ (bss_desc->bcn_ht_oper->ht_param &
+ IEEE80211_HT_PARAM_CHA_SEC_OFFSET));
+ chan_param->band_cfg |=
+ ((CHAN_BW_80MHZ <<
+ BAND_CFG_CHAN_WIDTH_SHIFT_BIT) &
+ BAND_CFG_CHAN_WIDTH_MASK);
+ } else if (sband->ht_cap.cap &
+ IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
+ bss_desc->bcn_ht_oper->ht_param &
+ IEEE80211_HT_PARAM_CHAN_WIDTH_ANY) {
+ SET_SECONDARYCHAN(chan_param->band_cfg,
+ (bss_desc->bcn_ht_oper->ht_param &
+ IEEE80211_HT_PARAM_CHA_SEC_OFFSET));
+ chan_param->band_cfg |=
+ ((CHAN_BW_40MHZ <<
+ BAND_CFG_CHAN_WIDTH_SHIFT_BIT) &
+ BAND_CFG_CHAN_WIDTH_MASK);
+ }
+
+ *buffer += struct_size(chan_list, chan_scan_param, 1);
+ ret_len += struct_size(chan_list, chan_scan_param, 1);
+ }
+
+ if (bss_desc->bcn_bss_co_2040) {
+ bss_co_2040 = (struct nxpwifi_ie_types_2040bssco *)*buffer;
+ memset(bss_co_2040, 0,
+ sizeof(struct nxpwifi_ie_types_2040bssco));
+ bss_co_2040->header.type = cpu_to_le16(WLAN_EID_BSS_COEX_2040);
+ bss_co_2040->header.len =
+ cpu_to_le16(sizeof(bss_co_2040->bss_co_2040));
+
+ memcpy((u8 *)bss_co_2040 +
+ sizeof(struct nxpwifi_ie_types_header),
+ bss_desc->bcn_bss_co_2040 +
+ sizeof(struct element),
+ le16_to_cpu(bss_co_2040->header.len));
+
+ *buffer += sizeof(struct nxpwifi_ie_types_2040bssco);
+ ret_len += sizeof(struct nxpwifi_ie_types_2040bssco);
+ }
+
+ if (bss_desc->bcn_ext_cap) {
+ u8 *ext_capab;
+
+ hdr = (void *)bss_desc->bcn_ext_cap;
+
+ ext_capab = (u8 *)cfg80211_find_ie(WLAN_EID_EXT_CAPABILITY, priv->gen_ie_buf,
+ priv->gen_ie_buf_len);
+ if (ext_capab) {
+ ext_capab += 2;
+ } else {
+ ext_cap = (struct nxpwifi_ie_types_extcap *)*buffer;
+ memset(ext_cap, 0, sizeof(struct nxpwifi_ie_types_extcap) + hdr->datalen);
+ ext_cap->header.type = cpu_to_le16(WLAN_EID_EXT_CAPABILITY);
+ ext_cap->header.len = cpu_to_le16(hdr->datalen);
+ ext_capab = ext_cap->ext_capab;
+ *buffer += sizeof(struct nxpwifi_ie_types_extcap) + hdr->datalen;
+ ret_len += sizeof(struct nxpwifi_ie_types_extcap) + hdr->datalen;
+ }
+
+ if (hdr->datalen > 3 &&
+ ext_capab[3] & WLAN_EXT_CAPA4_INTERWORKING_ENABLED)
+ priv->hs2_enabled = true;
+ else
+ priv->hs2_enabled = false;
+
+ if (nxpwifi_is_11ax_twt_supported(priv, bss_desc))
+ ext_capab[9] |=
+ WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT;
+ }
+ return ret_len;
+}
+
+/* Check if pointer is a valid Tx BA stream entry. */
+static bool
+nxpwifi_is_tx_ba_stream_ptr_valid(struct nxpwifi_private *priv,
+ struct nxpwifi_tx_ba_stream_tbl *tx_tbl_ptr)
+{
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl;
+ bool ret = false;
+ int tid;
+
+ tid = tx_tbl_ptr->tid;
+ guard(rcu)();
+ list_for_each_entry_rcu(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr[tid], list) {
+ if (tx_ba_tsr_tbl == tx_tbl_ptr) {
+ ret = true;
+ break;
+ }
+ }
+ return ret;
+}
+
+/* Delete a Tx BA stream entry (after validating pointer). */
+void
+nxpwifi_11n_delete_tx_ba_stream_tbl_entry(struct nxpwifi_private *priv,
+ struct nxpwifi_tx_ba_stream_tbl *tbl)
+{
+ if (!tbl && nxpwifi_is_tx_ba_stream_ptr_valid(priv, tbl))
+ return;
+
+ nxpwifi_dbg(priv->adapter, INFO,
+ "info: tx_ba_tsr_tbl %p\n", tbl);
+
+ list_del_rcu(&tbl->list);
+ kfree_rcu(tbl, rcu);
+}
+
+/* Delete all entries in Tx BA stream table. */
+void nxpwifi_11n_delete_all_tx_ba_stream_tbl(struct nxpwifi_private *priv)
+{
+ int i;
+ struct nxpwifi_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node;
+
+ for (i = 0; i < MAX_NUM_TID; i++) {
+ spin_lock_bh(&priv->tx_ba_stream_tbl_lock[i]);
+ list_for_each_entry_safe(del_tbl_ptr, tmp_node,
+ &priv->tx_ba_stream_tbl_ptr[i], list)
+ nxpwifi_11n_delete_tx_ba_stream_tbl_entry(priv, del_tbl_ptr);
+ spin_unlock_bh(&priv->tx_ba_stream_tbl_lock[i]);
+
+ INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr[i]);
+
+ priv->aggr_prio_tbl[i].ampdu_ap =
+ priv->aggr_prio_tbl[i].ampdu_user;
+ }
+}
+
+/* Return BA stream entry for given RA/TID. */
+struct nxpwifi_tx_ba_stream_tbl *
+nxpwifi_get_ba_tbl(struct nxpwifi_private *priv, int tid, u8 *ra)
+{
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl = NULL;
+
+ list_for_each_entry_rcu(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr[tid], list) {
+ if (ether_addr_equal_unaligned(tx_ba_tsr_tbl->ra, ra) &&
+ tx_ba_tsr_tbl->tid == tid)
+ return tx_ba_tsr_tbl;
+ }
+ return NULL;
+}
+
+/* Create Tx BA stream entry for given RA/TID. */
+void nxpwifi_create_ba_tbl(struct nxpwifi_private *priv, u8 *ra, int tid,
+ enum nxpwifi_ba_status ba_status)
+{
+ struct nxpwifi_tx_ba_stream_tbl *new_node;
+ struct nxpwifi_ra_list_tbl *ra_list;
+ int tid_down;
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tbl;
+
+ guard(rcu)();
+ tx_ba_tbl = nxpwifi_get_ba_tbl(priv, tid, ra);
+
+ if (!tx_ba_tbl) {
+ new_node = kzalloc_obj(*new_node, GFP_ATOMIC);
+ if (!new_node)
+ return;
+
+ tid_down = nxpwifi_wmm_downgrade_tid(priv, tid);
+ ra_list = nxpwifi_wmm_get_ralist_node(priv, tid_down, ra);
+ if (ra_list) {
+ ra_list->ba_status = ba_status;
+ ra_list->amsdu_in_ampdu = false;
+ }
+ INIT_LIST_HEAD(&new_node->list);
+
+ new_node->tid = tid;
+ new_node->ba_status = ba_status;
+ memcpy(new_node->ra, ra, ETH_ALEN);
+
+ spin_lock_bh(&priv->tx_ba_stream_tbl_lock[tid]);
+ list_add_tail_rcu(&new_node->list, &priv->tx_ba_stream_tbl_ptr[tid]);
+ spin_unlock_bh(&priv->tx_ba_stream_tbl_lock[tid]);
+ }
+}
+
+/* Send ADDBA request to the given TID/RA. */
+int nxpwifi_send_addba(struct nxpwifi_private *priv, int tid, u8 *peer_mac)
+{
+ struct host_cmd_ds_11n_addba_req add_ba_req;
+ u32 tx_win_size = priv->add_ba_param.tx_win_size;
+ static u8 dialog_tok;
+ u16 block_ack_param_set;
+
+ nxpwifi_dbg(priv->adapter, CMD, "cmd: %s: tid %d\n", __func__, tid);
+
+ memset(&add_ba_req, 0, sizeof(add_ba_req));
+
+ block_ack_param_set = (u16)((tid << BLOCKACKPARAM_TID_POS) |
+ tx_win_size << BLOCKACKPARAM_WINSIZE_POS |
+ IMMEDIATE_BLOCK_ACK);
+
+ /* enable AMSDU inside AMPDU */
+ if (priv->add_ba_param.tx_amsdu &&
+ priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED)
+ block_ack_param_set |= IEEE80211_ADDBA_PARAM_AMSDU_MASK;
+
+ add_ba_req.block_ack_param_set = cpu_to_le16(block_ack_param_set);
+ add_ba_req.block_ack_tmo = cpu_to_le16((u16)priv->add_ba_param.timeout);
+
+ ++dialog_tok;
+
+ if (dialog_tok == 0)
+ dialog_tok = 1;
+
+ add_ba_req.dialog_token = dialog_tok;
+ memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN);
+
+ /* We don't wait for the response of this command */
+ return nxpwifi_send_cmd(priv, HOST_CMD_11N_ADDBA_REQ,
+ 0, 0, &add_ba_req, false);
+}
+
+/* Send DELBA request to the given TID/RA. */
+int nxpwifi_send_delba(struct nxpwifi_private *priv, int tid, u8 *peer_mac,
+ int initiator)
+{
+ struct host_cmd_ds_11n_delba delba;
+ u16 del_ba_param_set;
+
+ memset(&delba, 0, sizeof(delba));
+
+ del_ba_param_set = tid << DELBA_TID_POS;
+
+ if (initiator)
+ del_ba_param_set |= IEEE80211_DELBA_PARAM_INITIATOR_MASK;
+ else
+ del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK;
+
+ delba.del_ba_param_set = cpu_to_le16(del_ba_param_set);
+ memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN);
+
+ /* We don't wait for the response of this command */
+ return nxpwifi_send_cmd(priv, HOST_CMD_11N_DELBA,
+ HOST_ACT_GEN_SET, 0, &delba, false);
+}
+
+/* Send DELBA to specific TID. */
+void nxpwifi_11n_delba(struct nxpwifi_private *priv, int tid)
+{
+ struct nxpwifi_rx_reorder_tbl *rx_reor_tbl_ptr;
+ u8 ta[ETH_ALEN];
+ bool found = false;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(rx_reor_tbl_ptr, &priv->rx_reorder_tbl_ptr[tid], list) {
+ if (rx_reor_tbl_ptr->tid == tid) {
+ memcpy(ta, rx_reor_tbl_ptr->ta, ETH_ALEN);
+ found = true;
+ break;
+ }
+ }
+ rcu_read_unlock();
+
+ if (found) {
+ nxpwifi_dbg(priv->adapter, INFO,
+ "Send delba to tid=%d, %pM\n", tid, ta);
+ nxpwifi_send_delba(priv, tid, ta, 0);
+ }
+}
+
+/* Handle DELBA event; remove BA stream. */
+void nxpwifi_11n_delete_ba_stream(struct nxpwifi_private *priv, u8 *del_ba)
+{
+ struct host_cmd_ds_11n_delba *cmd_del_ba =
+ (struct host_cmd_ds_11n_delba *)del_ba;
+ u16 del_ba_param_set = le16_to_cpu(cmd_del_ba->del_ba_param_set);
+ int tid;
+
+ tid = del_ba_param_set >> DELBA_TID_POS;
+
+ nxpwifi_del_ba_tbl(priv, tid, cmd_del_ba->peer_mac_addr,
+ TYPE_DELBA_RECEIVE, INITIATOR_BIT(del_ba_param_set));
+}
+
+/* Retrieve Rx reordering table. */
+int nxpwifi_get_rx_reorder_tbl(struct nxpwifi_private *priv,
+ struct nxpwifi_ds_rx_reorder_tbl *buf)
+{
+ int i, j;
+ struct nxpwifi_ds_rx_reorder_tbl *rx_reo_tbl = buf;
+ struct nxpwifi_rx_reorder_tbl *rx_reorder_tbl_ptr;
+ int count = 0;
+
+ guard(rcu)();
+ for (j = 0; j < MAX_NUM_TID; j++) {
+ list_for_each_entry_rcu(rx_reorder_tbl_ptr,
+ &priv->rx_reorder_tbl_ptr[j],
+ list) {
+ rx_reo_tbl->tid = (u16)rx_reorder_tbl_ptr->tid;
+ memcpy(rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta, ETH_ALEN);
+ rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win;
+ rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size;
+ for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) {
+ if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
+ rx_reo_tbl->buffer[i] = true;
+ else
+ rx_reo_tbl->buffer[i] = false;
+ }
+ rx_reo_tbl++;
+ count++;
+
+ if (count >= NXPWIFI_MAX_RX_BASTREAM_SUPPORTED)
+ return count;
+ }
+ }
+
+ return count;
+}
+
+/* Retrieve Tx BA stream table. */
+int nxpwifi_get_tx_ba_stream_tbl(struct nxpwifi_private *priv,
+ struct nxpwifi_ds_tx_ba_stream_tbl *buf)
+{
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_tsr_tbl;
+ struct nxpwifi_ds_tx_ba_stream_tbl *rx_reo_tbl = buf;
+ int count = 0;
+ int i;
+
+ guard(rcu)();
+ for (i = 0; i < MAX_NUM_TID; i++) {
+ list_for_each_entry_rcu(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr[i], list) {
+ rx_reo_tbl->tid = (u16)tx_ba_tsr_tbl->tid;
+ nxpwifi_dbg(priv->adapter, DATA, "data: %s tid=%d\n",
+ __func__, rx_reo_tbl->tid);
+ memcpy(rx_reo_tbl->ra, tx_ba_tsr_tbl->ra, ETH_ALEN);
+ rx_reo_tbl->amsdu = tx_ba_tsr_tbl->amsdu;
+ rx_reo_tbl++;
+ count++;
+ if (count >= NXPWIFI_MAX_TX_BASTREAM_SUPPORTED)
+ return count;
+ }
+ }
+
+ return count;
+}
+
+/* Delete Tx BA stream entry by RA. */
+void nxpwifi_del_tx_ba_stream_tbl_by_ra(struct nxpwifi_private *priv, u8 *ra)
+{
+ struct nxpwifi_tx_ba_stream_tbl *tbl;
+ int i;
+
+ if (!ra)
+ return;
+
+ for (i = 0; i < MAX_NUM_TID; i++) {
+ spin_lock_bh(&priv->tx_ba_stream_tbl_lock[i]);
+ list_for_each_entry_rcu(tbl, &priv->tx_ba_stream_tbl_ptr[i], list)
+ if (!memcmp(tbl->ra, ra, ETH_ALEN))
+ nxpwifi_11n_delete_tx_ba_stream_tbl_entry(priv, tbl);
+
+ spin_unlock_bh(&priv->tx_ba_stream_tbl_lock[i]);
+ }
+}
+
+/* Initialize BlockAck parameters. */
+void nxpwifi_set_ba_params(struct nxpwifi_private *priv)
+{
+ priv->add_ba_param.timeout = NXPWIFI_DEFAULT_BLOCK_ACK_TIMEOUT;
+
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_UAP) {
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_UAP_AMPDU_DEF_TXWINSIZE;
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_UAP_AMPDU_DEF_RXWINSIZE;
+ } else {
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_STA_AMPDU_DEF_TXWINSIZE;
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_STA_AMPDU_DEF_RXWINSIZE;
+ }
+
+ priv->add_ba_param.tx_amsdu = true;
+ priv->add_ba_param.rx_amsdu = true;
+}
+
+u8 nxpwifi_get_sec_chan_offset(int chan)
+{
+ u8 sec_offset;
+
+ switch (chan) {
+ case 36:
+ case 44:
+ case 52:
+ case 60:
+ case 100:
+ case 108:
+ case 116:
+ case 124:
+ case 132:
+ case 140:
+ case 149:
+ case 157:
+ case 173:
+ sec_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+ break;
+ case 40:
+ case 48:
+ case 56:
+ case 64:
+ case 104:
+ case 112:
+ case 120:
+ case 128:
+ case 136:
+ case 144:
+ case 153:
+ case 161:
+ case 169:
+ case 177:
+ sec_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+ break;
+ case 165:
+ default:
+ sec_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
+ break;
+ }
+
+ return sec_offset;
+}
+
+/* Send DELBA to entries in the Tx BA stream table. */
+static void
+nxpwifi_send_delba_txbastream_tbl(struct nxpwifi_private *priv, u8 tid)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct nxpwifi_tx_ba_stream_tbl *tx_ba_stream_tbl_ptr;
+
+ guard(rcu)();
+ list_for_each_entry_rcu(tx_ba_stream_tbl_ptr,
+ &priv->tx_ba_stream_tbl_ptr[tid], list) {
+ if (tx_ba_stream_tbl_ptr->ba_status == BA_SETUP_COMPLETE) {
+ if (tid == tx_ba_stream_tbl_ptr->tid) {
+ nxpwifi_dbg(adapter, INFO,
+ "Tx:Send delba to tid=%d, %pM\n", tid,
+ tx_ba_stream_tbl_ptr->ra);
+ nxpwifi_send_delba(priv,
+ tx_ba_stream_tbl_ptr->tid,
+ tx_ba_stream_tbl_ptr->ra, 1);
+ break;
+ }
+ }
+ }
+}
+
+/*
+ * Update tx_win_size for all interfaces and send DELBA when it changes.
+ */
+void nxpwifi_update_ampdu_txwinsize(struct nxpwifi_adapter *adapter)
+{
+ u8 i, j;
+ u32 tx_win_size;
+ struct nxpwifi_private *priv;
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+ tx_win_size = priv->add_ba_param.tx_win_size;
+
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_STA)
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_STA_AMPDU_DEF_TXWINSIZE;
+
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_UAP)
+ priv->add_ba_param.tx_win_size =
+ NXPWIFI_UAP_AMPDU_DEF_TXWINSIZE;
+
+ if (adapter->coex_win_size) {
+ if (adapter->coex_tx_win_size)
+ priv->add_ba_param.tx_win_size =
+ adapter->coex_tx_win_size;
+ }
+
+ if (tx_win_size != priv->add_ba_param.tx_win_size) {
+ if (!priv->media_connected)
+ continue;
+ for (j = 0; j < MAX_NUM_TID; j++)
+ nxpwifi_send_delba_txbastream_tbl(priv, j);
+ }
+ }
+}
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n.h b/drivers/net/wireless/nxp/nxpwifi/11n.h
new file mode 100644
index 000000000000..039c45993f07
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n.h
@@ -0,0 +1,158 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * nxpwifi: 802.11n support
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#ifndef _NXPWIFI_11N_H_
+#define _NXPWIFI_11N_H_
+
+#include "11n_aggr.h"
+#include "11n_rxreorder.h"
+#include "wmm.h"
+
+int nxpwifi_ret_11n_delba(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp);
+int nxpwifi_ret_11n_addba_req(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp);
+int nxpwifi_cmd_11n_cfg(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd, u16 cmd_action,
+ struct nxpwifi_ds_11n_tx_cfg *txcfg);
+int nxpwifi_cmd_append_11n_tlv(struct nxpwifi_private *priv,
+ struct nxpwifi_bssdescriptor *bss_desc,
+ u8 **buffer);
+int nxpwifi_fill_cap_info(struct nxpwifi_private *priv, u8 radio_type,
+ struct ieee80211_ht_cap *ht_cap);
+int nxpwifi_set_get_11n_htcap_cfg(struct nxpwifi_private *priv,
+ u16 action, int *htcap_cfg);
+void nxpwifi_11n_delete_tx_ba_stream_tbl_entry(struct nxpwifi_private *priv,
+ struct nxpwifi_tx_ba_stream_tbl
+ *tx_tbl);
+void nxpwifi_11n_delete_all_tx_ba_stream_tbl(struct nxpwifi_private *priv);
+struct nxpwifi_tx_ba_stream_tbl *nxpwifi_get_ba_tbl(struct nxpwifi_private
+ *priv, int tid, u8 *ra);
+void nxpwifi_create_ba_tbl(struct nxpwifi_private *priv, u8 *ra, int tid,
+ enum nxpwifi_ba_status ba_status);
+int nxpwifi_send_addba(struct nxpwifi_private *priv, int tid, u8 *peer_mac);
+int nxpwifi_send_delba(struct nxpwifi_private *priv, int tid, u8 *peer_mac,
+ int initiator);
+void nxpwifi_11n_delete_ba_stream(struct nxpwifi_private *priv, u8 *del_ba);
+int nxpwifi_get_rx_reorder_tbl(struct nxpwifi_private *priv,
+ struct nxpwifi_ds_rx_reorder_tbl *buf);
+int nxpwifi_get_tx_ba_stream_tbl(struct nxpwifi_private *priv,
+ struct nxpwifi_ds_tx_ba_stream_tbl *buf);
+int nxpwifi_cmd_recfg_tx_buf(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd,
+ int cmd_action, u16 *buf_size);
+int nxpwifi_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command *cmd,
+ int cmd_action,
+ struct nxpwifi_ds_11n_amsdu_aggr_ctrl *aa_ctrl);
+void nxpwifi_del_tx_ba_stream_tbl_by_ra(struct nxpwifi_private *priv, u8 *ra);
+u8 nxpwifi_get_sec_chan_offset(int chan);
+
+static inline bool
+nxpwifi_is_station_ampdu_allowed(struct nxpwifi_private *priv,
+ struct nxpwifi_ra_list_tbl *ptr, int tid)
+{
+ struct nxpwifi_sta_node *node;
+
+ guard(rcu)();
+ node = nxpwifi_get_sta_entry(priv, ptr->ra);
+ if (unlikely(!node))
+ return false;
+
+ if (node->ampdu_sta[tid] == BA_STREAM_NOT_ALLOWED)
+ return false;
+
+ return true;
+}
+
+/* Check if AMPDU is allowed for the given TID. */
+static inline bool
+nxpwifi_is_ampdu_allowed(struct nxpwifi_private *priv,
+ struct nxpwifi_ra_list_tbl *ptr, int tid)
+{
+ if (is_broadcast_ether_addr(ptr->ra))
+ return false;
+
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_UAP)
+ return nxpwifi_is_station_ampdu_allowed(priv, ptr, tid);
+
+ return priv->aggr_prio_tbl[tid].ampdu_ap != BA_STREAM_NOT_ALLOWED;
+}
+
+/* Check if AMSDU is allowed for the given TID. */
+static inline bool
+nxpwifi_is_amsdu_allowed(struct nxpwifi_private *priv, int tid)
+{
+ bool amsdu_enabled = priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED;
+ bool rate_ok = priv->is_data_rate_auto || !(priv->bitmap_rates[2] & 0x03);
+
+ return amsdu_enabled && rate_ok;
+}
+
+/* Check if there is available space for a new BA stream. */
+static inline bool
+nxpwifi_space_avail_for_new_ba_stream(struct nxpwifi_adapter *adapter)
+{
+ struct nxpwifi_private *priv;
+ u8 i, j;
+ size_t ba_stream_num = 0;
+ size_t ba_stream_max = NXPWIFI_MAX_TX_BASTREAM_SUPPORTED;
+
+ if (adapter->fw_api_ver == NXPWIFI_FW_V15) {
+ ba_stream_max = GETSUPP_TXBASTREAMS(adapter->hw_dot_11n_dev_cap);
+ if (!ba_stream_max)
+ ba_stream_max = NXPWIFI_MAX_TX_BASTREAM_SUPPORTED;
+ }
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+ for (j = 0; j < MAX_NUM_TID; j++)
+ ba_stream_num += list_count_nodes(&priv->tx_ba_stream_tbl_ptr[j]);
+ }
+
+ return ba_stream_num < ba_stream_max;
+}
+
+/* Find the Tx BA stream to delete and return its TID and RA. */
+static inline bool
+nxpwifi_find_stream_to_delete(struct nxpwifi_private *priv, int ptr_tid,
+ int *ptid, u8 *ra)
+{
+ int search_tid = priv->aggr_prio_tbl[ptr_tid].ampdu_user;
+ bool found = false;
+ struct nxpwifi_tx_ba_stream_tbl *tx_tbl;
+ int candidate_tid;
+
+ spin_lock_bh(&priv->tx_ba_stream_tbl_lock[ptr_tid]);
+
+ list_for_each_entry(tx_tbl, &priv->tx_ba_stream_tbl_ptr[ptr_tid], list) {
+ candidate_tid = priv->aggr_prio_tbl[tx_tbl->tid].ampdu_user;
+
+ if (search_tid > candidate_tid) {
+ search_tid = candidate_tid;
+ *ptid = tx_tbl->tid;
+ memcpy(ra, tx_tbl->ra, ETH_ALEN);
+ found = true;
+ }
+ }
+
+ spin_unlock_bh(&priv->tx_ba_stream_tbl_lock[ptr_tid]);
+
+ return found;
+}
+
+/* Check whether the associated station is 11n enabled. */
+static inline int nxpwifi_is_sta_11n_enabled(struct nxpwifi_private *priv,
+ struct nxpwifi_sta_node *node)
+{
+ if (!node || (priv->bss_role == NXPWIFI_BSS_ROLE_UAP &&
+ !priv->ap_11n_enabled))
+ return 0;
+
+ return node->is_11n_enabled;
+}
+
+#endif /* !_NXPWIFI_11N_H_ */
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n_aggr.c b/drivers/net/wireless/nxp/nxpwifi/11n_aggr.c
new file mode 100644
index 000000000000..be7080f2a6ce
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n_aggr.c
@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * nxpwifi: 802.11n Aggregation
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#include "cfg.h"
+#include "util.h"
+#include "fw.h"
+#include "main.h"
+#include "wmm.h"
+#include "11n.h"
+#include "11n_aggr.h"
+
+/*
+ * Build an AMSDU subframe for aggregation, with fields
+ * (DA | SA | Length | SNAP header | MSDU), and compute padding
+ * to align the subframe to a 4-byte boundary.
+ */
+static int nxpwifi_11n_form_amsdu_pkt(struct sk_buff *skb_aggr,
+ struct sk_buff *skb_src, int *pad)
+
+{
+ int dt_offset;
+ struct rfc_1042_hdr snap = {
+ 0xaa, /* LLC DSAP */
+ 0xaa, /* LLC SSAP */
+ 0x03, /* LLC CTRL */
+ {0x00, 0x00, 0x00}, /* SNAP OUI */
+ 0x0000 /* SNAP type */
+ /* This field will be overwritten later with ethertype */
+ };
+ struct tx_packet_hdr *tx_header;
+
+ tx_header = skb_put(skb_aggr, sizeof(*tx_header));
+
+ /* Copy DA and SA */
+ dt_offset = 2 * ETH_ALEN;
+ memcpy(&tx_header->eth803_hdr, skb_src->data, dt_offset);
+
+ /* Copy SNAP header */
+ snap.snap_type = ((struct ethhdr *)skb_src->data)->h_proto;
+
+ dt_offset += sizeof(__be16);
+
+ memcpy(&tx_header->rfc1042_hdr, &snap, sizeof(struct rfc_1042_hdr));
+
+ skb_pull(skb_src, dt_offset);
+
+ /* Update Length field */
+ tx_header->eth803_hdr.h_proto = htons(skb_src->len + LLC_SNAP_LEN);
+
+ /* Add payload */
+ skb_put_data(skb_aggr, skb_src->data, skb_src->len);
+
+ /* Add padding for new MSDU to start from 4 byte boundary */
+ *pad = (4 - ((unsigned long)skb_aggr->tail & 0x3)) % 4;
+
+ return skb_aggr->len + *pad;
+}
+
+/*
+ * Adds TxPD to AMSDU header. Each AMSDU packet will contain one TxPD at the
+ * beginning, followed by multiple AMSDU subframes
+ */
+static void
+nxpwifi_11n_form_amsdu_txpd(struct nxpwifi_private *priv,
+ struct sk_buff *skb)
+{
+ struct txpd *local_tx_pd;
+
+ skb_push(skb, sizeof(*local_tx_pd));
+
+ local_tx_pd = (struct txpd *)skb->data;
+ memset(local_tx_pd, 0, sizeof(struct txpd));
+
+ /* Original priority has been overwritten */
+ local_tx_pd->priority = (u8)skb->priority;
+ local_tx_pd->pkt_delay_2ms =
+ nxpwifi_wmm_compute_drv_pkt_delay(priv, skb);
+ local_tx_pd->bss_num = priv->bss_num;
+ local_tx_pd->bss_type = priv->bss_type;
+ /* Always zero as the data is followed by struct txpd */
+ local_tx_pd->tx_pkt_offset = cpu_to_le16(sizeof(struct txpd));
+ local_tx_pd->tx_pkt_type = cpu_to_le16(PKT_TYPE_AMSDU);
+ local_tx_pd->tx_pkt_length = cpu_to_le16(skb->len -
+ sizeof(*local_tx_pd));
+
+ if (local_tx_pd->tx_control == 0)
+ /* TxCtrl set by user or default */
+ local_tx_pd->tx_control = cpu_to_le32(priv->pkt_tx_ctrl);
+
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_STA &&
+ priv->adapter->pps_uapsd_mode) {
+ if (nxpwifi_check_last_packet_indication(priv)) {
+ priv->adapter->tx_lock_flag = true;
+ local_tx_pd->flags =
+ NXPWIFI_TxPD_POWER_MGMT_LAST_PACKET;
+ }
+ }
+}
+
+/*
+ * Build an aggregated MSDU packet by encapsulating buffers from the RA
+ * list as AMSDU subframes and concatenating them. A TxPD is prepended
+ * before transmission to form the final AMSDU packet.
+ */
+int
+nxpwifi_11n_aggregate_pkt(struct nxpwifi_private *priv,
+ struct nxpwifi_ra_list_tbl *pra_list,
+ int ptrindex)
+ __releases(&priv->wmm.ra_list_spinlock)
+{
+ struct nxpwifi_adapter *adapter = priv->adapter;
+ struct sk_buff *skb_aggr, *skb_src;
+ struct nxpwifi_txinfo *tx_info_aggr, *tx_info_src;
+ int pad = 0, aggr_num = 0, ret;
+ struct nxpwifi_tx_param tx_param;
+ struct txpd *ptx_pd = NULL;
+ int headroom = adapter->intf_hdr_len;
+
+ skb_src = skb_peek(&pra_list->skb_head);
+ if (!skb_src) {
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ return 0;
+ }
+
+ tx_info_src = NXPWIFI_SKB_TXCB(skb_src);
+ skb_aggr = nxpwifi_alloc_dma_align_buf(adapter->tx_buf_size,
+ GFP_ATOMIC);
+ if (!skb_aggr) {
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ return -ENOMEM;
+ }
+
+ /*
+ * skb_aggr->data already 64 byte align, just reserve bus interface
+ * header and txpd.
+ */
+ skb_reserve(skb_aggr, headroom + sizeof(struct txpd));
+ tx_info_aggr = NXPWIFI_SKB_TXCB(skb_aggr);
+
+ memset(tx_info_aggr, 0, sizeof(*tx_info_aggr));
+ tx_info_aggr->bss_type = tx_info_src->bss_type;
+ tx_info_aggr->bss_num = tx_info_src->bss_num;
+
+ tx_info_aggr->flags |= NXPWIFI_BUF_FLAG_AGGR_PKT;
+ skb_aggr->priority = skb_src->priority;
+ skb_aggr->tstamp = skb_src->tstamp;
+
+ do {
+ /* Check if AMSDU can accommodate this MSDU */
+ if ((skb_aggr->len + skb_src->len + LLC_SNAP_LEN) >
+ adapter->tx_buf_size)
+ break;
+
+ skb_src = skb_dequeue(&pra_list->skb_head);
+ pra_list->total_pkt_count--;
+ atomic_dec(&priv->wmm.tx_pkts_queued);
+ aggr_num++;
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ nxpwifi_11n_form_amsdu_pkt(skb_aggr, skb_src, &pad);
+
+ nxpwifi_write_data_complete(adapter, skb_src, 0, 0);
+
+ spin_lock_bh(&priv->wmm.ra_list_spinlock);
+
+ if (!nxpwifi_is_ralist_valid(priv, pra_list, ptrindex)) {
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ return -ENOENT;
+ }
+
+ if (skb_tailroom(skb_aggr) < pad) {
+ pad = 0;
+ break;
+ }
+ skb_put(skb_aggr, pad);
+
+ skb_src = skb_peek(&pra_list->skb_head);
+
+ } while (skb_src);
+
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+
+ /* Last AMSDU packet does not need padding */
+ skb_trim(skb_aggr, skb_aggr->len - pad);
+
+ /* Form AMSDU */
+ nxpwifi_11n_form_amsdu_txpd(priv, skb_aggr);
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_STA)
+ ptx_pd = (struct txpd *)skb_aggr->data;
+
+ skb_push(skb_aggr, headroom);
+ tx_info_aggr->aggr_num = aggr_num * 2;
+ if (adapter->data_sent || adapter->tx_lock_flag) {
+ atomic_add(aggr_num * 2, &adapter->tx_queued);
+ skb_queue_tail(&adapter->tx_data_q, skb_aggr);
+ return 0;
+ }
+
+ if (skb_src)
+ tx_param.next_pkt_len = skb_src->len + sizeof(struct txpd);
+ else
+ tx_param.next_pkt_len = 0;
+
+ ret = adapter->if_ops.host_to_card(adapter, NXPWIFI_TYPE_DATA,
+ skb_aggr, &tx_param);
+
+ switch (ret) {
+ case -EBUSY:
+ spin_lock_bh(&priv->wmm.ra_list_spinlock);
+ if (!nxpwifi_is_ralist_valid(priv, pra_list, ptrindex)) {
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ nxpwifi_write_data_complete(adapter, skb_aggr, 1, -1);
+ return -EINVAL;
+ }
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_STA &&
+ adapter->pps_uapsd_mode && adapter->tx_lock_flag) {
+ priv->adapter->tx_lock_flag = false;
+ if (ptx_pd)
+ ptx_pd->flags = 0;
+ }
+
+ skb_queue_tail(&pra_list->skb_head, skb_aggr);
+
+ pra_list->total_pkt_count++;
+
+ atomic_inc(&priv->wmm.tx_pkts_queued);
+
+ tx_info_aggr->flags |= NXPWIFI_BUF_FLAG_REQUEUED_PKT;
+ spin_unlock_bh(&priv->wmm.ra_list_spinlock);
+ nxpwifi_dbg(adapter, ERROR, "data: -EBUSY is returned\n");
+ break;
+ case -EINPROGRESS:
+ break;
+ case 0:
+ nxpwifi_write_data_complete(adapter, skb_aggr, 1, ret);
+ break;
+ default:
+ nxpwifi_dbg(adapter, ERROR, "%s: host_to_card failed: %#x\n",
+ __func__, ret);
+ adapter->dbg.num_tx_host_to_card_failure++;
+ nxpwifi_write_data_complete(adapter, skb_aggr, 1, ret);
+ break;
+ }
+ if (ret != -EBUSY)
+ nxpwifi_rotate_priolists(priv, pra_list, ptrindex);
+
+ return 0;
+}
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n_aggr.h b/drivers/net/wireless/nxp/nxpwifi/11n_aggr.h
new file mode 100644
index 000000000000..be9f0f8f4e48
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n_aggr.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * NXP Wireless LAN device driver: 802.11n Aggregation
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#ifndef _NXPWIFI_11N_AGGR_H_
+#define _NXPWIFI_11N_AGGR_H_
+
+#define PKT_TYPE_AMSDU 0xE6
+#define MIN_NUM_AMSDU 2
+
+int nxpwifi_11n_deaggregate_pkt(struct nxpwifi_private *priv,
+ struct sk_buff *skb);
+int nxpwifi_11n_aggregate_pkt(struct nxpwifi_private *priv,
+ struct nxpwifi_ra_list_tbl *ptr,
+ int ptr_index)
+ __releases(&priv->wmm.ra_list_spinlock);
+
+#endif /* !_NXPWIFI_11N_AGGR_H_ */
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c b/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c
new file mode 100644
index 000000000000..c5819f89b08c
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c
@@ -0,0 +1,826 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * nxpwifi: 802.11n RX Re-ordering
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#include "cfg.h"
+#include "util.h"
+#include "fw.h"
+#include "main.h"
+#include "cmdevt.h"
+#include "wmm.h"
+#include "11n.h"
+#include "11n_rxreorder.h"
+/* Dispatch A-MSDU to stack. */
+static int nxpwifi_11n_dispatch_amsdu_pkt(struct nxpwifi_private *priv,
+ struct sk_buff *skb)
+{
+ struct rxpd *local_rx_pd = (struct rxpd *)(skb->data);
+ int ret;
+
+ if (le16_to_cpu(local_rx_pd->rx_pkt_type) == PKT_TYPE_AMSDU) {
+ struct sk_buff_head list;
+ struct sk_buff *rx_skb;
+
+ __skb_queue_head_init(&list);
+
+ skb_pull(skb, le16_to_cpu(local_rx_pd->rx_pkt_offset));
+ skb_trim(skb, le16_to_cpu(local_rx_pd->rx_pkt_length));
+
+ ieee80211_amsdu_to_8023s(skb, &list, priv->curr_addr,
+ priv->wdev.iftype, 0, NULL, NULL, false);
+
+ while (!skb_queue_empty(&list)) {
+ rx_skb = __skb_dequeue(&list);
+
+ if (priv->bss_role == NXPWIFI_BSS_ROLE_UAP)
+ ret = nxpwifi_uap_recv_packet(priv, rx_skb);
+ else
+ ret = nxpwifi_recv_packet(priv, rx_skb);
+ if (ret)
+ nxpwifi_dbg(priv->adapter, ERROR,
+ "Rx of A-MSDU failed");
+ }
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+/* Process RX packet and forward to stack. */
+static int nxpwifi_11n_dispatch_pkt(struct nxpwifi_private *priv,
+ struct sk_buff *payload)
+{
+ int ret;
+
+ if (!payload) {
+ nxpwifi_dbg(priv->adapter, INFO, "info: fw drop data\n");
+ return 0;
+ }
+
+ ret = nxpwifi_11n_dispatch_amsdu_pkt(priv, payload);
+ if (!ret)
+ return 0;
+
+ if (priv->bss_role == NXPWIFI_BSS_ROLE_UAP)
+ return nxpwifi_handle_uap_rx_forward(priv, payload);
+
+ return nxpwifi_process_rx_packet(priv, payload);
+}
+
+/* Dispatch packets up to start_win. */
+static void
+nxpwifi_11n_dispatch_pkt_until_start_win(struct nxpwifi_private *priv,
+ struct nxpwifi_rx_reorder_tbl *tbl,
+ int start_win)
+{
+ struct sk_buff_head list;
+ struct sk_buff *skb;
+ int pkt_to_send, i, tid;
+
+ tid = tbl->tid;
+ __skb_queue_head_init(&list);
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[tid]);
+
+ pkt_to_send = (start_win > tbl->start_win) ?
+ min((start_win - tbl->start_win), tbl->win_size) :
+ tbl->win_size;
+
+ for (i = 0; i < pkt_to_send; ++i) {
+ if (tbl->rx_reorder_ptr[i]) {
+ skb = tbl->rx_reorder_ptr[i];
+ __skb_queue_tail(&list, skb);
+ tbl->rx_reorder_ptr[i] = NULL;
+ }
+ }
+
+ /* Simulate circular buffer via rotation. */
+ for (i = 0; i < tbl->win_size - pkt_to_send; ++i) {
+ tbl->rx_reorder_ptr[i] = tbl->rx_reorder_ptr[pkt_to_send + i];
+ tbl->rx_reorder_ptr[pkt_to_send + i] = NULL;
+ }
+
+ tbl->start_win = start_win;
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[tid]);
+
+ while ((skb = __skb_dequeue(&list)))
+ nxpwifi_11n_dispatch_pkt(priv, skb);
+}
+
+/* Dispatch packets until a hole is found. */
+static void
+nxpwifi_11n_scan_and_dispatch(struct nxpwifi_private *priv,
+ struct nxpwifi_rx_reorder_tbl *tbl)
+{
+ struct sk_buff_head list;
+ struct sk_buff *skb;
+ int i, j, xchg, tid;
+
+ tid = tbl->tid;
+ __skb_queue_head_init(&list);
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[tid]);
+
+ for (i = 0; i < tbl->win_size; ++i) {
+ if (!tbl->rx_reorder_ptr[i])
+ break;
+ skb = tbl->rx_reorder_ptr[i];
+ __skb_queue_tail(&list, skb);
+ tbl->rx_reorder_ptr[i] = NULL;
+ }
+
+ /* Simulate circular buffer via rotation. */
+ if (i > 0) {
+ xchg = tbl->win_size - i;
+ for (j = 0; j < xchg; ++j) {
+ tbl->rx_reorder_ptr[j] = tbl->rx_reorder_ptr[i + j];
+ tbl->rx_reorder_ptr[i + j] = NULL;
+ }
+ }
+ tbl->start_win = (tbl->start_win + i) & (MAX_TID_VALUE - 1);
+
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[tid]);
+
+ while ((skb = __skb_dequeue(&list)))
+ nxpwifi_11n_dispatch_pkt(priv, skb);
+}
+
+/* Delete RX reorder entry and flush pending packets. */
+static void
+nxpwifi_del_rx_reorder_entry(struct nxpwifi_private *priv,
+ struct nxpwifi_rx_reorder_tbl *tbl)
+{
+ int start_win, tid;
+
+ if (!tbl)
+ return;
+
+ tid = tbl->tid;
+
+ atomic_set(&priv->adapter->rx_ba_teardown_pending, 1);
+ flush_workqueue(priv->adapter->rx_workqueue);
+
+ start_win = (tbl->start_win + tbl->win_size) & (MAX_TID_VALUE - 1);
+ nxpwifi_11n_dispatch_pkt_until_start_win(priv, tbl, start_win);
+
+ timer_delete_sync(&tbl->timer_context.timer);
+ tbl->timer_context.timer_is_set = false;
+
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[tid]);
+ list_del_rcu(&tbl->list);
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[tid]);
+
+ kfree(tbl->rx_reorder_ptr);
+ kfree_rcu(tbl, rcu);
+
+ atomic_set(&priv->adapter->rx_ba_teardown_pending, 0);
+}
+
+/* Lookup RX reorder entry by TID/TA. */
+struct nxpwifi_rx_reorder_tbl *
+nxpwifi_11n_get_rx_reorder_tbl(struct nxpwifi_private *priv, int tid, u8 *ta)
+{
+ struct nxpwifi_rx_reorder_tbl *tbl, *found = NULL;
+
+ guard(rcu)();
+
+ list_for_each_entry_rcu(tbl, &priv->rx_reorder_tbl_ptr[tid], list) {
+ if (!memcmp(tbl->ta, ta, ETH_ALEN) && tbl->tid == tid) {
+ found = tbl;
+ break;
+ }
+ }
+
+ return found;
+}
+
+/* Delete RX reorder entries by TA. */
+void nxpwifi_11n_del_rx_reorder_tbl_by_ta(struct nxpwifi_private *priv, u8 *ta)
+{
+ struct nxpwifi_rx_reorder_tbl *tbl, *tmp;
+ LIST_HEAD(to_delete);
+ int i;
+
+ if (!ta)
+ return;
+
+ for (i = 0; i < MAX_NUM_TID; i++) {
+ guard(rcu)();
+ list_for_each_entry_rcu(tbl, &priv->rx_reorder_tbl_ptr[i], list) {
+ if (!memcmp(tbl->ta, ta, ETH_ALEN)) {
+ INIT_LIST_HEAD(&tbl->tmp_list);
+ list_add_tail(&tbl->tmp_list, &to_delete);
+ }
+ }
+
+ list_for_each_entry_safe(tbl, tmp, &to_delete, tmp_list)
+ nxpwifi_del_rx_reorder_entry(priv, tbl);
+
+ INIT_LIST_HEAD(&to_delete);
+ }
+}
+
+/* Find last buffered sequence index. */
+static int
+nxpwifi_11n_find_last_seq_num(struct reorder_tmr_cnxt *ctx)
+{
+ struct nxpwifi_rx_reorder_tbl *rx_reorder_tbl_ptr = ctx->ptr;
+ int i;
+
+ guard(rcu)();
+ for (i = rx_reorder_tbl_ptr->win_size - 1; i >= 0; --i) {
+ if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
+ return i;
+ }
+
+ return -EINVAL;
+}
+
+/* Flush and dispatch buffered packets on timer. */
+static void
+nxpwifi_flush_data(struct timer_list *t)
+{
+ struct reorder_tmr_cnxt *ctx =
+ timer_container_of(ctx, t, timer);
+ int start_win, seq_num;
+
+ ctx->timer_is_set = false;
+ seq_num = nxpwifi_11n_find_last_seq_num(ctx);
+
+ if (seq_num < 0)
+ return;
+
+ nxpwifi_dbg(ctx->priv->adapter, INFO, "info: flush data %d\n", seq_num);
+ start_win = (ctx->ptr->start_win + seq_num + 1) & (MAX_TID_VALUE - 1);
+ nxpwifi_11n_dispatch_pkt_until_start_win(ctx->priv, ctx->ptr,
+ start_win);
+}
+
+/* Create RX reorder entry (TID/TA, SSN, winsize, timer). */
+static void
+nxpwifi_11n_create_rx_reorder_tbl(struct nxpwifi_private *priv, u8 *ta,
+ int tid, int win_size, int seq_num)
+{
+ int i;
+ struct nxpwifi_rx_reorder_tbl *tbl, *new_node;
+ u16 last_seq = 0;
+ struct nxpwifi_sta_node *node;
+
+ /* Existing TID/TA: flush and move window to SSN. */
+ tbl = nxpwifi_11n_get_rx_reorder_tbl(priv, tid, ta);
+ if (tbl) {
+ nxpwifi_11n_dispatch_pkt_until_start_win(priv, tbl, seq_num);
+ return;
+ }
+ /* if !tbl then create one */
+ new_node = kzalloc_obj(*new_node, GFP_KERNEL);
+ if (!new_node)
+ return;
+
+ INIT_LIST_HEAD(&new_node->list);
+ new_node->tid = tid;
+ memcpy(new_node->ta, ta, ETH_ALEN);
+ new_node->start_win = seq_num;
+ new_node->init_win = seq_num;
+ new_node->flags = 0;
+
+ if (nxpwifi_queuing_ra_based(priv)) {
+ if (priv->bss_role == NXPWIFI_BSS_ROLE_UAP) {
+ guard(rcu)();
+ node = nxpwifi_get_sta_entry(priv, ta);
+ if (node)
+ last_seq = node->rx_seq[tid];
+ }
+ } else {
+ guard(rcu)();
+ node = nxpwifi_get_sta_entry(priv, ta);
+ if (node)
+ last_seq = node->rx_seq[tid];
+ else
+ last_seq = priv->rx_seq[tid];
+ }
+
+ nxpwifi_dbg(priv->adapter, INFO,
+ "info: last_seq=%d start_win=%d\n",
+ last_seq, new_node->start_win);
+
+ if (last_seq != NXPWIFI_DEF_11N_RX_SEQ_NUM &&
+ last_seq >= new_node->start_win) {
+ new_node->start_win = last_seq + 1;
+ new_node->flags |= RXREOR_INIT_WINDOW_SHIFT;
+ }
+
+ new_node->win_size = win_size;
+
+ new_node->rx_reorder_ptr = kcalloc(win_size, sizeof(void *),
+ GFP_KERNEL);
+ if (!new_node->rx_reorder_ptr) {
+ kfree(new_node);
+ nxpwifi_dbg(priv->adapter, ERROR,
+ "%s: failed to alloc reorder_ptr\n", __func__);
+ return;
+ }
+
+ new_node->timer_context.ptr = new_node;
+ new_node->timer_context.priv = priv;
+ new_node->timer_context.timer_is_set = false;
+
+ timer_setup(&new_node->timer_context.timer, nxpwifi_flush_data, 0);
+
+ for (i = 0; i < win_size; ++i)
+ new_node->rx_reorder_ptr[i] = NULL;
+
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[tid]);
+ list_add_tail_rcu(&new_node->list, &priv->rx_reorder_tbl_ptr[tid]);
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[tid]);
+}
+
+static void
+nxpwifi_11n_rxreorder_timer_restart(struct nxpwifi_rx_reorder_tbl *tbl)
+{
+ u32 min_flush_time;
+
+ if (tbl->win_size >= NXPWIFI_BA_WIN_SIZE_32)
+ min_flush_time = MIN_FLUSH_TIMER_15_MS;
+ else
+ min_flush_time = MIN_FLUSH_TIMER_MS;
+
+ mod_timer(&tbl->timer_context.timer,
+ jiffies + msecs_to_jiffies(min_flush_time * tbl->win_size));
+
+ tbl->timer_context.timer_is_set = true;
+}
+
+/* Prepare ADDBA request. */
+int nxpwifi_cmd_11n_addba_req(struct host_cmd_ds_command *cmd, void *data_buf)
+{
+ struct host_cmd_ds_11n_addba_req *add_ba_req = &cmd->params.add_ba_req;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11N_ADDBA_REQ);
+ cmd->size = cpu_to_le16(sizeof(*add_ba_req) + S_DS_GEN);
+ memcpy(add_ba_req, data_buf, sizeof(*add_ba_req));
+
+ return 0;
+}
+
+/* Prepare ADDBA response and create RX reorder table. */
+int nxpwifi_cmd_11n_addba_rsp_gen(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd,
+ struct host_cmd_ds_11n_addba_req
+ *cmd_addba_req)
+{
+ struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &cmd->params.add_ba_rsp;
+ u32 rx_win_size = priv->add_ba_param.rx_win_size;
+ u8 tid;
+ int win_size;
+ u16 block_ack_param_set;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11N_ADDBA_RSP);
+ cmd->size = cpu_to_le16(sizeof(*add_ba_rsp) + S_DS_GEN);
+
+ memcpy(add_ba_rsp->peer_mac_addr, cmd_addba_req->peer_mac_addr,
+ ETH_ALEN);
+ add_ba_rsp->dialog_token = cmd_addba_req->dialog_token;
+ add_ba_rsp->block_ack_tmo = cmd_addba_req->block_ack_tmo;
+ add_ba_rsp->ssn = cmd_addba_req->ssn;
+
+ block_ack_param_set = le16_to_cpu(cmd_addba_req->block_ack_param_set);
+ tid = (block_ack_param_set & IEEE80211_ADDBA_PARAM_TID_MASK)
+ >> BLOCKACKPARAM_TID_POS;
+ add_ba_rsp->status_code = cpu_to_le16(ADDBA_RSP_STATUS_ACCEPT);
+ block_ack_param_set &= ~IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK;
+
+ /* If we don't support AMSDU inside AMPDU, reset the bit */
+ if (!priv->add_ba_param.rx_amsdu ||
+ priv->aggr_prio_tbl[tid].amsdu == BA_STREAM_NOT_ALLOWED)
+ block_ack_param_set &= ~IEEE80211_ADDBA_PARAM_AMSDU_MASK;
+ block_ack_param_set |= rx_win_size << BLOCKACKPARAM_WINSIZE_POS;
+ add_ba_rsp->block_ack_param_set = cpu_to_le16(block_ack_param_set);
+ win_size = (le16_to_cpu(add_ba_rsp->block_ack_param_set)
+ & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK)
+ >> BLOCKACKPARAM_WINSIZE_POS;
+ cmd_addba_req->block_ack_param_set = cpu_to_le16(block_ack_param_set);
+
+ nxpwifi_11n_create_rx_reorder_tbl(priv, cmd_addba_req->peer_mac_addr,
+ tid, win_size,
+ le16_to_cpu(cmd_addba_req->ssn));
+ return 0;
+}
+
+/* Prepare DELBA command. */
+int nxpwifi_cmd_11n_delba(struct host_cmd_ds_command *cmd, void *data_buf)
+{
+ struct host_cmd_ds_11n_delba *del_ba = &cmd->params.del_ba;
+
+ cmd->command = cpu_to_le16(HOST_CMD_11N_DELBA);
+ cmd->size = cpu_to_le16(sizeof(*del_ba) + S_DS_GEN);
+ memcpy(del_ba, data_buf, sizeof(*del_ba));
+
+ return 0;
+}
+
+/* Decide and perform RX reordering for a packet. */
+int nxpwifi_11n_rx_reorder_pkt(struct nxpwifi_private *priv,
+ u16 seq_num, u16 tid,
+ u8 *ta, u8 pkt_type, void *payload)
+{
+ struct nxpwifi_rx_reorder_tbl *tbl;
+ int prev_start_win, start_win, end_win, win_size;
+ u16 pkt_index;
+ bool init_window_shift = false;
+ int ret = 0;
+
+ tbl = nxpwifi_11n_get_rx_reorder_tbl(priv, tid, ta);
+ if (!tbl) {
+ if (pkt_type != PKT_TYPE_BAR)
+ nxpwifi_11n_dispatch_pkt(priv, payload);
+ return ret;
+ }
+
+ if (pkt_type == PKT_TYPE_AMSDU && !tbl->amsdu) {
+ nxpwifi_11n_dispatch_pkt(priv, payload);
+ return ret;
+ }
+
+ start_win = tbl->start_win;
+ prev_start_win = start_win;
+ win_size = tbl->win_size;
+ end_win = ((start_win + win_size) - 1) & (MAX_TID_VALUE - 1);
+ if (tbl->flags & RXREOR_INIT_WINDOW_SHIFT) {
+ init_window_shift = true;
+ tbl->flags &= ~RXREOR_INIT_WINDOW_SHIFT;
+ }
+
+ if (tbl->flags & RXREOR_FORCE_NO_DROP) {
+ nxpwifi_dbg(priv->adapter, INFO,
+ "RXREOR_FORCE_NO_DROP when HS is activated\n");
+ tbl->flags &= ~RXREOR_FORCE_NO_DROP;
+ } else if (init_window_shift && seq_num < start_win &&
+ seq_num >= tbl->init_win) {
+ nxpwifi_dbg(priv->adapter, INFO,
+ "Sender TID sequence number reset %d->%d for SSN %d\n",
+ start_win, seq_num, tbl->init_win);
+ start_win = seq_num;
+ tbl->start_win = start_win;
+ end_win = ((start_win + win_size) - 1) & (MAX_TID_VALUE - 1);
+ } else {
+ /* Drop packet if seq_num < start_win. */
+ if ((start_win + TWOPOW11) > (MAX_TID_VALUE - 1)) {
+ if (seq_num >= ((start_win + TWOPOW11) &
+ (MAX_TID_VALUE - 1)) &&
+ seq_num < start_win) {
+ ret = -EINVAL;
+ goto done;
+ }
+ } else if ((seq_num < start_win) ||
+ (seq_num >= (start_win + TWOPOW11))) {
+ ret = -EINVAL;
+ goto done;
+ }
+ }
+
+ /* Adjust seq_num for BAR (WinStart = seq_num). */
+ if (pkt_type == PKT_TYPE_BAR)
+ seq_num = ((seq_num + win_size) - 1) & (MAX_TID_VALUE - 1);
+
+ if ((end_win < start_win &&
+ seq_num < start_win && seq_num > end_win) ||
+ (end_win > start_win && (seq_num > end_win ||
+ seq_num < start_win))) {
+ end_win = seq_num;
+ if (((end_win - win_size) + 1) >= 0)
+ start_win = (end_win - win_size) + 1;
+ else
+ start_win = (MAX_TID_VALUE - (win_size - end_win)) + 1;
+ nxpwifi_11n_dispatch_pkt_until_start_win(priv, tbl, start_win);
+ }
+
+ if (pkt_type != PKT_TYPE_BAR) {
+ if (seq_num >= start_win)
+ pkt_index = seq_num - start_win;
+ else
+ pkt_index = (seq_num + MAX_TID_VALUE) - start_win;
+
+ if (tbl->rx_reorder_ptr[pkt_index]) {
+ ret = -EINVAL;
+ goto done;
+ }
+
+ tbl->rx_reorder_ptr[pkt_index] = payload;
+ }
+
+ /* Dispatch sequentially until a hole; update start_win. */
+ nxpwifi_11n_scan_and_dispatch(priv, tbl);
+
+done:
+ if (!tbl->timer_context.timer_is_set ||
+ prev_start_win != tbl->start_win)
+ nxpwifi_11n_rxreorder_timer_restart(tbl);
+ return ret;
+}
+
+/* Delete BA entry for TID/TA. */
+void
+nxpwifi_del_ba_tbl(struct nxpwifi_private *priv, int tid, u8 *peer_mac,
+ u8 type, int initiator)
+{
+ struct nxpwifi_rx_reorder_tbl *tbl;
+ struct nxpwifi_tx_ba_stream_tbl *ptx_tbl;
+ struct nxpwifi_ra_list_tbl *ra_list;
+ u8 cleanup_rx_reorder_tbl;
+ int tid_down;
+
+ if (type == TYPE_DELBA_RECEIVE)
+ cleanup_rx_reorder_tbl = (initiator) ? true : false;
+ else
+ cleanup_rx_reorder_tbl = (initiator) ? false : true;
+
+ nxpwifi_dbg(priv->adapter, EVENT, "event: DELBA: %pM tid=%d initiator=%d\n",
+ peer_mac, tid, initiator);
+
+ if (cleanup_rx_reorder_tbl) {
+ tbl = nxpwifi_11n_get_rx_reorder_tbl(priv, tid, peer_mac);
+ if (!tbl) {
+ nxpwifi_dbg(priv->adapter, EVENT,
+ "event: TID, TA not found in table\n");
+ return;
+ }
+ nxpwifi_del_rx_reorder_entry(priv, tbl);
+ } else {
+ guard(rcu)();
+ ptx_tbl = nxpwifi_get_ba_tbl(priv, tid, peer_mac);
+
+ if (!ptx_tbl) {
+ nxpwifi_dbg(priv->adapter, EVENT,
+ "event: TID, RA not found in table\n");
+ return;
+ }
+
+ tid_down = nxpwifi_wmm_downgrade_tid(priv, tid);
+ ra_list = nxpwifi_wmm_get_ralist_node(priv, tid_down, peer_mac);
+ if (ra_list) {
+ ra_list->amsdu_in_ampdu = false;
+ ra_list->ba_status = BA_SETUP_NONE;
+ }
+ spin_lock_bh(&priv->tx_ba_stream_tbl_lock[tid]);
+ nxpwifi_11n_delete_tx_ba_stream_tbl_entry(priv, ptx_tbl);
+ spin_unlock_bh(&priv->tx_ba_stream_tbl_lock[tid]);
+ }
+}
+
+/* Handle ADDBA response. */
+int nxpwifi_ret_11n_addba_resp(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *resp)
+{
+ struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &resp->params.add_ba_rsp;
+ int tid, win_size;
+ struct nxpwifi_rx_reorder_tbl *tbl;
+ u16 block_ack_param_set;
+
+ block_ack_param_set = le16_to_cpu(add_ba_rsp->block_ack_param_set);
+
+ tid = (block_ack_param_set & IEEE80211_ADDBA_PARAM_TID_MASK)
+ >> BLOCKACKPARAM_TID_POS;
+ /* Check if we had rejected the ADDBA, if yes then do not create the stream */
+ if (le16_to_cpu(add_ba_rsp->status_code) != BA_RESULT_SUCCESS) {
+ nxpwifi_dbg(priv->adapter, ERROR, "ADDBA RSP: failed %pM tid=%d)\n",
+ add_ba_rsp->peer_mac_addr, tid);
+
+ tbl = nxpwifi_11n_get_rx_reorder_tbl(priv, tid,
+ add_ba_rsp->peer_mac_addr);
+ if (tbl)
+ nxpwifi_del_rx_reorder_entry(priv, tbl);
+
+ return 0;
+ }
+
+ win_size = (block_ack_param_set & IEEE80211_ADDBA_PARAM_BUF_SIZE_MASK)
+ >> BLOCKACKPARAM_WINSIZE_POS;
+
+ tbl = nxpwifi_11n_get_rx_reorder_tbl(priv, tid,
+ add_ba_rsp->peer_mac_addr);
+ if (tbl) {
+ if ((block_ack_param_set & IEEE80211_ADDBA_PARAM_AMSDU_MASK) &&
+ priv->add_ba_param.rx_amsdu &&
+ priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED)
+ tbl->amsdu = true;
+ else
+ tbl->amsdu = false;
+ }
+
+ nxpwifi_dbg(priv->adapter, CMD,
+ "cmd: ADDBA RSP: %pM tid=%d ssn=%d win_size=%d\n",
+ add_ba_rsp->peer_mac_addr, tid, add_ba_rsp->ssn, win_size);
+
+ return 0;
+}
+
+/* Handle BA stream timeout: send DELBA. */
+void nxpwifi_11n_ba_stream_timeout(struct nxpwifi_private *priv,
+ struct host_cmd_ds_11n_batimeout *event)
+{
+ struct host_cmd_ds_11n_delba delba;
+
+ memset(&delba, 0, sizeof(struct host_cmd_ds_11n_delba));
+ memcpy(delba.peer_mac_addr, event->peer_mac_addr, ETH_ALEN);
+
+ delba.del_ba_param_set |=
+ cpu_to_le16((u16)event->tid << DELBA_TID_POS);
+ delba.del_ba_param_set |=
+ cpu_to_le16((u16)event->origninator << DELBA_INITIATOR_POS);
+ delba.reason_code = cpu_to_le16(WLAN_REASON_QSTA_TIMEOUT);
+ nxpwifi_send_cmd(priv, HOST_CMD_11N_DELBA, 0, 0, &delba, false);
+}
+
+/* Cleanup all RX reorder entries. */
+void nxpwifi_11n_cleanup_reorder_tbl(struct nxpwifi_private *priv)
+{
+ struct nxpwifi_rx_reorder_tbl *del_tbl_ptr, *tmp_node;
+ LIST_HEAD(to_delete_list);
+ int i;
+
+ for (i = 0; i < MAX_NUM_TID; i++) {
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[i]);
+ list_splice_init(&priv->rx_reorder_tbl_ptr[i], &to_delete_list);
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[i]);
+
+ list_for_each_entry_safe(del_tbl_ptr, tmp_node, &to_delete_list, list)
+ nxpwifi_del_rx_reorder_entry(priv, del_tbl_ptr);
+
+ INIT_LIST_HEAD(&to_delete_list);
+ }
+
+ nxpwifi_reset_11n_rx_seq_num(priv);
+}
+
+/* Update flags for all RX reorder tables. */
+void nxpwifi_update_rxreor_flags(struct nxpwifi_adapter *adapter, u8 flags)
+{
+ struct nxpwifi_private *priv;
+ struct nxpwifi_rx_reorder_tbl *tbl;
+ int i, j;
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+
+ for (j = 0; j < MAX_NUM_TID; j++) {
+ spin_lock_bh(&priv->rx_reorder_tbl_lock[j]);
+ list_for_each_entry_rcu(tbl, &priv->rx_reorder_tbl_ptr[j], list)
+ tbl->flags = flags;
+ spin_unlock_bh(&priv->rx_reorder_tbl_lock[j]);
+ }
+ }
+}
+
+/* Update RX window size based on coex flag. */
+static void nxpwifi_update_ampdu_rxwinsize(struct nxpwifi_adapter *adapter,
+ bool coex_flag)
+{
+ u8 i, j;
+ u32 rx_win_size;
+ struct nxpwifi_private *priv;
+
+ nxpwifi_dbg(adapter, INFO, "Update rxwinsize %d\n", coex_flag);
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+ rx_win_size = priv->add_ba_param.rx_win_size;
+ if (coex_flag) {
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_STA)
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_STA_COEX_AMPDU_DEF_RXWINSIZE;
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_UAP)
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_UAP_COEX_AMPDU_DEF_RXWINSIZE;
+ } else {
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_STA)
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_STA_AMPDU_DEF_RXWINSIZE;
+ if (priv->bss_type == NXPWIFI_BSS_TYPE_UAP)
+ priv->add_ba_param.rx_win_size =
+ NXPWIFI_UAP_AMPDU_DEF_RXWINSIZE;
+ }
+
+ if (adapter->coex_win_size && adapter->coex_rx_win_size)
+ priv->add_ba_param.rx_win_size =
+ adapter->coex_rx_win_size;
+
+ if (rx_win_size != priv->add_ba_param.rx_win_size) {
+ if (!priv->media_connected)
+ continue;
+ for (j = 0; j < MAX_NUM_TID; j++)
+ nxpwifi_11n_delba(priv, j);
+ }
+ }
+}
+
+/* Check coex for RX BA. */
+void nxpwifi_coex_ampdu_rxwinsize(struct nxpwifi_adapter *adapter)
+{
+ u8 i;
+ struct nxpwifi_private *priv;
+ u8 count = 0;
+
+ for (i = 0; i < adapter->priv_num; i++) {
+ priv = adapter->priv[i];
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_STA) {
+ if (priv->media_connected)
+ count++;
+ }
+ if (GET_BSS_ROLE(priv) == NXPWIFI_BSS_ROLE_UAP) {
+ if (priv->bss_started)
+ count++;
+ }
+ if (count >= NXPWIFI_BSS_COEX_COUNT)
+ break;
+ }
+ if (count >= NXPWIFI_BSS_COEX_COUNT)
+ nxpwifi_update_ampdu_rxwinsize(adapter, true);
+ else
+ nxpwifi_update_ampdu_rxwinsize(adapter, false);
+}
+
+/* Handle RXBA sync event. */
+void nxpwifi_11n_rxba_sync_event(struct nxpwifi_private *priv,
+ u8 *event_buf, u16 len)
+{
+ struct nxpwifi_ie_types_rxba_sync *tlv_rxba = (void *)event_buf;
+ u16 tlv_type, tlv_len;
+ struct nxpwifi_rx_reorder_tbl *rx_reor_tbl_ptr;
+ u8 i, j;
+ u16 seq_num, tlv_seq_num, tlv_bitmap_len;
+ int tlv_buf_left = len;
+ int ret;
+ u8 *tmp;
+
+ nxpwifi_dbg_dump(priv->adapter, EVT_D, "RXBA_SYNC event:",
+ event_buf, len);
+ while (tlv_buf_left > sizeof(*tlv_rxba)) {
+ tlv_type = le16_to_cpu(tlv_rxba->header.type);
+ tlv_len = le16_to_cpu(tlv_rxba->header.len);
+ if (size_add(sizeof(tlv_rxba->header), tlv_len) > tlv_buf_left) {
+ nxpwifi_dbg(priv->adapter, WARN,
+ "TLV size (%zu) overflows event_buf buf_left=%d\n",
+ size_add(sizeof(tlv_rxba->header), tlv_len),
+ tlv_buf_left);
+ return;
+ }
+
+ if (tlv_type != TLV_TYPE_RXBA_SYNC) {
+ nxpwifi_dbg(priv->adapter, ERROR,
+ "Wrong TLV id=0x%x\n", tlv_type);
+ return;
+ }
+
+ tlv_seq_num = le16_to_cpu(tlv_rxba->seq_num);
+ tlv_bitmap_len = le16_to_cpu(tlv_rxba->bitmap_len);
+ if (size_add(sizeof(*tlv_rxba), tlv_bitmap_len) > tlv_buf_left) {
+ nxpwifi_dbg(priv->adapter, WARN,
+ "TLV size (%zu) overflows event_buf buf_left=%d\n",
+ size_add(sizeof(*tlv_rxba), tlv_bitmap_len),
+ tlv_buf_left);
+ return;
+ }
+
+ nxpwifi_dbg(priv->adapter, INFO,
+ "%pM tid=%d seq_num=%d bitmap_len=%d\n",
+ tlv_rxba->mac, tlv_rxba->tid, tlv_seq_num,
+ tlv_bitmap_len);
+
+ rx_reor_tbl_ptr =
+ nxpwifi_11n_get_rx_reorder_tbl(priv, tlv_rxba->tid,
+ tlv_rxba->mac);
+ if (!rx_reor_tbl_ptr) {
+ nxpwifi_dbg(priv->adapter, ERROR,
+ "Can not find rx_reorder_tbl!");
+ return;
+ }
+
+ for (i = 0; i < tlv_bitmap_len; i++) {
+ for (j = 0 ; j < 8; j++) {
+ if (tlv_rxba->bitmap[i] & (1 << j)) {
+ seq_num = (MAX_TID_VALUE - 1) &
+ (tlv_seq_num + i * 8 + j);
+
+ nxpwifi_dbg(priv->adapter, ERROR,
+ "drop packet,seq=%d\n",
+ seq_num);
+
+ ret = nxpwifi_11n_rx_reorder_pkt
+ (priv, seq_num, tlv_rxba->tid,
+ tlv_rxba->mac, 0, NULL);
+
+ if (ret)
+ nxpwifi_dbg(priv->adapter,
+ ERROR,
+ "Fail to drop packet");
+ }
+ }
+ }
+
+ tlv_buf_left -= (sizeof(tlv_rxba->header) + tlv_len);
+ tmp = (u8 *)tlv_rxba + sizeof(tlv_rxba->header) + tlv_len;
+ tlv_rxba = (struct nxpwifi_ie_types_rxba_sync *)tmp;
+ }
+}
diff --git a/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h b/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h
new file mode 100644
index 000000000000..db95d9db5d1f
--- /dev/null
+++ b/drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h
@@ -0,0 +1,71 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * NXP Wireless LAN device driver: 802.11n RX Re-ordering
+ *
+ * Copyright 2011-2024 NXP
+ */
+
+#ifndef _NXPWIFI_11N_RXREORDER_H_
+#define _NXPWIFI_11N_RXREORDER_H_
+
+#define MIN_FLUSH_TIMER_MS 50
+#define MIN_FLUSH_TIMER_15_MS 15
+#define NXPWIFI_BA_WIN_SIZE_32 32
+
+#define PKT_TYPE_BAR 0xE7
+#define MAX_TID_VALUE (2 << 11)
+#define TWOPOW11 (2 << 10)
+
+#define BLOCKACKPARAM_TID_POS 2
+#define BLOCKACKPARAM_WINSIZE_POS 6
+#define DELBA_TID_POS 12
+#define DELBA_INITIATOR_POS 11
+#define TYPE_DELBA_SENT 1
+#define TYPE_DELBA_RECEIVE 2
+#define IMMEDIATE_BLOCK_ACK 0x2
+
+#define ADDBA_RSP_STATUS_ACCEPT 0
+
+#define NXPWIFI_DEF_11N_RX_SEQ_NUM 0xffff
+#define BA_SETUP_MAX_PACKET_THRESHOLD 16
+#define BA_SETUP_PACKET_OFFSET 16
+
+enum nxpwifi_rxreor_flags {
+ RXREOR_FORCE_NO_DROP = 1 << 0,
+ RXREOR_INIT_WINDOW_SHIFT = 1 << 1,
+};
+
+static inline void nxpwifi_reset_11n_rx_seq_num(struct nxpwifi_private *priv)
+{
+ memset(priv->rx_seq, 0xff, sizeof(priv->rx_seq));
+}
+
+int nxpwifi_11n_rx_reorder_pkt(struct nxpwifi_private *priv,
+ u16 seq_num,
+ u16 tid, u8 *ta,
+ u8 pkttype, void *payload);
+void nxpwifi_del_ba_tbl(struct nxpwifi_private *priv, int tid,
+ u8 *peer_mac, u8 type, int initiator);
+void nxpwifi_11n_ba_stream_timeout(struct nxpwifi_private *priv,
+ struct host_cmd_ds_11n_batimeout *event);
+int nxpwifi_ret_11n_addba_resp(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command
+ *resp);
+int nxpwifi_cmd_11n_delba(struct host_cmd_ds_command *cmd,
+ void *data_buf);
+int nxpwifi_cmd_11n_addba_rsp_gen(struct nxpwifi_private *priv,
+ struct host_cmd_ds_command *cmd,
+ struct host_cmd_ds_11n_addba_req
+ *cmd_addba_req);
+int nxpwifi_cmd_11n_addba_req(struct host_cmd_ds_command *cmd,
+ void *data_buf);
+void nxpwifi_11n_cleanup_reorder_tbl(struct nxpwifi_private *priv);
+struct nxpwifi_rx_reorder_tbl *
+nxpwifi_11n_get_rxreorder_tbl(struct nxpwifi_private *priv, int tid, u8 *ta);
+struct nxpwifi_rx_reorder_tbl *
+nxpwifi_11n_get_rx_reorder_tbl(struct nxpwifi_private *priv, int tid, u8 *ta);
+void nxpwifi_11n_del_rx_reorder_tbl_by_ta(struct nxpwifi_private *priv, u8 *ta);
+void nxpwifi_update_rxreor_flags(struct nxpwifi_adapter *adapter, u8 flags);
+void nxpwifi_11n_rxba_sync_event(struct nxpwifi_private *priv,
+ u8 *event_buf, u16 len);
+#endif /* _NXPWIFI_11N_RXREORDER_H_ */
--
2.34.1
^ permalink raw reply related
* [PATCH v11 01/22] mmc: core: add NXP IW61x base ID and block size quirk
From: Jeff Chen @ 2026-04-28 19:40 UTC (permalink / raw)
To: linux-wireless
Cc: linux-kernel, ulf.hansson, johannes, francesco, wyatt.hsu,
s.hauer, Jeff Chen
In-Reply-To: <20260428194021.785252-1-jeff.chen_1@nxp.com>
The NXP IW61x series SDIO chipset identifies itself with a base card ID
(0x0204) during the initial MMC bus scan, while the specific WLAN
function reports a different ID (0x0205).
To ensure that the MMC_QUIRK_BLKSZ_FOR_BYTE_MODE quirk is correctly
inherited by all SDIO functions (including Wi-Fi), it must be attached
to the base card ID at the core level.
Add the SDIO_DEVICE_ID_NXP_IW61X_BASE definition and apply the required
fixup in the SDIO quirk table.
Signed-off-by: Jeff Chen <jeff.chen_1@nxp.com>
---
drivers/mmc/core/quirks.h | 3 +++
include/linux/mmc/sdio_ids.h | 1 +
2 files changed, 4 insertions(+)
diff --git a/drivers/mmc/core/quirks.h b/drivers/mmc/core/quirks.h
index 940549d3b95d..ae3ece89d0aa 100644
--- a/drivers/mmc/core/quirks.h
+++ b/drivers/mmc/core/quirks.h
@@ -208,6 +208,9 @@ static const struct mmc_fixup __maybe_unused sdio_fixup_methods[] = {
SDIO_FIXUP(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887_F0,
add_limit_rate_quirk, 150000000),
+ SDIO_FIXUP(SDIO_VENDOR_ID_NXP, SDIO_DEVICE_ID_NXP_IW61X_BASE,
+ add_quirk, MMC_QUIRK_BLKSZ_FOR_BYTE_MODE),
+
END_FIXUP
};
diff --git a/include/linux/mmc/sdio_ids.h b/include/linux/mmc/sdio_ids.h
index 0685dd717e85..7dac5428afe0 100644
--- a/include/linux/mmc/sdio_ids.h
+++ b/include/linux/mmc/sdio_ids.h
@@ -118,6 +118,7 @@
#define SDIO_DEVICE_ID_MICROCHIP_WILC1000 0x5347
#define SDIO_VENDOR_ID_NXP 0x0471
+#define SDIO_DEVICE_ID_NXP_IW61X_BASE 0x0204
#define SDIO_DEVICE_ID_NXP_IW61X 0x0205
#define SDIO_VENDOR_ID_REALTEK 0x024c
--
2.34.1
^ permalink raw reply related
* [PATCH v11 00/22] wifi: nxpwifi: create nxpwifi to support iw61x
From: Jeff Chen @ 2026-04-28 19:39 UTC (permalink / raw)
To: linux-wireless
Cc: linux-kernel, ulf.hansson, johannes, francesco, wyatt.hsu,
s.hauer, Jeff Chen
This series adds a new full-MAC Wi-Fi driver `nxpwifi` to support NXP
IW611/IW612 chip family. These chips are tri-radio single-chip solutions
with Wi-Fi 6(1x1, 2.4/5 GHz), Bluetooth 5.4, and IEEE 802.15.4.
Communication with the external host is via SDIO interface. The driver is
tested on i.MX8M Mini EVK in both STA and AP mode.
This driver is not based on mac80211. It derives from mwifiex, but due to
significant differences in firmware architecture, host command interface,
and supported features, it was not feasible to extend mwifiex without risk
of regressions. Thus, a new driver is introduced. Future NXP Wi-Fi chipsets
will also be supported under `nxpwifi`.
The driver passes checkpatch. WPA2/WPA3 personal/enterprise is currently
handled in host via wpa_supplicant/hostapd.
v4 adds support for TWT, monitor mode, WPA3 Enterprise Suite-B, and various
fixes and improvements. See below for full changelog.
Data sheet is available at:
https://www.nxp.com/docs/en/data-sheet/IW612.pdf
Firmware binaries can be obtained from:
https://github.com/nxp-imx/imx-firmware/tree/lf-6.12.34_2.1.0/nxp/FwImage_IW612_SD/
Change history:
v11:
- Added MMC core support for NXP IW61x base SDIO card ID, ensuring that the
MMC_QUIRK_BLKSZ_FOR_BYTE_MODE quirk is applied at the card level rather
than from the SDIO function driver.
This addresses the IW61x SDIO identification behavior, where the base card
reports one ID during initial bus scan while the WLAN function reports a
different ID, and aligns quirk handling with upstream MMC architecture.
- Cleaned up legacy ioctl-style command usage in cfg80211 paths by removing
direct nxpwifi_send_cmd() invocations and routing these operations through
explicit driver helper functions. This reduces duplicated control logic,
clarifies command ownership, and aligns nxpwifi with the expected
cfg80211-based control flow.
v10:
- Removed all remaining OF code, since DT bindings were dropped and
OF usage is not allowed without a corresponding schema.
- Updated all commit subjects to imperative mood and fixed non-imperative
wording in several commit messages.
v9:
SDIO updates (addressing v8 review feedback)
--------------------------------------------
- Dropped mandatory Device Tree matching in SDIO probe. DT parsing is
now optional and no longer affects probe success. All unused OFi
match logic was removed.
- Removed pr_debug() and all probe()/remove() entry/exit prints. SDIO
now stays silent on success, consistent with kernel expectations.
- Removed legacy assignment of MMC_QUIRK_BLKSZ_FOR_BYTE_MODE.
- Dropped deprecated `.owner = THIS_MODULE` from struct sdio_driver.
- Reworked SDIO comments to follow current kernel style guidelines and
removed verbose “This function …” comment blocks.
- Modernized firmware-ready polling using read_poll_timeout().
- Rate-limited intermittent ISR error messages.
- Replaced sprintf/mdelay/memmove with scnprintf/msleep/memcpy.
- Added missing return value checks to sdio_enable_func() and
sdio_set_block_size().
- Removed the dependency on include/linux/mmc/sdio_ids.h.
This ID table belongs to MMC/SDIO subsystem and is handled separately;
nxpwifi no longer requires this header and the update will be
submitted as an MMC patch.
Devicetree bindings note
------------------------
The previous version included a devicetree binding document for
`nxp,iw61x.yaml`. Since Device Tree support for this device is optional
and not required for current SDIO-based bring-up, the binding has been
dropped from this series. A proper schema will be submitted separately
once DT usage becomes relevant, so that binding review can be handled
in the correct subsystem and without blocking this driver introduction.
Initialization path cleanups (aligned with upstream mwifiex)
------------------------------------------------------------
This series ports three upstream mwifiex cleanups which remove obsolete
asynchronous initialization scaffolding:
- Based-on: c2095eb63319 ("wifi: mwifiex: remove mwifiex_sta_init_cmd() last
argument")
Dropped the unused “init” argument from the STA init command helper.
- Based-on: f996f434aa78 ("wifi: mwifiex: drop asynchronous init waiting code")
Removed all asynchronous-init waiting logic (init_wait_q, last_init_cmd,
INIT_DONE transitional state). Initialization now completes strictly when
the last synchronous command returns.
- Based-on: 659d609bdda5 ("wifi: mwifiex: remove unnecessary queue empty check")
Removed the redundant “command queue empty” check after init; retained
only a WARN_ON() for future regression detection.
General cleanups
----------------
- Numerous comment style fixes across SDIO, HE, VHT/HT, and main files.
- Reduced verbosity across the driver to align with upstream expectations.
- Small structural cleanups and dead-code removals.
v8:
- Standardized multi-line comment style across nxpwifi driver files to Linux kernel
convention.
/*
* ...
*/
No functional changes.
- Fixed workqueue cleanup and error path ordering in nxpwifi_add_card(): ensure
proper termination before resource free to avoid race conditions.
- Corrected spelling mistakes in source code and comments for better readability
(e.g., Dimensions -> Dimensions, interfacces -> interfaces).
- Added Device Tree binding schema for NXP IW61x SDIO devices (nxp,iw61x.yaml),
including properties for compatible, reg, interrupts, wakeup pin, and optional
calibration data.
v7:
- Addressed review feedback from v6
- Removed unused variable `ext_rate_info` in `nxpwifi_rxpdinfo_to_radiotapinfo()
- Radiotap handling fixes:
- Converted fields to `__le16`/`__le64`
- Applied `cpu_to_le16()`/`cpu_to_le64()` for endian correctness
- Replaced `jiffies` with `ktime_get_ns()/1000` for timestamp
- Validated channel frequency conversion and removed redundant code
- General cleanup of endian conversions and Sparse warnings
- Improved HE capability setup via `_ieee80211_set_sband_iftype_data()`
- TWT configuration fixes:
- Updated structs to `__le16`/`__le32`
- Corrected debugfs write helpers for endian conversions
- Removed redundant conversions in `nxpwifi_cmd_twt_cfg()`
- Scan handling fixes:
- Changed OUI variables to `__be32`
- Used `le16_to_cpu()` for `ext_cap->header.len`
- Moved element pointer declaration outside `switch`
- HW spec parsing fix:
- Added `le32_to_cpu()` before `GET_MPDU_DENSITY()`
- Cfg80211 handling fix:
- Moved `legacy_rates[]` definition outside `switch` block
v4:
- Added support for TWT (STA mode)
- Added support for Monitor mode
- Added support for WPA3 Enterprise Suite-B
- Bug fix: In BGN/AN HT40 mode, throughput was 50% lower than expected
- Bug fix: In STA 2.4G HE40 mode, throughput was 80% lower than expected
- Use wiphy work instead of general workqueue for cfg80211 ops
- Introduced RCU protection for ba, rx_reorder, and sta_lists
- Used per-TID spinlock for tx_ba / rx_reorder lists to improve
concurrency
- Replaced mutex_lock with wiphy_lock
- Reverted "use tasklet for Rx" (back to workqueue)
- Refactored HE capability handling for better clarity and
maintainability
- Used standard kernel helpers for MAC address handling
- Replaced proprietary nxpwifi_ieee80211 with standard ieee80211_mgmt
structure
- Used u32_get_bits() for VHT capability field access
- Replaced LOW_PRIO_TID with TC_PRIO_BESTEFFORT for skb priority
- Removed static WPA/RSN OUI table; now derived from cipher suite ID
- Removed redundant helper functions: has_vendor_hdr and has_ieee_hdr
v3:
- Enable 802.11ax (Wi-Fi 6) for both AP and STA mode.
- Extend driver version string with hotfix number.
- Remove Rx mlme work.
- Remove all useless check of netif_carrier_ok().
- Merge decl.h to cfg.h.
- Remove unnecessary check for wiphy parameters setting.
- Synchronize following commits from Mwifiex:
wifi: mwifiex: replace open-coded module_sdio_driver()
wifi: mwifiex: Fix interface type change
wifi: mwifiex: Do not return unused priv in mwifiex_get_priv_by_id()
wifi: mwifiex: increase max_num_akm_suites
wifi: mwifiex: duplicate static structs used in driver instances
wifi: mwifiex: keep mwifiex_cfg80211_ops constant
Jeff Chen (22):
mmc: core: add NXP IW61x base ID and block size quirk
wifi: nxpwifi: add 802.11n support for STA and AP modes
wifi: nxpwifi: add initial 802.11ac support for STA and AP modes
wifi: nxpwifi: add initial 802.11ax support for STA and AP modes
wifi: nxpwifi: add 802.11h (DFS/TPC) support
wifi: nxpwifi: add WMM support
wifi: nxpwifi: add scan support
wifi: nxpwifi: add join and association support
wifi: nxpwifi: add channel/frequency/power (cfp) support
wifi: nxpwifi: add configuration support
wifi: nxpwifi: implement cfg80211 ops for STA and AP modes
wifi: nxpwifi: add firmware command and TLV definitions
wifi: nxpwifi: add command and event handling infrastructure
wifi: nxpwifi: add data path support for STA and AP modes
wifi: nxpwifi: add debugfs support for diagnostics and testing
wifi: nxpwifi: add ethtool support for Wake-on-LAN
wifi: nxpwifi: add utility functions and element handling support
wifi: nxpwifi: add driver initialization and shutdown support
wifi: nxpwifi: add core driver implementation
wifi: nxpwifi: add initial SDIO bus driver support
wifi: nxpwifi: add Kconfig and Makefile for kernel integration
wifi: nxpwifi: add MAINTAINERS entry for nxpwifi driver
MAINTAINERS | 7 +
drivers/mmc/core/quirks.h | 3 +
drivers/net/wireless/Kconfig | 1 +
drivers/net/wireless/Makefile | 1 +
drivers/net/wireless/nxp/Kconfig | 17 +
drivers/net/wireless/nxp/Makefile | 3 +
drivers/net/wireless/nxp/nxpwifi/11ac.c | 280 ++
drivers/net/wireless/nxp/nxpwifi/11ac.h | 33 +
drivers/net/wireless/nxp/nxpwifi/11ax.c | 594 +++
drivers/net/wireless/nxp/nxpwifi/11ax.h | 73 +
drivers/net/wireless/nxp/nxpwifi/11h.c | 339 ++
drivers/net/wireless/nxp/nxpwifi/11n.c | 837 ++++
drivers/net/wireless/nxp/nxpwifi/11n.h | 158 +
drivers/net/wireless/nxp/nxpwifi/11n_aggr.c | 251 ++
drivers/net/wireless/nxp/nxpwifi/11n_aggr.h | 21 +
.../net/wireless/nxp/nxpwifi/11n_rxreorder.c | 826 ++++
.../net/wireless/nxp/nxpwifi/11n_rxreorder.h | 71 +
drivers/net/wireless/nxp/nxpwifi/Kconfig | 22 +
drivers/net/wireless/nxp/nxpwifi/Makefile | 39 +
drivers/net/wireless/nxp/nxpwifi/cfg.h | 1019 +++++
drivers/net/wireless/nxp/nxpwifi/cfg80211.c | 3929 +++++++++++++++++
drivers/net/wireless/nxp/nxpwifi/cfg80211.h | 18 +
drivers/net/wireless/nxp/nxpwifi/cfp.c | 458 ++
drivers/net/wireless/nxp/nxpwifi/cmdevt.c | 1310 ++++++
drivers/net/wireless/nxp/nxpwifi/cmdevt.h | 122 +
drivers/net/wireless/nxp/nxpwifi/debugfs.c | 1094 +++++
drivers/net/wireless/nxp/nxpwifi/ethtool.c | 58 +
drivers/net/wireless/nxp/nxpwifi/fw.h | 2380 ++++++++++
drivers/net/wireless/nxp/nxpwifi/ie.c | 480 ++
drivers/net/wireless/nxp/nxpwifi/init.c | 607 +++
drivers/net/wireless/nxp/nxpwifi/join.c | 787 ++++
drivers/net/wireless/nxp/nxpwifi/main.c | 1673 +++++++
drivers/net/wireless/nxp/nxpwifi/main.h | 1776 ++++++++
drivers/net/wireless/nxp/nxpwifi/scan.c | 2695 +++++++++++
drivers/net/wireless/nxp/nxpwifi/sdio.c | 2327 ++++++++++
drivers/net/wireless/nxp/nxpwifi/sdio.h | 340 ++
drivers/net/wireless/nxp/nxpwifi/sta_cfg.c | 1165 +++++
drivers/net/wireless/nxp/nxpwifi/sta_cmd.c | 3387 ++++++++++++++
drivers/net/wireless/nxp/nxpwifi/sta_event.c | 862 ++++
drivers/net/wireless/nxp/nxpwifi/sta_rx.c | 242 +
drivers/net/wireless/nxp/nxpwifi/sta_tx.c | 190 +
drivers/net/wireless/nxp/nxpwifi/txrx.c | 352 ++
drivers/net/wireless/nxp/nxpwifi/uap_cmd.c | 1256 ++++++
drivers/net/wireless/nxp/nxpwifi/uap_event.c | 488 ++
drivers/net/wireless/nxp/nxpwifi/uap_txrx.c | 478 ++
drivers/net/wireless/nxp/nxpwifi/util.c | 1523 +++++++
drivers/net/wireless/nxp/nxpwifi/util.h | 155 +
drivers/net/wireless/nxp/nxpwifi/wmm.c | 1313 ++++++
drivers/net/wireless/nxp/nxpwifi/wmm.h | 77 +
include/linux/mmc/sdio_ids.h | 1 +
50 files changed, 36138 insertions(+)
create mode 100644 drivers/net/wireless/nxp/Kconfig
create mode 100644 drivers/net/wireless/nxp/Makefile
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ac.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ax.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11ax.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11h.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_aggr.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/11n_rxreorder.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/Kconfig
create mode 100644 drivers/net/wireless/nxp/nxpwifi/Makefile
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfg80211.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cfp.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/cmdevt.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/debugfs.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/ethtool.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/fw.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/ie.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/init.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/join.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/main.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/scan.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sdio.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_cfg.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_cmd.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_event.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_rx.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/sta_tx.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/txrx.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_cmd.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_event.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/uap_txrx.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/util.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/util.h
create mode 100644 drivers/net/wireless/nxp/nxpwifi/wmm.c
create mode 100644 drivers/net/wireless/nxp/nxpwifi/wmm.h
base-commit: 7baf5857e15d722776898510a10546d6b2f18645
--
2.34.1
^ permalink raw reply
* Re: [PATCH v4 11/15] media: qcom: Switch to generic PAS TZ APIs
From: Mukesh Ojha @ 2026-04-28 19:37 UTC (permalink / raw)
To: Sumit Garg
Cc: andersson, konradybcio, linux-arm-msm, devicetree, dri-devel,
freedreno, linux-media, netdev, linux-wireless, ath12k,
linux-remoteproc, robh, krzk+dt, conor+dt, robin.clark, sean,
akhilpo, lumag, abhinav.kumar, jesszhan0024, marijn.suijten,
airlied, simona, vikash.garodia, dikshita.agarwal, bod, mchehab,
elder, andrew+netdev, davem, edumazet, kuba, pabeni, jjohnson,
mathieu.poirier, trilokkumar.soni, pavan.kondeti, jorge.ramirez,
tonyh, vignesh.viswanathan, srinivas.kandagatla, amirreza.zarrabi,
jens.wiklander, op-tee, apurupa, skare, linux-kernel, Sumit Garg
In-Reply-To: <20260427095603.1157963-12-sumit.garg@kernel.org>
On Mon, Apr 27, 2026 at 03:25:59PM +0530, Sumit Garg wrote:
> From: Sumit Garg <sumit.garg@oss.qualcomm.com>
>
> Switch qcom media client drivers over to generic PAS TZ APIs. Generic PAS
> TZ service allows to support multiple TZ implementation backends like QTEE
> based SCM PAS service, OP-TEE based PAS service and any further future TZ
> backend service.
>
> Along with that pass proper PAS ID to set_remote_state API. As per testing
> the SCM backend just ignores it while OP-TEE makes use of it to for proper
> book keeping purpose.
When we use 'Along with' or 'while at it', patch is doing two things and
not one.
>
> Signed-off-by: Sumit Garg <sumit.garg@oss.qualcomm.com>
> ---
> drivers/media/platform/qcom/iris/Kconfig | 25 ++++++++++---------
> .../media/platform/qcom/iris/iris_firmware.c | 9 ++++---
> drivers/media/platform/qcom/venus/Kconfig | 1 +
> drivers/media/platform/qcom/venus/firmware.c | 11 ++++----
> 4 files changed, 25 insertions(+), 21 deletions(-)
>
> diff --git a/drivers/media/platform/qcom/iris/Kconfig b/drivers/media/platform/qcom/iris/Kconfig
> index 3c803a05305a..f54b759c18aa 100644
> --- a/drivers/media/platform/qcom/iris/Kconfig
> +++ b/drivers/media/platform/qcom/iris/Kconfig
> @@ -1,13 +1,14 @@
> config VIDEO_QCOM_IRIS
> - tristate "Qualcomm iris V4L2 decoder driver"
> - depends on VIDEO_DEV
> - depends on ARCH_QCOM || COMPILE_TEST
> - select V4L2_MEM2MEM_DEV
> - select QCOM_MDT_LOADER if ARCH_QCOM
> - select QCOM_SCM
> - select VIDEOBUF2_DMA_CONTIG
> - help
> - This is a V4L2 driver for Qualcomm iris video accelerator
> - hardware. It accelerates decoding operations on various
> - Qualcomm SoCs.
> - To compile this driver as a module choose m here.
> + tristate "Qualcomm iris V4L2 decoder driver"
> + depends on VIDEO_DEV
> + depends on ARCH_QCOM || COMPILE_TEST
> + select V4L2_MEM2MEM_DEV
> + select QCOM_MDT_LOADER if ARCH_QCOM
> + select QCOM_SCM
> + select QCOM_PAS
> + select VIDEOBUF2_DMA_CONTIG
> + help
> + This is a V4L2 driver for Qualcomm iris video accelerator
> + hardware. It accelerates decoding operations on various
> + Qualcomm SoCs.
> + To compile this driver as a module choose m here.
Here, Space replaced by Tabs just for one line.., should be fine.
> diff --git a/drivers/media/platform/qcom/iris/iris_firmware.c b/drivers/media/platform/qcom/iris/iris_firmware.c
> index 5f408024e967..856fa6a79064 100644
> --- a/drivers/media/platform/qcom/iris/iris_firmware.c
> +++ b/drivers/media/platform/qcom/iris/iris_firmware.c
> @@ -4,6 +4,7 @@
> */
>
> #include <linux/firmware.h>
> +#include <linux/firmware/qcom/qcom_pas.h>
> #include <linux/firmware/qcom/qcom_scm.h>
> #include <linux/of_address.h>
> #include <linux/of_reserved_mem.h>
> @@ -79,7 +80,7 @@ int iris_fw_load(struct iris_core *core)
> return -ENOMEM;
> }
>
> - ret = qcom_scm_pas_auth_and_reset(core->iris_platform_data->pas_id);
> + ret = qcom_pas_auth_and_reset(core->iris_platform_data->pas_id);
> if (ret) {
> dev_err(core->dev, "auth and reset failed: %d\n", ret);
> return ret;
> @@ -93,7 +94,7 @@ int iris_fw_load(struct iris_core *core)
> cp_config->cp_nonpixel_size);
> if (ret) {
> dev_err(core->dev, "qcom_scm_mem_protect_video_var failed: %d\n", ret);
> - qcom_scm_pas_shutdown(core->iris_platform_data->pas_id);
> + qcom_pas_shutdown(core->iris_platform_data->pas_id);
> return ret;
> }
> }
> @@ -103,10 +104,10 @@ int iris_fw_load(struct iris_core *core)
>
> int iris_fw_unload(struct iris_core *core)
> {
> - return qcom_scm_pas_shutdown(core->iris_platform_data->pas_id);
> + return qcom_pas_shutdown(core->iris_platform_data->pas_id);
> }
>
> int iris_set_hw_state(struct iris_core *core, bool resume)
> {
> - return qcom_scm_set_remote_state(resume, 0);
> + return qcom_pas_set_remote_state(resume, core->irisi_platform_data->pas_id);
Should be a separate change for qcom_pas_set_remote_state()
> }
> diff --git a/drivers/media/platform/qcom/venus/Kconfig b/drivers/media/platform/qcom/venus/Kconfig
> index ffb731ecd48c..574172724e8f 100644
> --- a/drivers/media/platform/qcom/venus/Kconfig
> +++ b/drivers/media/platform/qcom/venus/Kconfig
> @@ -6,6 +6,7 @@ config VIDEO_QCOM_VENUS
> select OF_DYNAMIC if ARCH_QCOM
> select QCOM_MDT_LOADER if ARCH_QCOM
> select QCOM_SCM
> + select QCOM_PAS
> select VIDEOBUF2_DMA_CONTIG
> select V4L2_MEM2MEM_DEV
> help
> diff --git a/drivers/media/platform/qcom/venus/firmware.c b/drivers/media/platform/qcom/venus/firmware.c
> index 1de7436713ed..3c0727ea137d 100644
> --- a/drivers/media/platform/qcom/venus/firmware.c
> +++ b/drivers/media/platform/qcom/venus/firmware.c
> @@ -12,6 +12,7 @@
> #include <linux/of_reserved_mem.h>
> #include <linux/platform_device.h>
> #include <linux/of_device.h>
> +#include <linux/firmware/qcom/qcom_pas.h>
> #include <linux/firmware/qcom/qcom_scm.h>
> #include <linux/sizes.h>
> #include <linux/soc/qcom/mdt_loader.h>
> @@ -58,7 +59,7 @@ int venus_set_hw_state(struct venus_core *core, bool resume)
> int ret;
>
> if (core->use_tz) {
> - ret = qcom_scm_set_remote_state(resume, 0);
> + ret = qcom_pas_set_remote_state(resume, VENUS_PAS_ID);
This too..
> if (resume && ret == -EINVAL)
> ret = 0;
> return ret;
> @@ -218,7 +219,7 @@ int venus_boot(struct venus_core *core)
> int ret;
>
> if (!IS_ENABLED(CONFIG_QCOM_MDT_LOADER) ||
> - (core->use_tz && !qcom_scm_is_available()))
> + (core->use_tz && !qcom_pas_is_available()))
> return -EPROBE_DEFER;
>
> ret = of_property_read_string_index(dev->of_node, "firmware-name", 0,
> @@ -236,7 +237,7 @@ int venus_boot(struct venus_core *core)
> core->fw.mem_phys = mem_phys;
>
> if (core->use_tz)
> - ret = qcom_scm_pas_auth_and_reset(VENUS_PAS_ID);
> + ret = qcom_pas_auth_and_reset(VENUS_PAS_ID);
> else
> ret = venus_boot_no_tz(core, mem_phys, mem_size);
>
> @@ -259,7 +260,7 @@ int venus_boot(struct venus_core *core)
> res->cp_nonpixel_start,
> res->cp_nonpixel_size);
> if (ret) {
> - qcom_scm_pas_shutdown(VENUS_PAS_ID);
> + qcom_pas_shutdown(VENUS_PAS_ID);
> dev_err(dev, "set virtual address ranges fail (%d)\n",
> ret);
> return ret;
> @@ -274,7 +275,7 @@ int venus_shutdown(struct venus_core *core)
> int ret;
>
> if (core->use_tz)
> - ret = qcom_scm_pas_shutdown(VENUS_PAS_ID);
> + ret = qcom_pas_shutdown(VENUS_PAS_ID);
> else
> ret = venus_shutdown_no_tz(core);
>
> --
> 2.51.0
with above change
Reviewed-by: Mukesh Ojha <mukesh.ojha@oss.qualcomm.com>
>
--
-Mukesh Ojha
^ permalink raw reply
* Re: [PATCH net-next] net: Consistently define pci_device_ids using named initializers
From: Johannes Berg @ 2026-04-28 19:35 UTC (permalink / raw)
To: Uwe Kleine-König (The Capable Hub), Michael Grzeschik,
Andrew Lunn, David S. Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Marc Kleine-Budde, Vincent Mailhol, Krzysztof Halasa
Cc: Markus Schneider-Pargmann, Steffen Klassert, David Dillow,
Ion Badulescu, Mark Einon, Rasesh Mody, GR-Linux-NIC-Dev,
Sudarsana Kalluru, Manish Chopra, Potnuri Bharat Teja,
Denis Kirjanov, Jijie Shao, Jian Shen, Cai Huoqing, Fan Gong,
Tony Nguyen, Przemek Kitszel, Tariq Toukan, Saeed Mahameed,
Leon Romanovsky, Mark Bloch, Ido Schimmel, Petr Machata,
Yibo Dong, Simon Horman, Heiner Kallweit, nic_swsd, Jiri Pirko,
Francois Romieu, Daniele Venzano, Samuel Chessman, Jiawen Wu,
Mengyuan Lou, Kevin Curtis, Arend van Spriel, Stanislav Yakovlev,
Richard Cochran, Kees Cook, Thomas Gleixner, Thomas Fourier,
Ingo Molnar, Kory Maincent, Zilin Guan, Marco Crivellari,
Vadim Fedorenko, Jacob Keller, Philipp Stanner, Bjorn Helgaas,
Yeounsu Moon, Denis Benato, Peiyang Wang, Yonglong Liu,
Andy Shevchenko, Yicong Hui, Randy Dunlap, MD Danish Anwar,
Nathan Chancellor, Sai Krishna, Ethan Nelson-Moore,
Larysa Zaremba, Joe Damato, Double Lo, Chi-hsien Lin,
Colin Ian King, netdev, linux-kernel, linux-can, linux-parisc,
intel-wired-lan, linux-rdma, oss-drivers, linux-wireless,
brcm80211, brcm80211-dev-list.pdl
In-Reply-To: <20260428171845.2288395-2-u.kleine-koenig@baylibre.com>
On Tue, 2026-04-28 at 19:18 +0200, Uwe Kleine-König (The Capable Hub)
wrote:
>
> I handled all of drivers/net/ in a single patch, please tell me if I
> should split by subsystem.
I guess wireless would be the one not in net-next initially normally,
but
> .../broadcom/brcm80211/brcmfmac/pcie.c | 17 +-
> drivers/net/wireless/intel/ipw2x00/ipw2200.c | 52 +-
Nobody has been touching *that* code, so from my perspective this is
fine.
Acked-by: Johannes Berg <johannes@sipsolutions.net>
johannes
^ permalink raw reply
* [PATCH] wifi: mt76: mt7915: fix GENMASK for chain 3 RSSI in mt7915_mac_sta_poll()
From: Ankit Dange @ 2026-04-28 19:22 UTC (permalink / raw)
To: nbd, lorenzo, linux-wireless
Cc: ryder.lee, linux-kernel, linux-mediatek, ankitdange37
The RCPI values of response frames are stored as four consecutive
bytes in WTBL DW30. The bitmask for extracting chain 3 RCPI uses
GENMASK(31, 14) which is an 18-bit field overlapping with chains 1
and 2. Fix it to GENMASK(31, 24) to correctly extract the 8-bit
RCPI value for chain 3.
On devices with fewer than 4 antenna chains this bug is masked
because mt76_rx_signal() skips chains not present in antenna_mask.
On 4x4 configurations the corrupted chain 3 value feeds into the
combined ACK signal strength calculation.
Tested on Yuncore AX820 (MT7915, 2x2) by reading raw DW30 register
values and comparing FIELD_GET results for both masks. With
GENMASK(31, 14), chain 3 produces garbage values (e.g., -112 dBm
from a register value of 0xFFFF4248 where the correct result is
+17, indicating an unused chain). No regression on 2x2 operation.
Fixes: 94b335fa88e1 ("wifi: mt76: mt7915: add ack signal support")
Signed-off-by: Ankit Dange <ankitdange37@gmail.com>
---
mt7915/mac.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/mt7915/mac.c b/mt7915/mac.c
index b581d8f9..3d7d71ac 100644
--- a/mt7915/mac.c
+++ b/mt7915/mac.c
@@ -221,7 +221,7 @@ static void mt7915_mac_sta_poll(struct mt7915_dev *dev)
rssi[0] = to_rssi(GENMASK(7, 0), val);
rssi[1] = to_rssi(GENMASK(15, 8), val);
rssi[2] = to_rssi(GENMASK(23, 16), val);
- rssi[3] = to_rssi(GENMASK(31, 14), val);
+ rssi[3] = to_rssi(GENMASK(31, 24), val);
msta->ack_signal =
mt76_rx_signal(msta->vif->phy->mt76->antenna_mask, rssi);
--
2.43.0
^ permalink raw reply related
* [PATCH net-next] net: Consistently define pci_device_ids using named initializers
From: Uwe Kleine-König (The Capable Hub) @ 2026-04-28 17:18 UTC (permalink / raw)
To: Michael Grzeschik, Andrew Lunn, David S. Miller, Eric Dumazet,
Jakub Kicinski, Paolo Abeni, Marc Kleine-Budde, Vincent Mailhol,
Krzysztof Halasa, Johannes Berg
Cc: Markus Schneider-Pargmann, Steffen Klassert, David Dillow,
Ion Badulescu, Mark Einon, Rasesh Mody, GR-Linux-NIC-Dev,
Sudarsana Kalluru, Manish Chopra, Potnuri Bharat Teja,
Denis Kirjanov, Jijie Shao, Jian Shen, Cai Huoqing, Fan Gong,
Tony Nguyen, Przemek Kitszel, Tariq Toukan, Saeed Mahameed,
Leon Romanovsky, Mark Bloch, Ido Schimmel, Petr Machata,
Yibo Dong, Simon Horman, Heiner Kallweit, nic_swsd, Jiri Pirko,
Francois Romieu, Daniele Venzano, Samuel Chessman, Jiawen Wu,
Mengyuan Lou, Kevin Curtis, Arend van Spriel, Stanislav Yakovlev,
Richard Cochran, Kees Cook, Thomas Gleixner, Thomas Fourier,
Ingo Molnar, Kory Maincent, Zilin Guan, Marco Crivellari,
Vadim Fedorenko, Jacob Keller, Philipp Stanner, Bjorn Helgaas,
Yeounsu Moon, Denis Benato, Peiyang Wang, Yonglong Liu,
Andy Shevchenko, Yicong Hui, Randy Dunlap, MD Danish Anwar,
Nathan Chancellor, Sai Krishna, Ethan Nelson-Moore,
Larysa Zaremba, Joe Damato, Double Lo, Chi-hsien Lin,
Colin Ian King, netdev, linux-kernel, linux-can, linux-parisc,
intel-wired-lan, linux-rdma, oss-drivers, linux-wireless,
brcm80211, brcm80211-dev-list.pdl
... and PCI device helpers.
The various struct pci_device_id arrays were initialized mostly by one
the PCI_DEVICE macros and then list expressions. The latter isn't easily
readable if you're not into PCI. Using named initializers is more
explicit and thus easier to parse.
Also use PCI_DEVICE* helper macros to assign .vendor, .device,
.subvendor and .subdevice where appropriate and skip explicit
assignments of 0 (which the compiler takes care of).
The secret plan is to make struct pci_device_id::driver_data an
anonymous union (similar to
https://lore.kernel.org/all/cover.1776579304.git.u.kleine-koenig@baylibre.com/)
and that requires named initializers. But it's also a nice cleanup on
its own.
This change doesn't introduce changes to the compiled pci_device_id
arrays. Tested on x86 and arm64.
Signed-off-by: Uwe Kleine-König (The Capable Hub) <u.kleine-koenig@baylibre.com>
---
Hello,
the mentioned follow-up quest allows to do
PCI_DEVICE(0x1571, 0xa203),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
- .driver_data_ptr = &card_info_10mbit,
which gets rid of a bunch of casts and so brings a little bit more type
safety. This patch is a preparation for that.
I handled all of drivers/net/ in a single patch, please tell me if I
should split by subsystem.
Best regards
Uwe
---
drivers/net/arcnet/com20020-pci.c | 242 +++------
drivers/net/can/m_can/m_can_pci.c | 6 +-
drivers/net/can/sja1000/plx_pci.c | 167 +++----
drivers/net/ethernet/3com/3c59x.c | 80 +--
drivers/net/ethernet/3com/typhoon.c | 75 ++-
drivers/net/ethernet/8390/ne2k-pci.c | 24 +-
drivers/net/ethernet/adaptec/starfire.c | 4 +-
drivers/net/ethernet/agere/et131x.c | 6 +-
drivers/net/ethernet/broadcom/bnx2.c | 62 ++-
.../net/ethernet/broadcom/bnx2x/bnx2x_main.c | 50 +-
.../net/ethernet/cavium/liquidio/lio_main.c | 10 +-
.../ethernet/cavium/liquidio/lio_vf_main.c | 7 +-
drivers/net/ethernet/chelsio/cxgb/common.h | 2 +-
drivers/net/ethernet/chelsio/cxgb/subr.c | 2 +-
.../net/ethernet/chelsio/cxgb3/cxgb3_main.c | 4 +-
.../net/ethernet/chelsio/cxgb4/cxgb4_main.c | 4 +-
.../ethernet/chelsio/cxgb4vf/cxgb4vf_main.c | 4 +-
drivers/net/ethernet/dec/tulip/de2104x.c | 6 +-
drivers/net/ethernet/dec/tulip/dmfe.c | 12 +-
drivers/net/ethernet/dec/tulip/tulip_core.c | 78 +--
drivers/net/ethernet/dec/tulip/uli526x.c | 6 +-
drivers/net/ethernet/dec/tulip/winbond-840.c | 13 +-
drivers/net/ethernet/dlink/dl2k.h | 12 +-
drivers/net/ethernet/dlink/sundance.c | 14 +-
drivers/net/ethernet/fealnx.c | 8 +-
.../net/ethernet/hisilicon/hibmcge/hbg_main.c | 2 +-
.../net/ethernet/hisilicon/hns3/hns3_enet.c | 50 +-
.../hisilicon/hns3/hns3pf/hclge_main.c | 18 +-
.../hisilicon/hns3/hns3vf/hclgevf_main.c | 12 +-
.../net/ethernet/huawei/hinic/hinic_main.c | 12 +-
.../net/ethernet/huawei/hinic3/hinic3_lld.c | 7 +-
drivers/net/ethernet/intel/e100.c | 4 +-
drivers/net/ethernet/intel/e1000e/netdev.c | 471 +++++++++++++-----
drivers/net/ethernet/intel/fm10k/fm10k_pci.c | 10 +-
drivers/net/ethernet/intel/i40e/i40e_main.c | 59 +--
drivers/net/ethernet/intel/iavf/iavf_main.c | 10 +-
drivers/net/ethernet/intel/igb/igb_main.c | 66 +--
drivers/net/ethernet/intel/igbvf/netdev.c | 4 +-
drivers/net/ethernet/intel/igc/igc_main.c | 34 +-
drivers/net/ethernet/intel/ixgbe/ixgbe_main.c | 106 ++--
.../net/ethernet/intel/ixgbevf/ixgbevf_main.c | 49 +-
drivers/net/ethernet/mellanox/mlx4/main.c | 6 +-
.../net/ethernet/mellanox/mlx5/core/main.c | 26 +-
.../net/ethernet/mellanox/mlxsw/spectrum.c | 16 +-
drivers/net/ethernet/micrel/ksz884x.c | 8 +-
.../net/ethernet/mucse/rnpgbe/rnpgbe_main.c | 10 +-
drivers/net/ethernet/natsemi/natsemi.c | 4 +-
drivers/net/ethernet/netronome/nfp/nfp_main.c | 81 +--
.../ethernet/netronome/nfp/nfp_netvf_main.c | 41 +-
drivers/net/ethernet/qlogic/qede/qede_main.c | 20 +-
drivers/net/ethernet/realtek/8139too.c | 52 +-
drivers/net/ethernet/realtek/r8169_main.c | 8 +-
drivers/net/ethernet/rocker/rocker_main.c | 4 +-
drivers/net/ethernet/sis/sis190.c | 6 +-
drivers/net/ethernet/sis/sis900.c | 10 +-
drivers/net/ethernet/smsc/epic100.c | 18 +-
drivers/net/ethernet/sun/cassini.c | 8 +-
drivers/net/ethernet/sun/sungem.c | 26 +-
drivers/net/ethernet/ti/tlan.c | 41 +-
drivers/net/ethernet/wangxun/ngbe/ngbe_main.c | 26 +-
.../net/ethernet/wangxun/ngbevf/ngbevf_main.c | 26 +-
.../net/ethernet/wangxun/txgbe/txgbe_main.c | 18 +-
.../ethernet/wangxun/txgbevf/txgbevf_main.c | 18 +-
drivers/net/wan/farsync.c | 24 +-
drivers/net/wan/pc300too.c | 14 +-
drivers/net/wan/pci200syn.c | 6 +-
drivers/net/wan/wanxl.c | 11 +-
.../broadcom/brcm80211/brcmfmac/pcie.c | 17 +-
drivers/net/wireless/intel/ipw2x00/ipw2200.c | 52 +-
69 files changed, 1308 insertions(+), 1101 deletions(-)
diff --git a/drivers/net/arcnet/com20020-pci.c b/drivers/net/arcnet/com20020-pci.c
index dbadda08dce2..6474c7be2992 100644
--- a/drivers/net/arcnet/com20020-pci.c
+++ b/drivers/net/arcnet/com20020-pci.c
@@ -459,168 +459,88 @@ static struct com20020_pci_card_info card_info_eae_fb2 = {
static const struct pci_device_id com20020pci_id_table[] = {
{
- 0x1571, 0xa001,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0,
+ PCI_DEVICE(0x1571, 0xa001),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa002),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa003),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa004),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa005),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa006),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa007),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa008),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1571, 0xa009),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa00a),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa00b),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa00c),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa00d),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa00e),
+ .driver_data = (kernel_ulong_t)&card_info_5mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa201),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa202),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa203),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa204),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa205),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x1571, 0xa206),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE_SUB(0x10B5, 0x9030, 0x10B5, 0x2978),
+ .driver_data = (kernel_ulong_t)&card_info_sohard,
+ }, {
+ PCI_DEVICE_SUB(0x10B5, 0x9050, 0x10B5, 0x2273),
+ .driver_data = (kernel_ulong_t)&card_info_sohard,
+ }, {
+ PCI_DEVICE_SUB(0x10B5, 0x9050, 0x10B5, 0x3263),
+ .driver_data = (kernel_ulong_t)&card_info_eae_arc1,
+ }, {
+ PCI_DEVICE_SUB(0x10B5, 0x9050, 0x10B5, 0x3292),
+ .driver_data = (kernel_ulong_t)&card_info_eae_ma1,
+ }, {
+ PCI_DEVICE_SUB(0x10B5, 0x9050, 0x10B5, 0x3294),
+ .driver_data = (kernel_ulong_t)&card_info_eae_fb2,
+ }, {
+ PCI_DEVICE(0x14BA, 0x6000),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
+ }, {
+ PCI_DEVICE(0x10B5, 0x2200),
+ .driver_data = (kernel_ulong_t)&card_info_10mbit,
},
- {
- 0x1571, 0xa002,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0,
- },
- {
- 0x1571, 0xa003,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0
- },
- {
- 0x1571, 0xa004,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0,
- },
- {
- 0x1571, 0xa005,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0
- },
- {
- 0x1571, 0xa006,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0
- },
- {
- 0x1571, 0xa007,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0
- },
- {
- 0x1571, 0xa008,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- 0
- },
- {
- 0x1571, 0xa009,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa00a,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa00b,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa00c,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa00d,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa00e,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_5mbit
- },
- {
- 0x1571, 0xa201,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x1571, 0xa202,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x1571, 0xa203,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x1571, 0xa204,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x1571, 0xa205,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x1571, 0xa206,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x10B5, 0x9030,
- 0x10B5, 0x2978,
- 0, 0,
- (kernel_ulong_t)&card_info_sohard
- },
- {
- 0x10B5, 0x9050,
- 0x10B5, 0x2273,
- 0, 0,
- (kernel_ulong_t)&card_info_sohard
- },
- {
- 0x10B5, 0x9050,
- 0x10B5, 0x3263,
- 0, 0,
- (kernel_ulong_t)&card_info_eae_arc1
- },
- {
- 0x10B5, 0x9050,
- 0x10B5, 0x3292,
- 0, 0,
- (kernel_ulong_t)&card_info_eae_ma1
- },
- {
- 0x10B5, 0x9050,
- 0x10B5, 0x3294,
- 0, 0,
- (kernel_ulong_t)&card_info_eae_fb2
- },
- {
- 0x14BA, 0x6000,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- {
- 0x10B5, 0x2200,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&card_info_10mbit
- },
- { 0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, com20020pci_id_table);
diff --git a/drivers/net/can/m_can/m_can_pci.c b/drivers/net/can/m_can/m_can_pci.c
index eb31ed1f9644..cb9335c1d3ea 100644
--- a/drivers/net/can/m_can/m_can_pci.c
+++ b/drivers/net/can/m_can/m_can_pci.c
@@ -183,9 +183,9 @@ static SIMPLE_DEV_PM_OPS(m_can_pci_pm_ops,
m_can_pci_suspend, m_can_pci_resume);
static const struct pci_device_id m_can_pci_id_table[] = {
- { PCI_VDEVICE(INTEL, 0x4bc1), M_CAN_CLOCK_FREQ_EHL, },
- { PCI_VDEVICE(INTEL, 0x4bc2), M_CAN_CLOCK_FREQ_EHL, },
- { } /* Terminating Entry */
+ { PCI_VDEVICE(INTEL, 0x4bc1), .driver_data = M_CAN_CLOCK_FREQ_EHL, },
+ { PCI_VDEVICE(INTEL, 0x4bc2), .driver_data = M_CAN_CLOCK_FREQ_EHL, },
+ { } /* terminating entry */
};
MODULE_DEVICE_TABLE(pci, m_can_pci_id_table);
diff --git a/drivers/net/can/sja1000/plx_pci.c b/drivers/net/can/sja1000/plx_pci.c
index 08183833c9bc..a03553b80a5d 100644
--- a/drivers/net/can/sja1000/plx_pci.c
+++ b/drivers/net/can/sja1000/plx_pci.c
@@ -272,124 +272,89 @@ static struct plx_pci_card_info plx_pci_card_info_asem_dual_can = {
static const struct pci_device_id plx_pci_tbl[] = {
{
/* Adlink PCI-7841/cPCI-7841 */
- ADLINK_PCI_VENDOR_ID, ADLINK_PCI_DEVICE_ID,
- PCI_ANY_ID, PCI_ANY_ID,
- PCI_CLASS_NETWORK_OTHER << 8, ~0,
- (kernel_ulong_t)&plx_pci_card_info_adlink
- },
- {
+ PCI_DEVICE(ADLINK_PCI_VENDOR_ID, ADLINK_PCI_DEVICE_ID),
+ .class = PCI_CLASS_NETWORK_OTHER << 8,
+ .class_mask = ~0,
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_adlink,
+ }, {
/* Adlink PCI-7841/cPCI-7841 SE */
- ADLINK_PCI_VENDOR_ID, ADLINK_PCI_DEVICE_ID,
- PCI_ANY_ID, PCI_ANY_ID,
- PCI_CLASS_COMMUNICATION_OTHER << 8, ~0,
- (kernel_ulong_t)&plx_pci_card_info_adlink_se
- },
- {
+ PCI_DEVICE(ADLINK_PCI_VENDOR_ID, ADLINK_PCI_DEVICE_ID),
+ .class = PCI_CLASS_COMMUNICATION_OTHER << 8,
+ .class_mask = ~0,
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_adlink_se,
+ }, {
/* esd CAN-PCI/200 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI200,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd200
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9050,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI200),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd200,
+ }, {
/* esd CAN-CPCI/200 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_CPCI200,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd200
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9030,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_CPCI200),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd200,
+ }, {
/* esd CAN-PCI104/200 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI104200,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd200
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9030,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI104200),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd200,
+ }, {
/* esd CAN-PCI/266 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI266,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd266
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9056,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCI266),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd266,
+ }, {
/* esd CAN-PMC/266 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PMC266,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd266
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9056,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PMC266),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd266,
+ }, {
/* esd CAN-PCIE/2000 */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9056,
- PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCIE2000,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_esd2000
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9056,
+ PCI_VENDOR_ID_ESDGMBH, ESD_PCI_SUB_SYS_ID_PCIE2000),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_esd2000,
+ }, {
/* IXXAT PC-I 04/PCI card */
- IXXAT_PCI_VENDOR_ID, IXXAT_PCI_DEVICE_ID,
- PCI_ANY_ID, IXXAT_PCI_SUB_SYS_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_ixxat
- },
- {
+ PCI_DEVICE_SUB(IXXAT_PCI_VENDOR_ID, IXXAT_PCI_DEVICE_ID,
+ PCI_ANY_ID, IXXAT_PCI_SUB_SYS_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_ixxat,
+ }, {
/* Marathon CAN-bus-PCI card */
- PCI_VENDOR_ID_PLX, MARATHON_PCI_DEVICE_ID,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_marathon_pci
- },
- {
+ PCI_VDEVICE(PLX, MARATHON_PCI_DEVICE_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_marathon_pci,
+ }, {
/* Marathon CAN-bus-PCIe card */
- PCI_VENDOR_ID_PLX, MARATHON_PCIE_DEVICE_ID,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_marathon_pcie
- },
- {
+ PCI_VDEVICE(PLX, MARATHON_PCIE_DEVICE_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_marathon_pcie,
+ }, {
/* TEWS TECHNOLOGIES TPMC810 card */
- TEWS_PCI_VENDOR_ID, TEWS_PCI_DEVICE_ID_TMPC810,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_tews
- },
- {
+ PCI_DEVICE(TEWS_PCI_VENDOR_ID, TEWS_PCI_DEVICE_ID_TMPC810),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_tews,
+ }, {
/* Connect Tech Inc. CANpro/104-Plus Opto (CRG001) card */
- PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
- PCI_SUBVENDOR_ID_CONNECT_TECH, CTI_PCI_DEVICE_ID_CRG001,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_cti
- },
- {
+ PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9030,
+ PCI_SUBVENDOR_ID_CONNECT_TECH, CTI_PCI_DEVICE_ID_CRG001),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_cti,
+ }, {
/* Elcus CAN-200-PCI */
- CAN200PCI_VENDOR_ID, CAN200PCI_DEVICE_ID,
- CAN200PCI_SUB_VENDOR_ID, CAN200PCI_SUB_DEVICE_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_elcus
- },
- {
+ PCI_DEVICE_SUB(CAN200PCI_VENDOR_ID, CAN200PCI_DEVICE_ID,
+ CAN200PCI_SUB_VENDOR_ID, CAN200PCI_SUB_DEVICE_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_elcus,
+ }, {
/* moxa */
- MOXA_PCI_VENDOR_ID, MOXA_PCI_DEVICE_ID,
- PCI_ANY_ID, PCI_ANY_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_moxa
- },
- {
+ PCI_DEVICE(MOXA_PCI_VENDOR_ID, MOXA_PCI_DEVICE_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_moxa,
+ }, {
/* ASEM Dual CAN raw */
- ASEM_RAW_CAN_VENDOR_ID, ASEM_RAW_CAN_DEVICE_ID,
- ASEM_RAW_CAN_SUB_VENDOR_ID, ASEM_RAW_CAN_SUB_DEVICE_ID,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_asem_dual_can
- },
- {
+ PCI_DEVICE_SUB(ASEM_RAW_CAN_VENDOR_ID, ASEM_RAW_CAN_DEVICE_ID,
+ ASEM_RAW_CAN_SUB_VENDOR_ID, ASEM_RAW_CAN_SUB_DEVICE_ID),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_asem_dual_can,
+ }, {
/* ASEM Dual CAN raw -new model */
- ASEM_RAW_CAN_VENDOR_ID, ASEM_RAW_CAN_DEVICE_ID,
- ASEM_RAW_CAN_SUB_VENDOR_ID, ASEM_RAW_CAN_SUB_DEVICE_ID_BIS,
- 0, 0,
- (kernel_ulong_t)&plx_pci_card_info_asem_dual_can
+ PCI_DEVICE_SUB(ASEM_RAW_CAN_VENDOR_ID, ASEM_RAW_CAN_DEVICE_ID,
+ ASEM_RAW_CAN_SUB_VENDOR_ID, ASEM_RAW_CAN_SUB_DEVICE_ID_BIS),
+ .driver_data = (kernel_ulong_t)&plx_pci_card_info_asem_dual_can,
},
- { 0,}
+ { }
};
MODULE_DEVICE_TABLE(pci, plx_pci_tbl);
diff --git a/drivers/net/ethernet/3com/3c59x.c b/drivers/net/ethernet/3com/3c59x.c
index 4fe4efdb3737..79beb86437df 100644
--- a/drivers/net/ethernet/3com/3c59x.c
+++ b/drivers/net/ethernet/3com/3c59x.c
@@ -376,54 +376,54 @@ static struct vortex_chip_info {
static const struct pci_device_id vortex_pci_tbl[] = {
- { 0x10B7, 0x5900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C590 },
- { 0x10B7, 0x5920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C592 },
- { 0x10B7, 0x5970, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C597 },
- { 0x10B7, 0x5950, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_1 },
- { 0x10B7, 0x5951, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_2 },
+ { PCI_DEVICE(0x10B7, 0x5900), .driver_data = CH_3C590 },
+ { PCI_DEVICE(0x10B7, 0x5920), .driver_data = CH_3C592 },
+ { PCI_DEVICE(0x10B7, 0x5970), .driver_data = CH_3C597 },
+ { PCI_DEVICE(0x10B7, 0x5950), .driver_data = CH_3C595_1 },
+ { PCI_DEVICE(0x10B7, 0x5951), .driver_data = CH_3C595_2 },
- { 0x10B7, 0x5952, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_3 },
- { 0x10B7, 0x9000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_1 },
- { 0x10B7, 0x9001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_2 },
- { 0x10B7, 0x9004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_3 },
- { 0x10B7, 0x9005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_4 },
+ { PCI_DEVICE(0x10B7, 0x5952), .driver_data = CH_3C595_3 },
+ { PCI_DEVICE(0x10B7, 0x9000), .driver_data = CH_3C900_1 },
+ { PCI_DEVICE(0x10B7, 0x9001), .driver_data = CH_3C900_2 },
+ { PCI_DEVICE(0x10B7, 0x9004), .driver_data = CH_3C900_3 },
+ { PCI_DEVICE(0x10B7, 0x9005), .driver_data = CH_3C900_4 },
- { 0x10B7, 0x9006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_5 },
- { 0x10B7, 0x900A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900B_FL },
- { 0x10B7, 0x9050, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_1 },
- { 0x10B7, 0x9051, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_2 },
- { 0x10B7, 0x9054, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_TX },
- { 0x10B7, 0x9055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_1 },
+ { PCI_DEVICE(0x10B7, 0x9006), .driver_data = CH_3C900_5 },
+ { PCI_DEVICE(0x10B7, 0x900A), .driver_data = CH_3C900B_FL },
+ { PCI_DEVICE(0x10B7, 0x9050), .driver_data = CH_3C905_1 },
+ { PCI_DEVICE(0x10B7, 0x9051), .driver_data = CH_3C905_2 },
+ { PCI_DEVICE(0x10B7, 0x9054), .driver_data = CH_3C905B_TX },
+ { PCI_DEVICE(0x10B7, 0x9055), .driver_data = CH_3C905B_1 },
- { 0x10B7, 0x9058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_2 },
- { 0x10B7, 0x905A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_FX },
- { 0x10B7, 0x9200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905C },
- { 0x10B7, 0x9202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9202 },
- { 0x10B7, 0x9800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C980 },
- { 0x10B7, 0x9805, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9805 },
+ { PCI_DEVICE(0x10B7, 0x9058), .driver_data = CH_3C905B_2 },
+ { PCI_DEVICE(0x10B7, 0x905A), .driver_data = CH_3C905B_FX },
+ { PCI_DEVICE(0x10B7, 0x9200), .driver_data = CH_3C905C },
+ { PCI_DEVICE(0x10B7, 0x9202), .driver_data = CH_3C9202 },
+ { PCI_DEVICE(0x10B7, 0x9800), .driver_data = CH_3C980 },
+ { PCI_DEVICE(0x10B7, 0x9805), .driver_data = CH_3C9805 },
- { 0x10B7, 0x7646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CSOHO100_TX },
- { 0x10B7, 0x5055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C555 },
- { 0x10B7, 0x6055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556 },
- { 0x10B7, 0x6056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556B },
- { 0x10B7, 0x5b57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575 },
+ { PCI_DEVICE(0x10B7, 0x7646), .driver_data = CH_3CSOHO100_TX },
+ { PCI_DEVICE(0x10B7, 0x5055), .driver_data = CH_3C555 },
+ { PCI_DEVICE(0x10B7, 0x6055), .driver_data = CH_3C556 },
+ { PCI_DEVICE(0x10B7, 0x6056), .driver_data = CH_3C556B },
+ { PCI_DEVICE(0x10B7, 0x5b57), .driver_data = CH_3C575 },
- { 0x10B7, 0x5057, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575_1 },
- { 0x10B7, 0x5157, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575 },
- { 0x10B7, 0x5257, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575CT },
- { 0x10B7, 0x6560, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE656 },
- { 0x10B7, 0x6562, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656 },
+ { PCI_DEVICE(0x10B7, 0x5057), .driver_data = CH_3C575_1 },
+ { PCI_DEVICE(0x10B7, 0x5157), .driver_data = CH_3CCFE575 },
+ { PCI_DEVICE(0x10B7, 0x5257), .driver_data = CH_3CCFE575CT },
+ { PCI_DEVICE(0x10B7, 0x6560), .driver_data = CH_3CCFE656 },
+ { PCI_DEVICE(0x10B7, 0x6562), .driver_data = CH_3CCFEM656 },
- { 0x10B7, 0x6564, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656_1 },
- { 0x10B7, 0x4500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C450 },
- { 0x10B7, 0x9201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C920 },
- { 0x10B7, 0x1201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982A },
- { 0x10B7, 0x1202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982B },
+ { PCI_DEVICE(0x10B7, 0x6564), .driver_data = CH_3CCFEM656_1 },
+ { PCI_DEVICE(0x10B7, 0x4500), .driver_data = CH_3C450 },
+ { PCI_DEVICE(0x10B7, 0x9201), .driver_data = CH_3C920 },
+ { PCI_DEVICE(0x10B7, 0x1201), .driver_data = CH_3C982A },
+ { PCI_DEVICE(0x10B7, 0x1202), .driver_data = CH_3C982B },
- { 0x10B7, 0x9056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_905BT4 },
- { 0x10B7, 0x9210, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_920B_EMB_WNM },
+ { PCI_DEVICE(0x10B7, 0x9056), .driver_data = CH_905BT4 },
+ { PCI_DEVICE(0x10B7, 0x9210), .driver_data = CH_920B_EMB_WNM },
- {0,} /* 0 terminated list. */
+ { } /* 0 terminated list. */
};
MODULE_DEVICE_TABLE(pci, vortex_pci_tbl);
diff --git a/drivers/net/ethernet/3com/typhoon.c b/drivers/net/ethernet/3com/typhoon.c
index aaaff3ba43ef..fadc86907ec2 100644
--- a/drivers/net/ethernet/3com/typhoon.c
+++ b/drivers/net/ethernet/3com/typhoon.c
@@ -198,33 +198,54 @@ static struct typhoon_card_info typhoon_card_info[] = {
* bits 12-16 indicate card type: (0) client and (1) server
*/
static const struct pci_device_id typhoon_pci_tbl[] = {
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0,TYPHOON_TX },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX95 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_TX_97,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_TX97 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
- PCI_ANY_ID, 0x1000, 0, 0, TYPHOON_TXM },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
- PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FXM },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990B,
- PCI_ANY_ID, 0x2000, 0, 0, TYPHOON_BSVR },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
- PCI_ANY_ID, 0x1101, 0, 0, TYPHOON_FX95 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
- PCI_ANY_ID, 0x1102, 0, 0, TYPHOON_FX97 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
- PCI_ANY_ID, 0x2101, 0, 0, TYPHOON_FX95SVR },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
- PCI_ANY_ID, 0x2102, 0, 0, TYPHOON_FX97SVR },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR95,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR95 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR97,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR97 },
- { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3CR990SVR,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, TYPHOON_SVR },
- { 0, }
+ {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990),
+ .driver_data = TYPHOON_TX,
+ }, {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990_TX_95),
+ .driver_data = TYPHOON_TX95,
+ }, {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990_TX_97),
+ .driver_data = TYPHOON_TX97,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990B,
+ PCI_ANY_ID, 0x1000),
+ .driver_data = TYPHOON_TXM,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990B,
+ PCI_ANY_ID, 0x1102),
+ .driver_data = TYPHOON_FXM,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990B,
+ PCI_ANY_ID, 0x2000),
+ .driver_data = TYPHOON_BSVR,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
+ PCI_ANY_ID, 0x1101),
+ .driver_data = TYPHOON_FX95,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
+ PCI_ANY_ID, 0x1102),
+ .driver_data = TYPHOON_FX97,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
+ PCI_ANY_ID, 0x2101),
+ .driver_data = TYPHOON_FX95SVR,
+ }, {
+ PCI_VDEVICE_SUB(3COM, PCI_DEVICE_ID_3COM_3CR990_FX,
+ PCI_ANY_ID, 0x2102),
+ .driver_data = TYPHOON_FX97SVR,
+ }, {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990SVR95),
+ .driver_data = TYPHOON_SVR95,
+ }, {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990SVR97),
+ .driver_data = TYPHOON_SVR97,
+ }, {
+ PCI_VDEVICE(3COM, PCI_DEVICE_ID_3COM_3CR990SVR),
+ .driver_data = TYPHOON_SVR,
+ },
+ { }
};
MODULE_DEVICE_TABLE(pci, typhoon_pci_tbl);
diff --git a/drivers/net/ethernet/8390/ne2k-pci.c b/drivers/net/ethernet/8390/ne2k-pci.c
index 1a34da07c0db..b1a94c97c0b9 100644
--- a/drivers/net/ethernet/8390/ne2k-pci.c
+++ b/drivers/net/ethernet/8390/ne2k-pci.c
@@ -143,18 +143,18 @@ static struct {
static const struct pci_device_id ne2k_pci_tbl[] = {
- { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
- { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
- { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
- { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
- { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
- { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
- { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
- { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
- { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
- { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
- { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
- { 0, }
+ { PCI_DEVICE(0x10ec, 0x8029), .driver_data = CH_RealTek_RTL_8029 },
+ { PCI_DEVICE(0x1050, 0x0940), .driver_data = CH_Winbond_89C940 },
+ { PCI_DEVICE(0x11f6, 0x1401), .driver_data = CH_Compex_RL2000 },
+ { PCI_DEVICE(0x8e2e, 0x3000), .driver_data = CH_KTI_ET32P2 },
+ { PCI_DEVICE(0x4a14, 0x5000), .driver_data = CH_NetVin_NV5000SC },
+ { PCI_DEVICE(0x1106, 0x0926), .driver_data = CH_Via_86C926 },
+ { PCI_DEVICE(0x10bd, 0x0e34), .driver_data = CH_SureCom_NE34 },
+ { PCI_DEVICE(0x1050, 0x5a5a), .driver_data = CH_Winbond_W89C940F },
+ { PCI_DEVICE(0x12c3, 0x0058), .driver_data = CH_Holtek_HT80232 },
+ { PCI_DEVICE(0x12c3, 0x5598), .driver_data = CH_Holtek_HT80229 },
+ { PCI_DEVICE(0x8c4a, 0x1980), .driver_data = CH_Winbond_89C940_8c4a },
+ { }
};
MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
diff --git a/drivers/net/ethernet/adaptec/starfire.c b/drivers/net/ethernet/adaptec/starfire.c
index e1b8794b14c9..f1109d90e1fc 100644
--- a/drivers/net/ethernet/adaptec/starfire.c
+++ b/drivers/net/ethernet/adaptec/starfire.c
@@ -278,8 +278,8 @@ enum chipset {
};
static const struct pci_device_id starfire_pci_tbl[] = {
- { PCI_VDEVICE(ADAPTEC, 0x6915), CH_6915 },
- { 0, }
+ { PCI_VDEVICE(ADAPTEC, 0x6915), .driver_data = CH_6915 },
+ { }
};
MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);
diff --git a/drivers/net/ethernet/agere/et131x.c b/drivers/net/ethernet/agere/et131x.c
index 0f6e5373029a..1b465a167672 100644
--- a/drivers/net/ethernet/agere/et131x.c
+++ b/drivers/net/ethernet/agere/et131x.c
@@ -4084,9 +4084,9 @@ static int et131x_pci_setup(struct pci_dev *pdev,
}
static const struct pci_device_id et131x_pci_table[] = {
- { PCI_VDEVICE(ATT, ET131X_PCI_DEVICE_ID_GIG), 0UL},
- { PCI_VDEVICE(ATT, ET131X_PCI_DEVICE_ID_FAST), 0UL},
- { 0,}
+ { PCI_VDEVICE(ATT, ET131X_PCI_DEVICE_ID_GIG) },
+ { PCI_VDEVICE(ATT, ET131X_PCI_DEVICE_ID_FAST) },
+ { }
};
MODULE_DEVICE_TABLE(pci, et131x_pci_table);
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index f5722e929833..3e2fd2939e87 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -115,29 +115,45 @@ static struct {
};
static const struct pci_device_id bnx2_pci_tbl[] = {
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
- PCI_VENDOR_ID_HP, 0x3101, 0, 0, NC370T },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
- PCI_VENDOR_ID_HP, 0x3106, 0, 0, NC370I },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706 },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708 },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
- PCI_VENDOR_ID_HP, 0x3102, 0, 0, NC370F },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5706S,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5706S },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5708S,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5708S },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709 },
- { PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_NX2_5709S,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5709S },
- { PCI_VENDOR_ID_BROADCOM, 0x163b,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5716 },
- { PCI_VENDOR_ID_BROADCOM, 0x163c,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, BCM5716S },
- { 0, }
+ {
+ PCI_VDEVICE_SUB(BROADCOM, PCI_DEVICE_ID_NX2_5706,
+ PCI_VENDOR_ID_HP, 0x3101),
+ .driver_data = NC370T,
+ }, {
+ PCI_VDEVICE_SUB(BROADCOM, PCI_DEVICE_ID_NX2_5706,
+ PCI_VENDOR_ID_HP, 0x3106),
+ .driver_data = NC370I,
+ }, {
+ PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_5706),
+ .driver_data = BCM5706,
+ }, {
+ PCI_VDEVICE_SUB(BROADCOM, PCI_DEVICE_ID_NX2_5708,
+ PCI_ANY_ID, PCI_ANY_ID),
+ .driver_data = BCM5708,
+ }, {
+ PCI_VDEVICE_SUB(BROADCOM, PCI_DEVICE_ID_NX2_5706S,
+ PCI_VENDOR_ID_HP, 0x3102),
+ .driver_data = NC370F,
+ }, {
+ PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_5706S),
+ .driver_data = BCM5706S,
+ }, {
+ PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_5708S),
+ .driver_data = BCM5708S,
+ }, {
+ PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_5709),
+ .driver_data = BCM5709,
+ }, {
+ PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_5709S),
+ .driver_data = BCM5709S,
+ }, {
+ PCI_VDEVICE(BROADCOM, 0x163b),
+ .driver_data = BCM5716,
+ }, {
+ PCI_VDEVICE(BROADCOM, 0x163c),
+ .driver_data = BCM5716S,
+ },
+ { }
};
static const struct flash_spec flash_table[] =
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
index da0f8c353e6a..6f96645ff23f 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c
@@ -259,31 +259,31 @@ static struct {
#endif
static const struct pci_device_id bnx2x_pci_tbl[] = {
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), BCM57710 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), BCM57711 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), BCM57711E },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), BCM57712 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_MF), BCM57712_MF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_VF), BCM57712_VF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800), BCM57800 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_MF), BCM57800_MF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_VF), BCM57800_VF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810), BCM57810 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_MF), BCM57810_MF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_O), BCM57840_O },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_4_10), BCM57840_4_10 },
- { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_4_10), BCM57840_4_10 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_2_20), BCM57840_2_20 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_VF), BCM57810_VF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MFO), BCM57840_MFO },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MF), BCM57840_MF },
- { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_MF), BCM57840_MF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_VF), BCM57840_VF },
- { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_VF), BCM57840_VF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811), BCM57811 },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_MF), BCM57811_MF },
- { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_VF), BCM57811_VF },
- { 0 }
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57710), .driver_data = BCM57710 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711), .driver_data = BCM57711 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57711E), .driver_data = BCM57711E },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712), .driver_data = BCM57712 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_MF), .driver_data = BCM57712_MF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57712_VF), .driver_data = BCM57712_VF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800), .driver_data = BCM57800 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_MF), .driver_data = BCM57800_MF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57800_VF), .driver_data = BCM57800_VF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810), .driver_data = BCM57810 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_MF), .driver_data = BCM57810_MF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_O), .driver_data = BCM57840_O },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_4_10), .driver_data = BCM57840_4_10 },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_4_10), .driver_data = BCM57840_4_10 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_2_20), .driver_data = BCM57840_2_20 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57810_VF), .driver_data = BCM57810_VF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MFO), .driver_data = BCM57840_MFO },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_MF), .driver_data = BCM57840_MF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_MF), .driver_data = BCM57840_MF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57840_VF), .driver_data = BCM57840_VF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_NX2_57840_VF), .driver_data = BCM57840_VF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811), .driver_data = BCM57811 },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_MF), .driver_data = BCM57811_MF },
+ { PCI_VDEVICE(BROADCOM, PCI_DEVICE_ID_NX2_57811_VF), .driver_data = BCM57811_VF },
+ { }
};
MODULE_DEVICE_TABLE(pci, bnx2x_pci_tbl);
diff --git a/drivers/net/ethernet/cavium/liquidio/lio_main.c b/drivers/net/ethernet/cavium/liquidio/lio_main.c
index c1a3df225254..353b2d23396e 100644
--- a/drivers/net/ethernet/cavium/liquidio/lio_main.c
+++ b/drivers/net/ethernet/cavium/liquidio/lio_main.c
@@ -404,17 +404,15 @@ static const struct pci_error_handlers liquidio_err_handler = {
static const struct pci_device_id liquidio_pci_tbl[] = {
{ /* 68xx */
- PCI_VENDOR_ID_CAVIUM, 0x91, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0
+ PCI_VDEVICE(CAVIUM, 0x91)
},
{ /* 66xx */
- PCI_VENDOR_ID_CAVIUM, 0x92, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0
+ PCI_VDEVICE(CAVIUM, 0x92)
},
{ /* 23xx pf */
- PCI_VENDOR_ID_CAVIUM, 0x9702, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0
+ PCI_VDEVICE(CAVIUM, 0x9702)
},
- {
- 0, 0, 0, 0, 0, 0, 0
- }
+ { }
};
MODULE_DEVICE_TABLE(pci, liquidio_pci_tbl);
diff --git a/drivers/net/ethernet/cavium/liquidio/lio_vf_main.c b/drivers/net/ethernet/cavium/liquidio/lio_vf_main.c
index 43c595f3b84e..36255352e7ea 100644
--- a/drivers/net/ethernet/cavium/liquidio/lio_vf_main.c
+++ b/drivers/net/ethernet/cavium/liquidio/lio_vf_main.c
@@ -237,12 +237,9 @@ static const struct pci_error_handlers liquidio_vf_err_handler = {
static const struct pci_device_id liquidio_vf_pci_tbl[] = {
{
- PCI_VENDOR_ID_CAVIUM, OCTEON_CN23XX_VF_VID,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0
+ PCI_VDEVICE(CAVIUM, OCTEON_CN23XX_VF_VID),
},
- {
- 0, 0, 0, 0, 0, 0, 0
- }
+ { }
};
MODULE_DEVICE_TABLE(pci, liquidio_vf_pci_tbl);
diff --git a/drivers/net/ethernet/chelsio/cxgb/common.h b/drivers/net/ethernet/chelsio/cxgb/common.h
index 304bb282ab03..292f8ec248e2 100644
--- a/drivers/net/ethernet/chelsio/cxgb/common.h
+++ b/drivers/net/ethernet/chelsio/cxgb/common.h
@@ -48,7 +48,7 @@
#define DRV_NAME "cxgb"
#define CH_DEVICE(devid, ssid, idx) \
- { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, ssid, 0, 0, idx }
+ { PCI_VDEVICE_SUB(CHELSIO, devid, PCI_ANY_ID, ssid), .driver_data = idx }
#define SUPPORTED_PAUSE (1 << 13)
#define SUPPORTED_LOOPBACK (1 << 15)
diff --git a/drivers/net/ethernet/chelsio/cxgb/subr.c b/drivers/net/ethernet/chelsio/cxgb/subr.c
index 367a9e4581d5..d4488e400bc6 100644
--- a/drivers/net/ethernet/chelsio/cxgb/subr.c
+++ b/drivers/net/ethernet/chelsio/cxgb/subr.c
@@ -533,7 +533,7 @@ const struct pci_device_id t1_pci_tbl[] = {
CH_DEVICE(11, 1, CH_BRD_T210_1F),
CH_DEVICE(14, 1, CH_BRD_T210_1CU),
CH_DEVICE(16, 1, CH_BRD_N204_4CU),
- { 0 }
+ { }
};
MODULE_DEVICE_TABLE(pci, t1_pci_tbl);
diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
index 88b6d76817e9..3bee82bc0680 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
@@ -83,7 +83,7 @@ enum {
#define EEPROM_MAGIC 0x38E2F10C
#define CH_DEVICE(devid, idx) \
- { PCI_VENDOR_ID_CHELSIO, devid, PCI_ANY_ID, PCI_ANY_ID, 0, 0, idx }
+ { PCI_VDEVICE(CHELSIO, devid), .driver_data = idx }
static const struct pci_device_id cxgb3_pci_tbl[] = {
CH_DEVICE(0x20, 0), /* PE9000 */
@@ -99,7 +99,7 @@ static const struct pci_device_id cxgb3_pci_tbl[] = {
CH_DEVICE(0x35, 6), /* T3C20-derived T3C10 */
CH_DEVICE(0x36, 3), /* S320E-CR */
CH_DEVICE(0x37, 7), /* N320E-G2 */
- {0,}
+ { }
};
MODULE_DESCRIPTION(DRV_DESC);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 10694d5924ee..6df98fca932f 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -112,10 +112,10 @@ char cxgb4_driver_name[] = KBUILD_MODNAME;
#define CH_PCI_DEVICE_ID_FUNCTION2 0x0
#define CH_PCI_ID_TABLE_ENTRY(devid) \
- {PCI_VDEVICE(CHELSIO, (devid)), CXGB4_UNIFIED_PF}
+ { PCI_VDEVICE(CHELSIO, (devid)), .driver_data = CXGB4_UNIFIED_PF }
#define CH_PCI_DEVICE_ID_TABLE_DEFINE_END \
- { 0, } \
+ { } \
}
#include "t4_pci_id_tbl.h"
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
index 9eaa9aadee33..b35a54982b6d 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
@@ -3388,9 +3388,9 @@ static void cxgb4vf_pci_shutdown(struct pci_dev *pdev)
#define CH_PCI_DEVICE_ID_FUNCTION 0x8
#define CH_PCI_ID_TABLE_ENTRY(devid) \
- { PCI_VDEVICE(CHELSIO, (devid)), 0 }
+ { PCI_VDEVICE(CHELSIO, (devid)), .driver_data = 0 }
-#define CH_PCI_DEVICE_ID_TABLE_DEFINE_END { 0, } }
+#define CH_PCI_DEVICE_ID_TABLE_DEFINE_END { } }
#include "../cxgb4/t4_pci_id_tbl.h"
diff --git a/drivers/net/ethernet/dec/tulip/de2104x.c b/drivers/net/ethernet/dec/tulip/de2104x.c
index f9504f340c4a..f38a10c79907 100644
--- a/drivers/net/ethernet/dec/tulip/de2104x.c
+++ b/drivers/net/ethernet/dec/tulip/de2104x.c
@@ -333,10 +333,8 @@ static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
static const struct pci_device_id de_pci_tbl[] = {
- { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
+ { PCI_VDEVICE(DEC, PCI_DEVICE_ID_DEC_TULIP), .driver_data = 0 },
+ { PCI_VDEVICE(DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS), .driver_data = 1 },
{ },
};
MODULE_DEVICE_TABLE(pci, de_pci_tbl);
diff --git a/drivers/net/ethernet/dec/tulip/dmfe.c b/drivers/net/ethernet/dec/tulip/dmfe.c
index 2d3bd343b6e6..dabc091a0c66 100644
--- a/drivers/net/ethernet/dec/tulip/dmfe.c
+++ b/drivers/net/ethernet/dec/tulip/dmfe.c
@@ -2076,11 +2076,11 @@ static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
static const struct pci_device_id dmfe_pci_tbl[] = {
- { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
- { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
- { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
- { 0x1282, 0x9009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9009_ID },
- { 0, }
+ { PCI_DEVICE(0x1282, 0x9132), .driver_data = PCI_DM9132_ID },
+ { PCI_DEVICE(0x1282, 0x9102), .driver_data = PCI_DM9102_ID },
+ { PCI_DEVICE(0x1282, 0x9100), .driver_data = PCI_DM9100_ID },
+ { PCI_DEVICE(0x1282, 0x9009), .driver_data = PCI_DM9009_ID },
+ { }
};
MODULE_DEVICE_TABLE(pci, dmfe_pci_tbl);
@@ -2101,7 +2101,7 @@ static int __maybe_unused dmfe_suspend(struct device *dev_d)
dw32(DCR7, 0);
dw32(DCR5, dr32(DCR5));
- /* Fre RX buffers */
+ /* Free RX buffers */
dmfe_free_rxbuffer(db);
/* Enable WOL */
diff --git a/drivers/net/ethernet/dec/tulip/tulip_core.c b/drivers/net/ethernet/dec/tulip/tulip_core.c
index b608585f1954..a7200eb66594 100644
--- a/drivers/net/ethernet/dec/tulip/tulip_core.c
+++ b/drivers/net/ethernet/dec/tulip/tulip_core.c
@@ -196,45 +196,45 @@ const struct tulip_chip_table tulip_tbl[] = {
static const struct pci_device_id tulip_pci_tbl[] = {
- { 0x1011, 0x0009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21140 },
- { 0x1011, 0x0019, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DC21143 },
- { 0x11AD, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, LC82C168 },
- { 0x10d9, 0x0512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98713 },
- { 0x10d9, 0x0531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98715 },
-/* { 0x10d9, 0x0531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98725 },*/
- { 0x125B, 0x1400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, AX88140 },
- { 0x11AD, 0xc115, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PNIC2 },
- { 0x1317, 0x0981, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1317, 0x0985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1317, 0x1985, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1317, 0x9511, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x13D1, 0xAB02, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x13D1, 0xAB03, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x13D1, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x104A, 0x0981, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x104A, 0x2774, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1259, 0xa120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x11F6, 0x9881, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMPEX9881 },
- { 0x8086, 0x0039, PCI_ANY_ID, PCI_ANY_ID, 0, 0, I21145 },
+ { PCI_DEVICE(0x1011, 0x0009), .driver_data = DC21140 },
+ { PCI_DEVICE(0x1011, 0x0019), .driver_data = DC21143 },
+ { PCI_DEVICE(0x11AD, 0x0002), .driver_data = LC82C168 },
+ { PCI_DEVICE(0x10d9, 0x0512), .driver_data = MX98713 },
+ { PCI_DEVICE(0x10d9, 0x0531), .driver_data = MX98715 },
+/* { PCI_DEVICE(0x10d9, 0x0531), .driver_data = MX98725 },*/
+ { PCI_DEVICE(0x125B, 0x1400), .driver_data = AX88140 },
+ { PCI_DEVICE(0x11AD, 0xc115), .driver_data = PNIC2 },
+ { PCI_DEVICE(0x1317, 0x0981), .driver_data = COMET },
+ { PCI_DEVICE(0x1317, 0x0985), .driver_data = COMET },
+ { PCI_DEVICE(0x1317, 0x1985), .driver_data = COMET },
+ { PCI_DEVICE(0x1317, 0x9511), .driver_data = COMET },
+ { PCI_DEVICE(0x13D1, 0xAB02), .driver_data = COMET },
+ { PCI_DEVICE(0x13D1, 0xAB03), .driver_data = COMET },
+ { PCI_DEVICE(0x13D1, 0xAB08), .driver_data = COMET },
+ { PCI_DEVICE(0x104A, 0x0981), .driver_data = COMET },
+ { PCI_DEVICE(0x104A, 0x2774), .driver_data = COMET },
+ { PCI_DEVICE(0x1259, 0xa120), .driver_data = COMET },
+ { PCI_DEVICE(0x11F6, 0x9881), .driver_data = COMPEX9881 },
+ { PCI_DEVICE(0x8086, 0x0039), .driver_data = I21145 },
#ifdef CONFIG_TULIP_DM910X
- { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
- { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DM910X },
+ { PCI_DEVICE(0x1282, 0x9100), .driver_data = DM910X },
+ { PCI_DEVICE(0x1282, 0x9102), .driver_data = DM910X },
#endif
- { 0x1113, 0x1216, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1113, 0x1217, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MX98715 },
- { 0x1113, 0x9511, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1186, 0x1541, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1186, 0x1561, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1186, 0x1591, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x14f1, 0x1803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CONEXANT },
- { 0x1626, 0x8410, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1737, 0xAB09, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x1737, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x17B3, 0xAB08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
- { 0x10b7, 0x9300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* 3Com 3CSOHO100B-TX */
- { 0x14ea, 0xab08, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* Planex FNW-3602-TX */
- { 0x1414, 0x0001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET }, /* Microsoft MN-120 */
- { 0x1414, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, COMET },
+ { PCI_DEVICE(0x1113, 0x1216), .driver_data = COMET },
+ { PCI_DEVICE(0x1113, 0x1217), .driver_data = MX98715 },
+ { PCI_DEVICE(0x1113, 0x9511), .driver_data = COMET },
+ { PCI_DEVICE(0x1186, 0x1541), .driver_data = COMET },
+ { PCI_DEVICE(0x1186, 0x1561), .driver_data = COMET },
+ { PCI_DEVICE(0x1186, 0x1591), .driver_data = COMET },
+ { PCI_DEVICE(0x14f1, 0x1803), .driver_data = CONEXANT },
+ { PCI_DEVICE(0x1626, 0x8410), .driver_data = COMET },
+ { PCI_DEVICE(0x1737, 0xAB09), .driver_data = COMET },
+ { PCI_DEVICE(0x1737, 0xAB08), .driver_data = COMET },
+ { PCI_DEVICE(0x17B3, 0xAB08), .driver_data = COMET },
+ { PCI_DEVICE(0x10b7, 0x9300), .driver_data = COMET }, /* 3Com 3CSOHO100B-TX */
+ { PCI_DEVICE(0x14ea, 0xab08), .driver_data = COMET }, /* Planex FNW-3602-TX */
+ { PCI_DEVICE(0x1414, 0x0001), .driver_data = COMET }, /* Microsoft MN-120 */
+ { PCI_DEVICE(0x1414, 0x0002), .driver_data = COMET },
{ } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, tulip_pci_tbl);
@@ -1279,8 +1279,8 @@ static const struct net_device_ops tulip_netdev_ops = {
};
static const struct pci_device_id early_486_chipsets[] = {
- { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82424) },
- { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_496) },
+ { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_82424) },
+ { PCI_VDEVICE(SI, PCI_DEVICE_ID_SI_496) },
{ },
};
diff --git a/drivers/net/ethernet/dec/tulip/uli526x.c b/drivers/net/ethernet/dec/tulip/uli526x.c
index 6e4d8d31aba9..34b234b6b159 100644
--- a/drivers/net/ethernet/dec/tulip/uli526x.c
+++ b/drivers/net/ethernet/dec/tulip/uli526x.c
@@ -1728,9 +1728,9 @@ static u16 phy_read_1bit(struct uli526x_board_info *db)
static const struct pci_device_id uli526x_pci_tbl[] = {
- { 0x10B9, 0x5261, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_ULI5261_ID },
- { 0x10B9, 0x5263, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_ULI5263_ID },
- { 0, }
+ { PCI_DEVICE(0x10B9, 0x5261), .driver_data = PCI_ULI5261_ID },
+ { PCI_DEVICE(0x10B9, 0x5263), .driver_data = PCI_ULI5263_ID },
+ { }
};
MODULE_DEVICE_TABLE(pci, uli526x_pci_tbl);
diff --git a/drivers/net/ethernet/dec/tulip/winbond-840.c b/drivers/net/ethernet/dec/tulip/winbond-840.c
index a24a25a5f73d..a5581f1d0141 100644
--- a/drivers/net/ethernet/dec/tulip/winbond-840.c
+++ b/drivers/net/ethernet/dec/tulip/winbond-840.c
@@ -210,9 +210,16 @@ enum chip_capability_flags {
};
static const struct pci_device_id w840_pci_tbl[] = {
- { 0x1050, 0x0840, PCI_ANY_ID, 0x8153, 0, 0, 0 },
- { 0x1050, 0x0840, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
- { 0x11f6, 0x2011, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
+ {
+ PCI_DEVICE_SUB(0x1050, 0x0840, PCI_ANY_ID, 0x8153),
+ .driver_data = 0,
+ }, {
+ PCI_DEVICE(0x1050, 0x0840),
+ .driver_data = 1,
+ }, {
+ PCI_DEVICE(0x11f6, 0x2011),
+ .driver_data = 2,
+ },
{ }
};
MODULE_DEVICE_TABLE(pci, w840_pci_tbl);
diff --git a/drivers/net/ethernet/dlink/dl2k.h b/drivers/net/ethernet/dlink/dl2k.h
index 9ebf7a6db93e..00ef7d03b4d6 100644
--- a/drivers/net/ethernet/dlink/dl2k.h
+++ b/drivers/net/ethernet/dlink/dl2k.h
@@ -418,12 +418,12 @@ struct netdev_private {
#define CHIP_IP1000A 1
static const struct pci_device_id rio_pci_tbl[] = {
- {0x1186, 0x4000, PCI_ANY_ID, PCI_ANY_ID, },
- {0x13f0, 0x1021, PCI_ANY_ID, PCI_ANY_ID, },
- { PCI_VDEVICE(SUNDANCE, 0x1023), CHIP_IP1000A },
- { PCI_VDEVICE(SUNDANCE, 0x2021), CHIP_IP1000A },
- { PCI_VDEVICE(DLINK, 0x9021), CHIP_IP1000A },
- { PCI_VDEVICE(DLINK, 0x4020), CHIP_IP1000A },
+ { PCI_DEVICE(0x1186, 0x4000) },
+ { PCI_DEVICE(0x13f0, 0x1021) },
+ { PCI_VDEVICE(SUNDANCE, 0x1023), .driver_data = CHIP_IP1000A },
+ { PCI_VDEVICE(SUNDANCE, 0x2021), .driver_data = CHIP_IP1000A },
+ { PCI_VDEVICE(DLINK, 0x9021), .driver_data = CHIP_IP1000A },
+ { PCI_VDEVICE(DLINK, 0x4020), .driver_data = CHIP_IP1000A },
{ }
};
MODULE_DEVICE_TABLE (pci, rio_pci_tbl);
diff --git a/drivers/net/ethernet/dlink/sundance.c b/drivers/net/ethernet/dlink/sundance.c
index 277c50ef773f..58873fcd3eaf 100644
--- a/drivers/net/ethernet/dlink/sundance.c
+++ b/drivers/net/ethernet/dlink/sundance.c
@@ -192,13 +192,13 @@ IVc. Errata
#endif
static const struct pci_device_id sundance_pci_tbl[] = {
- { 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
- { 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
- { 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
- { 0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3 },
- { 0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
- { 0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
- { 0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
+ { PCI_DEVICE_SUB(0x1186, 0x1002, 0x1186, 0x1002), .driver_data = 0 },
+ { PCI_DEVICE_SUB(0x1186, 0x1002, 0x1186, 0x1003), .driver_data = 1 },
+ { PCI_DEVICE_SUB(0x1186, 0x1002, 0x1186, 0x1012), .driver_data = 2 },
+ { PCI_DEVICE_SUB(0x1186, 0x1002, 0x1186, 0x1040), .driver_data = 3 },
+ { PCI_DEVICE(0x1186, 0x1002), .driver_data = 4 },
+ { PCI_DEVICE(0x13F0, 0x0201), .driver_data = 5 },
+ { PCI_DEVICE(0x13F0, 0x0200), .driver_data = 6 },
{ }
};
MODULE_DEVICE_TABLE(pci, sundance_pci_tbl);
diff --git a/drivers/net/ethernet/fealnx.c b/drivers/net/ethernet/fealnx.c
index 3c9961806f75..bdc38aac5850 100644
--- a/drivers/net/ethernet/fealnx.c
+++ b/drivers/net/ethernet/fealnx.c
@@ -1935,10 +1935,10 @@ static int netdev_close(struct net_device *dev)
}
static const struct pci_device_id fealnx_pci_tbl[] = {
- {0x1516, 0x0800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
- {0x1516, 0x0803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
- {0x1516, 0x0891, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
- {} /* terminate list */
+ { PCI_DEVICE(0x1516, 0x0800), .driver_data = 0 },
+ { PCI_DEVICE(0x1516, 0x0803), .driver_data = 1 },
+ { PCI_DEVICE(0x1516, 0x0891), .driver_data = 2 },
+ { } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, fealnx_pci_tbl);
diff --git a/drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c b/drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c
index 068da2fd1fea..b3e01b2f8319 100644
--- a/drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c
+++ b/drivers/net/ethernet/hisilicon/hibmcge/hbg_main.c
@@ -489,7 +489,7 @@ static void hbg_shutdown(struct pci_dev *pdev)
}
static const struct pci_device_id hbg_pci_tbl[] = {
- {PCI_VDEVICE(HUAWEI, 0x3730), 0},
+ { PCI_VDEVICE(HUAWEI, 0x3730) },
{ }
};
MODULE_DEVICE_TABLE(pci, hbg_pci_tbl);
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
index a3206c97923e..4c34a144d21c 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
@@ -86,25 +86,39 @@ module_param(page_pool_enabled, bool, 0400);
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id hns3_pci_tbl[] = {
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_GE), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA_MACSEC),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA_MACSEC),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_100G_RDMA_MACSEC),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_200G_RDMA),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_VF), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_RDMA_DCB_PFC_VF),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
+ {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_GE),
+ .driver_data = 0,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE),
+ .driver_data = 0,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA_MACSEC),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA_MACSEC),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_100G_RDMA_MACSEC),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_200G_RDMA),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_VF),
+ .driver_data = 0,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_RDMA_DCB_PFC_VF),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ },
/* required last entry */
- {0,}
+ { }
};
MODULE_DEVICE_TABLE(pci, hns3_pci_tbl);
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
index dd4045c773d4..e17b92a411a2 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
@@ -72,16 +72,16 @@ static struct hnae3_ae_algo ae_algo;
static struct workqueue_struct *hclge_wq;
static const struct pci_device_id ae_algo_pci_tbl[] = {
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_GE), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA_MACSEC), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA_MACSEC), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_100G_RDMA_MACSEC), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_200G_RDMA), 0},
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_GE) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_25GE_RDMA_MACSEC) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_50GE_RDMA_MACSEC) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_100G_RDMA_MACSEC) },
+ { PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_200G_RDMA) },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, ae_algo_pci_tbl);
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c
index 0cc911e6c732..063a692c2b41 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_main.c
@@ -26,11 +26,15 @@ static struct hnae3_ae_algo ae_algovf;
static struct workqueue_struct *hclgevf_wq;
static const struct pci_device_id ae_algovf_pci_tbl[] = {
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_VF), 0},
- {PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_RDMA_DCB_PFC_VF),
- HNAE3_DEV_SUPPORT_ROCE_DCB_BITS},
+ {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_VF),
+ .driver_data = 0,
+ }, {
+ PCI_VDEVICE(HUAWEI, HNAE3_DEV_ID_RDMA_DCB_PFC_VF),
+ .driver_data = HNAE3_DEV_SUPPORT_ROCE_DCB_BITS,
+ },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, ae_algovf_pci_tbl);
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_main.c b/drivers/net/ethernet/huawei/hinic/hinic_main.c
index ae1f523d6841..42f4792d255b 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_main.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_main.c
@@ -1467,12 +1467,12 @@ static void hinic_shutdown(struct pci_dev *pdev)
}
static const struct pci_device_id hinic_pci_table[] = {
- { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_QUAD_PORT_25GE), 0},
- { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_DUAL_PORT_100GE), 0},
- { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_DUAL_PORT_100GE_MEZZ), 0},
- { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_QUAD_PORT_25GE_MEZZ), 0},
- { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_VF), 0},
- { 0, 0}
+ { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_QUAD_PORT_25GE) },
+ { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_DUAL_PORT_100GE) },
+ { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_DUAL_PORT_100GE_MEZZ) },
+ { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_QUAD_PORT_25GE_MEZZ) },
+ { PCI_VDEVICE(HUAWEI, HINIC_DEV_ID_VF) },
+ { }
};
MODULE_DEVICE_TABLE(pci, hinic_pci_table);
diff --git a/drivers/net/ethernet/huawei/hinic3/hinic3_lld.c b/drivers/net/ethernet/huawei/hinic3/hinic3_lld.c
index f83d5bd1041e..36df807cbe09 100644
--- a/drivers/net/ethernet/huawei/hinic3/hinic3_lld.c
+++ b/drivers/net/ethernet/huawei/hinic3/hinic3_lld.c
@@ -426,10 +426,9 @@ static void hinic3_remove(struct pci_dev *pdev)
}
static const struct pci_device_id hinic3_pci_table[] = {
- {PCI_VDEVICE(HUAWEI, PCI_DEV_ID_HINIC3_PF), 0},
- {PCI_VDEVICE(HUAWEI, PCI_DEV_ID_HINIC3_VF), 0},
- {0, 0}
-
+ { PCI_VDEVICE(HUAWEI, PCI_DEV_ID_HINIC3_PF) },
+ { PCI_VDEVICE(HUAWEI, PCI_DEV_ID_HINIC3_VF) },
+ { }
};
MODULE_DEVICE_TABLE(pci, hinic3_pci_table);
diff --git a/drivers/net/ethernet/intel/e100.c b/drivers/net/ethernet/intel/e100.c
index 9074b558de35..5ef82a4e6184 100644
--- a/drivers/net/ethernet/intel/e100.c
+++ b/drivers/net/ethernet/intel/e100.c
@@ -177,8 +177,8 @@ MODULE_PARM_DESC(eeprom_bad_csum_allow, "Allow bad eeprom checksums");
MODULE_PARM_DESC(use_io, "Force use of i/o access mode");
#define INTEL_8255X_ETHERNET_DEVICE(device_id, ich) {\
- PCI_VENDOR_ID_INTEL, device_id, PCI_ANY_ID, PCI_ANY_ID, \
- PCI_CLASS_NETWORK_ETHERNET << 8, 0xFFFF00, ich }
+ PCI_VDEVICE(INTEL, device_id), \
+ .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = 0xFFFF00, .driver_data = ich }
static const struct pci_device_id e100_id_table[] = {
INTEL_8255X_ETHERNET_DEVICE(0x1029, 0),
INTEL_8255X_ETHERNET_DEVICE(0x1030, 0),
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 7ce0cc8ab8f4..5b7ba1594f0d 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -7799,137 +7799,370 @@ static const struct pci_error_handlers e1000_err_handler = {
};
static const struct pci_device_id e1000_pci_tbl[] = {
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_COPPER), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_FIBER), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER_LP),
- board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_FIBER), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_DUAL), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_QUAD), board_82571 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82571PT_QUAD_COPPER), board_82571 },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_COPPER),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_FIBER),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_COPPER_LP),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_QUAD_FIBER),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_DUAL),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571EB_SERDES_QUAD),
+ .driver_data = board_82571,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82571PT_QUAD_COPPER),
+ .driver_data = board_82571,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI), board_82572 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_COPPER), board_82572 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_FIBER), board_82572 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_SERDES), board_82572 },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI),
+ .driver_data = board_82572,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_COPPER),
+ .driver_data = board_82572,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_FIBER),
+ .driver_data = board_82572,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82572EI_SERDES),
+ .driver_data = board_82572,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E), board_82573 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E_IAMT), board_82573 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82573L), board_82573 },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E),
+ .driver_data = board_82573,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573E_IAMT),
+ .driver_data = board_82573,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82573L),
+ .driver_data = board_82573,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82574L), board_82574 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82574LA), board_82574 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82583V), board_82583 },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82574L),
+ .driver_data = board_82574,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82574LA),
+ .driver_data = board_82574,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_82583V),
+ .driver_data = board_82583,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_DPT),
- board_80003es2lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_SPT),
- board_80003es2lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_DPT),
- board_80003es2lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_SPT),
- board_80003es2lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_DPT),
+ .driver_data = board_80003es2lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_COPPER_SPT),
+ .driver_data = board_80003es2lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_DPT),
+ .driver_data = board_80003es2lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_80003ES2LAN_SERDES_SPT),
+ .driver_data = board_80003es2lan,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_G), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_GT), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_AMT), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_C), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M_AMT), board_ich8lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_82567V_3), board_ich8lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_G),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IFE_GT),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_AMT),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_C),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_IGP_M_AMT),
+ .driver_data = board_ich8lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH8_82567V_3),
+ .driver_data = board_ich8lan,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_G), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_GT), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_AMT), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_C), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_BM), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_AMT), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_V), board_ich9lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_G),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IFE_GT),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_AMT),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_C),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_BM),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_AMT),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH9_IGP_M_V),
+ .driver_data = board_ich9lan
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LM), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LF), board_ich9lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_V), board_ich9lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LM),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_LF),
+ .driver_data = board_ich9lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_R_BM_V),
+ .driver_data = board_ich9lan,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LM), board_ich10lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LF), board_ich10lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_V), board_ich10lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LM),
+ .driver_data = board_ich10lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_LF),
+ .driver_data = board_ich10lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_ICH10_D_BM_V),
+ .driver_data = board_ich10lan,
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LM), board_pchlan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LC), board_pchlan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DM), board_pchlan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DC), board_pchlan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LM),
+ .driver_data = board_pchlan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_M_HV_LC),
+ .driver_data = board_pchlan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DM),
+ .driver_data = board_pchlan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_D_HV_DC),
+ .driver_data = board_pchlan
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_LM), board_pch2lan },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_V), board_pch2lan },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_LM),
+ .driver_data = board_pch2lan,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH2_LV_V),
+ .driver_data = board_pch2lan
+ },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_LM), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_V), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_LM), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_V), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM2), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V2), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM3), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V3), board_pch_lpt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM2), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V2), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LBG_I219_LM3), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM4), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V4), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM5), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V5), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_LM6), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_V6), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_LM7), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_V7), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_LM8), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_V8), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_LM9), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_V9), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM10), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V10), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM11), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V11), board_pch_cnp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM12), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V12), board_pch_spt },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM13), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V13), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM14), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V14), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM15), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V15), board_pch_tgp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_LM23), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_V23), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM16), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V16), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM17), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V17), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_LM22), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_V22), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM19), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V19), board_pch_adp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_MTP_I219_LM18), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_MTP_I219_V18), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_LM20), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_V20), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_LM21), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_V21), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_LM24), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_V24), board_pch_mtp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM25), board_pch_ptp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V25), board_pch_ptp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM27), board_pch_ptp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V27), board_pch_ptp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_LM29), board_pch_ptp },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_V29), board_pch_ptp },
+ {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_LM),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPT_I217_V),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_LM),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LPTLP_I218_V),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM2),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V2),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_LM3),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_I218_V3),
+ .driver_data = board_pch_lpt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM2),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V2),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LBG_I219_LM3),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM4),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V4),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_LM5),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_SPT_I219_V5),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_LM6),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_V6),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_LM7),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CNP_I219_V7),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_LM8),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_V8),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_LM9),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ICP_I219_V9),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM10),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V10),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM11),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V11),
+ .driver_data = board_pch_cnp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_LM12),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_CMP_I219_V12),
+ .driver_data = board_pch_spt,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM13),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V13),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM14),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V14),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_LM15),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_TGP_I219_V15),
+ .driver_data = board_pch_tgp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_LM23),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_V23),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM16),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V16),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM17),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V17),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_LM22),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_RPL_I219_V22),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_LM19),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ADP_I219_V19),
+ .driver_data = board_pch_adp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_MTP_I219_LM18),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_MTP_I219_V18),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_LM20),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_V20),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_LM21),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_LNP_I219_V21),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_LM24),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_ARL_I219_V24),
+ .driver_data = board_pch_mtp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM25),
+ .driver_data = board_pch_ptp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V25),
+ .driver_data = board_pch_ptp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_LM27),
+ .driver_data = board_pch_ptp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_PTP_I219_V27),
+ .driver_data = board_pch_ptp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_LM29),
+ .driver_data = board_pch_ptp,
+ }, {
+ PCI_VDEVICE(INTEL, E1000_DEV_ID_PCH_NVL_I219_V29),
+ .driver_data = board_pch_ptp
+ },
- { 0, 0, 0, 0, 0, 0, 0 } /* terminate list */
+ { } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
index d75b8a50413d..f5b4d062709a 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_pci.c
@@ -21,12 +21,12 @@ static const struct fm10k_info *fm10k_info_tbl[] = {
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id fm10k_pci_tbl[] = {
- { PCI_VDEVICE(INTEL, FM10K_DEV_ID_PF), fm10k_device_pf },
- { PCI_VDEVICE(INTEL, FM10K_DEV_ID_SDI_FM10420_QDA2), fm10k_device_pf },
- { PCI_VDEVICE(INTEL, FM10K_DEV_ID_SDI_FM10420_DA2), fm10k_device_pf },
- { PCI_VDEVICE(INTEL, FM10K_DEV_ID_VF), fm10k_device_vf },
+ { PCI_VDEVICE(INTEL, FM10K_DEV_ID_PF), .driver_data = fm10k_device_pf },
+ { PCI_VDEVICE(INTEL, FM10K_DEV_ID_SDI_FM10420_QDA2), .driver_data = fm10k_device_pf },
+ { PCI_VDEVICE(INTEL, FM10K_DEV_ID_SDI_FM10420_DA2), .driver_data = fm10k_device_pf },
+ { PCI_VDEVICE(INTEL, FM10K_DEV_ID_VF), .driver_data = fm10k_device_vf },
/* required last entry */
- { 0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, fm10k_pci_tbl);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 028bd500603a..93faada2d328 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -63,40 +63,43 @@ static bool i40e_is_total_port_shutdown_enabled(struct i40e_pf *pf);
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id i40e_pci_tbl[] = {
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_XL710), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_QEMU), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_B), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_C), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_A), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_B), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_C), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_BC), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T4), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_BC), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_SFP), 0},
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_XL710) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_QEMU) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_B) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_C) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_A) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_B) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_C) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_BC) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T4) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_BC) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_SFP) },
/*
* This ID conflicts with ipw2200, but the devices can be differentiated
* because i40e devices use PCI_CLASS_NETWORK_ETHERNET and ipw2200
* devices use PCI_CLASS_NETWORK_OTHER.
*/
- {PCI_DEVICE(PCI_VENDOR_ID_INTEL, I40E_DEV_ID_10G_B),
- PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_I_X722), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722_A), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2_A), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_X710_N3000), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_XXV710_N3000), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_B), 0},
- {PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_SFP28), 0},
+ {
+ PCI_DEVICE(PCI_VENDOR_ID_INTEL, I40E_DEV_ID_10G_B),
+ .class = PCI_CLASS_NETWORK_ETHERNET << 8,
+ .class_mask = 0xffff00,
+ },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_KX_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_QSFP_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_1G_BASE_T_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_10G_BASE_T_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_I_X722) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_SFP_X722_A) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_20G_KR2_A) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_X710_N3000) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_XXV710_N3000) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_B) },
+ { PCI_VDEVICE(INTEL, I40E_DEV_ID_25G_SFP28) },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, i40e_pci_tbl);
diff --git a/drivers/net/ethernet/intel/iavf/iavf_main.c b/drivers/net/ethernet/intel/iavf/iavf_main.c
index 3c1465cf0515..f00692f1e459 100644
--- a/drivers/net/ethernet/intel/iavf/iavf_main.c
+++ b/drivers/net/ethernet/intel/iavf/iavf_main.c
@@ -36,12 +36,12 @@ static const char iavf_copyright[] =
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id iavf_pci_tbl[] = {
- {PCI_VDEVICE(INTEL, IAVF_DEV_ID_VF), 0},
- {PCI_VDEVICE(INTEL, IAVF_DEV_ID_VF_HV), 0},
- {PCI_VDEVICE(INTEL, IAVF_DEV_ID_X722_VF), 0},
- {PCI_VDEVICE(INTEL, IAVF_DEV_ID_ADAPTIVE_VF), 0},
+ { PCI_VDEVICE(INTEL, IAVF_DEV_ID_VF) },
+ { PCI_VDEVICE(INTEL, IAVF_DEV_ID_VF_HV) },
+ { PCI_VDEVICE(INTEL, IAVF_DEV_ID_X722_VF) },
+ { PCI_VDEVICE(INTEL, IAVF_DEV_ID_ADAPTIVE_VF) },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, iavf_pci_tbl);
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index ce91dda00ec0..49d46670695f 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -63,40 +63,40 @@ static const struct pci_device_id igb_pci_tbl[] = {
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_FIBER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SGMII), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_FIBER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_QUAD_FIBER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SGMII), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER_DUAL), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SGMII), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_BACKPLANE), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SFP), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES_QUAD), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER_ET2), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), board_82575 },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575GB_QUAD_COPPER), board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_FIBER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_SGMII), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_FIBER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_QUAD_FIBER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_SGMII), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82580_COPPER_DUAL), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SGMII), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_BACKPLANE), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_DH89XXCC_SFP), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_NS_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_FIBER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_SERDES_QUAD), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER_ET2), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_QUAD_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_COPPER), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575EB_FIBER_SERDES), .driver_data = board_82575 },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82575GB_QUAD_COPPER), .driver_data = board_82575 },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, igb_pci_tbl);
diff --git a/drivers/net/ethernet/intel/igbvf/netdev.c b/drivers/net/ethernet/intel/igbvf/netdev.c
index 5d04541072b3..0a3d0a1cba43 100644
--- a/drivers/net/ethernet/intel/igbvf/netdev.c
+++ b/drivers/net/ethernet/intel/igbvf/netdev.c
@@ -2937,8 +2937,8 @@ static const struct pci_error_handlers igbvf_err_handler = {
};
static const struct pci_device_id igbvf_pci_tbl[] = {
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_VF), board_vf },
- { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_VF), board_i350_vf },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_82576_VF), .driver_data = board_vf },
+ { PCI_VDEVICE(INTEL, E1000_DEV_ID_I350_VF), .driver_data = board_i350_vf },
{ } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, igbvf_pci_tbl);
diff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c
index 8ac16808023c..89b9e1d00fc7 100644
--- a/drivers/net/ethernet/intel/igc/igc_main.c
+++ b/drivers/net/ethernet/intel/igc/igc_main.c
@@ -47,24 +47,24 @@ static const struct igc_info *igc_info_tbl[] = {
};
static const struct pci_device_id igc_pci_tbl[] = {
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_LM), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_V), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_I), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I220_V), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_K), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_K2), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_K), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_LMVP), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_LMVP), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_IT), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_LM), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_V), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_IT), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I221_V), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_BLANK_NVM), board_base },
- { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_BLANK_NVM), board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_LM), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_V), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_I), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I220_V), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_K), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_K2), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_K), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_LMVP), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_LMVP), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_IT), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_LM), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_V), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_IT), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I221_V), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I226_BLANK_NVM), .driver_data = board_base },
+ { PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_BLANK_NVM), .driver_data = board_base },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, igc_pci_tbl);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 2646ee6f295f..730a35658c76 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -88,60 +88,60 @@ static const struct ixgbe_info *ixgbe_info_tbl[] = {
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id ixgbe_pci_tbl[] = {
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_DUAL_PORT), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_SINGLE_PORT), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AT), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AT2), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_CX4), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_CX4_DUAL_PORT), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_DA_DUAL_PORT), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_XF_LR), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_SFP_LOM), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_BX), board_82598 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_XAUI_LOM), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KR), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_EM), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4_MEZZ), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_CX4), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_BACKPLANE_FCOE), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_FCOE), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_T3_LOM), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_COMBO_BACKPLANE), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540T), board_X540 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_SF2), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_LS), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_QSFP_SF_QP), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599EN_SFP), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_SF_QP), board_82599 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540T1), board_X540 },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T), board_X550},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T1), board_X550},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KX4), board_X550EM_x},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_XFI), board_X550EM_x},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KR), board_X550EM_x},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_10G_T), board_X550EM_x},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_SFP), board_X550EM_x},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_1G_T), board_x550em_x_fw},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR_L), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP_N), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII_L), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_10G_T), board_x550em_a},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP), board_x550em_a },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_1G_T), board_x550em_a_fw },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_1G_T_L), board_x550em_a_fw },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_BACKPLANE), board_e610},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_SFP), board_e610},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_10G_T), board_e610},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_2_5G_T), board_e610},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_SGMII), board_e610},
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_DUAL_PORT), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AF_SINGLE_PORT), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AT), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598AT2), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_CX4), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_CX4_DUAL_PORT), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_DA_DUAL_PORT), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_SR_DUAL_PORT_EM), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_XF_LR), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598EB_SFP_LOM), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82598_BX), .driver_data = board_82598 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_XAUI_LOM), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KR), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_EM), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_KX4_MEZZ), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_CX4), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_BACKPLANE_FCOE), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_FCOE), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_T3_LOM), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_COMBO_BACKPLANE), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540T), .driver_data = board_X540 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_SF2), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_LS), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_QSFP_SF_QP), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599EN_SFP), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_SFP_SF_QP), .driver_data = board_82599 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540T1), .driver_data = board_X540 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T), .driver_data = board_X550 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550T1), .driver_data = board_X550 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KX4), .driver_data = board_X550EM_x },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_XFI), .driver_data = board_X550EM_x },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_KR), .driver_data = board_X550EM_x },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_10G_T), .driver_data = board_X550EM_x },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_SFP), .driver_data = board_X550EM_x },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_1G_T), .driver_data = board_x550em_x_fw },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_KR_L), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP_N), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SGMII_L), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_10G_T), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_SFP), .driver_data = board_x550em_a },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_1G_T), .driver_data = board_x550em_a_fw },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_1G_T_L), .driver_data = board_x550em_a_fw },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_BACKPLANE), .driver_data = board_e610 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_SFP), .driver_data = board_e610 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_10G_T), .driver_data = board_e610 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_2_5G_T), .driver_data = board_e610 },
+ { PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_SGMII), .driver_data = board_e610 },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, ixgbe_pci_tbl);
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 42f89a179a3f..b5d15c1f0d4f 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -64,20 +64,43 @@ static const struct ixgbevf_info *ixgbevf_info_tbl[] = {
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id ixgbevf_pci_tbl[] = {
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF), board_82599_vf },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF_HV), board_82599_vf_hv },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF), board_X540_vf },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF_HV), board_X540_vf_hv },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF), board_X550_vf },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF_HV), board_X550_vf_hv },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF), board_X550EM_x_vf },
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF_HV), board_X550EM_x_vf_hv},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_VF), board_x550em_a_vf },
- {PCI_VDEVICE_SUB(INTEL, IXGBE_DEV_ID_E610_VF, PCI_ANY_ID,
- IXGBE_SUBDEV_ID_E610_VF_HV), board_e610_vf_hv},
- {PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_VF), board_e610_vf},
+ {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF),
+ .driver_data = board_82599_vf,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_82599_VF_HV),
+ .driver_data = board_82599_vf_hv,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF),
+ .driver_data = board_X540_vf,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X540_VF_HV),
+ .driver_data = board_X540_vf_hv,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF),
+ .driver_data = board_X550_vf,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550_VF_HV),
+ .driver_data = board_X550_vf_hv,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF),
+ .driver_data = board_X550EM_x_vf,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_X_VF_HV),
+ .driver_data = board_X550EM_x_vf_hv
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_X550EM_A_VF),
+ .driver_data = board_x550em_a_vf,
+ }, {
+ PCI_VDEVICE_SUB(INTEL, IXGBE_DEV_ID_E610_VF,
+ PCI_ANY_ID, IXGBE_SUBDEV_ID_E610_VF_HV),
+ .driver_data = board_e610_vf_hv,
+ }, {
+ PCI_VDEVICE(INTEL, IXGBE_DEV_ID_E610_VF),
+ .driver_data = board_e610_vf,
+ },
/* required last entry */
- {0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, ixgbevf_pci_tbl);
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index e6b7e75894ff..4fe6dbf0942f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -4274,9 +4274,9 @@ int mlx4_restart_one(struct pci_dev *pdev)
return mlx4_restart_one_up(pdev, false, NULL);
}
-#define MLX_SP(id) { PCI_VDEVICE(MELLANOX, id), MLX4_PCI_DEV_FORCE_SENSE_PORT }
-#define MLX_VF(id) { PCI_VDEVICE(MELLANOX, id), MLX4_PCI_DEV_IS_VF }
-#define MLX_GN(id) { PCI_VDEVICE(MELLANOX, id), 0 }
+#define MLX_SP(id) { PCI_VDEVICE(MELLANOX, id), .driver_data = MLX4_PCI_DEV_FORCE_SENSE_PORT }
+#define MLX_VF(id) { PCI_VDEVICE(MELLANOX, id), .driver_data = MLX4_PCI_DEV_IS_VF }
+#define MLX_GN(id) { PCI_VDEVICE(MELLANOX, id), .driver_data = 0 }
static const struct pci_device_id mlx4_pci_table[] = {
#ifdef CONFIG_MLX4_CORE_GEN2
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c
index 74827e8ca125..ff450269ce37 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c
@@ -2203,19 +2203,26 @@ static int mlx5_resume(struct pci_dev *pdev)
static const struct pci_device_id mlx5_core_pci_table[] = {
{ PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_CONNECTIB) },
- { PCI_VDEVICE(MELLANOX, 0x1012), MLX5_PCI_DEV_IS_VF}, /* Connect-IB VF */
+ { PCI_VDEVICE(MELLANOX, 0x1012),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* Connect-IB VF */
{ PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_CONNECTX4) },
- { PCI_VDEVICE(MELLANOX, 0x1014), MLX5_PCI_DEV_IS_VF}, /* ConnectX-4 VF */
+ { PCI_VDEVICE(MELLANOX, 0x1014),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX-4 VF */
{ PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_CONNECTX4_LX) },
- { PCI_VDEVICE(MELLANOX, 0x1016), MLX5_PCI_DEV_IS_VF}, /* ConnectX-4LX VF */
+ { PCI_VDEVICE(MELLANOX, 0x1016),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX-4LX VF */
{ PCI_VDEVICE(MELLANOX, 0x1017) }, /* ConnectX-5, PCIe 3.0 */
- { PCI_VDEVICE(MELLANOX, 0x1018), MLX5_PCI_DEV_IS_VF}, /* ConnectX-5 VF */
+ { PCI_VDEVICE(MELLANOX, 0x1018),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX-5 VF */
{ PCI_VDEVICE(MELLANOX, 0x1019) }, /* ConnectX-5 Ex */
- { PCI_VDEVICE(MELLANOX, 0x101a), MLX5_PCI_DEV_IS_VF}, /* ConnectX-5 Ex VF */
+ { PCI_VDEVICE(MELLANOX, 0x101a),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX-5 Ex VF */
{ PCI_VDEVICE(MELLANOX, 0x101b) }, /* ConnectX-6 */
- { PCI_VDEVICE(MELLANOX, 0x101c), MLX5_PCI_DEV_IS_VF}, /* ConnectX-6 VF */
+ { PCI_VDEVICE(MELLANOX, 0x101c),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX-6 VF */
{ PCI_VDEVICE(MELLANOX, 0x101d) }, /* ConnectX-6 Dx */
- { PCI_VDEVICE(MELLANOX, 0x101e), MLX5_PCI_DEV_IS_VF}, /* ConnectX Family mlx5Gen Virtual Function */
+ { PCI_VDEVICE(MELLANOX, 0x101e),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* ConnectX Family mlx5Gen Virtual Function */
{ PCI_VDEVICE(MELLANOX, 0x101f) }, /* ConnectX-6 LX */
{ PCI_VDEVICE(MELLANOX, 0x1021) }, /* ConnectX-7 */
{ PCI_VDEVICE(MELLANOX, 0x1023) }, /* ConnectX-8 */
@@ -2223,11 +2230,12 @@ static const struct pci_device_id mlx5_core_pci_table[] = {
{ PCI_VDEVICE(MELLANOX, 0x1027) }, /* ConnectX-10 */
{ PCI_VDEVICE(MELLANOX, 0x2101) }, /* ConnectX-10 NVLink-C2C */
{ PCI_VDEVICE(MELLANOX, 0xa2d2) }, /* BlueField integrated ConnectX-5 network controller */
- { PCI_VDEVICE(MELLANOX, 0xa2d3), MLX5_PCI_DEV_IS_VF}, /* BlueField integrated ConnectX-5 network controller VF */
+ { PCI_VDEVICE(MELLANOX, 0xa2d3),
+ .driver_data = MLX5_PCI_DEV_IS_VF }, /* BlueField integrated ConnectX-5 network controller VF */
{ PCI_VDEVICE(MELLANOX, 0xa2d6) }, /* BlueField-2 integrated ConnectX-6 Dx network controller */
{ PCI_VDEVICE(MELLANOX, 0xa2dc) }, /* BlueField-3 integrated ConnectX-7 network controller */
{ PCI_VDEVICE(MELLANOX, 0xa2df) }, /* BlueField-4 integrated ConnectX-8 network controller */
- { 0, }
+ { }
};
MODULE_DEVICE_TABLE(pci, mlx5_core_pci_table);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index 3a65420fa1ad..1aaa75b47fe3 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -5277,8 +5277,8 @@ static int mlxsw_sp_netdevice_event(struct notifier_block *nb,
}
static const struct pci_device_id mlxsw_sp1_pci_id_table[] = {
- {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM), 0},
- {0, },
+ {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM) },
+ { },
};
static struct pci_driver mlxsw_sp1_pci_driver = {
@@ -5287,8 +5287,8 @@ static struct pci_driver mlxsw_sp1_pci_driver = {
};
static const struct pci_device_id mlxsw_sp2_pci_id_table[] = {
- {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM2), 0},
- {0, },
+ {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM2) },
+ { },
};
static struct pci_driver mlxsw_sp2_pci_driver = {
@@ -5297,8 +5297,8 @@ static struct pci_driver mlxsw_sp2_pci_driver = {
};
static const struct pci_device_id mlxsw_sp3_pci_id_table[] = {
- {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM3), 0},
- {0, },
+ {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM3) },
+ { },
};
static struct pci_driver mlxsw_sp3_pci_driver = {
@@ -5307,8 +5307,8 @@ static struct pci_driver mlxsw_sp3_pci_driver = {
};
static const struct pci_device_id mlxsw_sp4_pci_id_table[] = {
- {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM4), 0},
- {0, },
+ {PCI_VDEVICE(MELLANOX, PCI_DEVICE_ID_MELLANOX_SPECTRUM4) },
+ { },
};
static struct pci_driver mlxsw_sp4_pci_driver = {
diff --git a/drivers/net/ethernet/micrel/ksz884x.c b/drivers/net/ethernet/micrel/ksz884x.c
index 26557cd32008..773fdd215a15 100644
--- a/drivers/net/ethernet/micrel/ksz884x.c
+++ b/drivers/net/ethernet/micrel/ksz884x.c
@@ -6839,11 +6839,9 @@ static int __maybe_unused pcidev_suspend(struct device *dev_d)
static char pcidev_name[] = "ksz884xp";
static const struct pci_device_id pcidev_table[] = {
- { PCI_VENDOR_ID_MICREL_KS, 0x8841,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_MICREL_KS, 0x8842,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
- { 0 }
+ { PCI_VDEVICE(MICREL_KS, 0x8841) },
+ { PCI_VDEVICE(MICREL_KS, 0x8842) },
+ { }
};
MODULE_DEVICE_TABLE(pci, pcidev_table);
diff --git a/drivers/net/ethernet/mucse/rnpgbe/rnpgbe_main.c b/drivers/net/ethernet/mucse/rnpgbe/rnpgbe_main.c
index 316f941629d4..70a2b0082ba8 100644
--- a/drivers/net/ethernet/mucse/rnpgbe/rnpgbe_main.c
+++ b/drivers/net/ethernet/mucse/rnpgbe/rnpgbe_main.c
@@ -17,12 +17,12 @@ static const char rnpgbe_driver_name[] = "rnpgbe";
* private_data (used for different hw chip) }
*/
static struct pci_device_id rnpgbe_pci_tbl[] = {
- { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N210), board_n210 },
- { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N210L), board_n210 },
- { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N500_DUAL_PORT), board_n500 },
- { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N500_QUAD_PORT), board_n500 },
+ { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N210), .driver_data = board_n210 },
+ { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N210L), .driver_data = board_n210 },
+ { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N500_DUAL_PORT), .driver_data = board_n500 },
+ { PCI_VDEVICE(MUCSE, RNPGBE_DEVICE_ID_N500_QUAD_PORT), .driver_data = board_n500 },
/* required last entry */
- {0, },
+ { },
};
/**
diff --git a/drivers/net/ethernet/natsemi/natsemi.c b/drivers/net/ethernet/natsemi/natsemi.c
index b253734dbc80..35a63b78880b 100644
--- a/drivers/net/ethernet/natsemi/natsemi.c
+++ b/drivers/net/ethernet/natsemi/natsemi.c
@@ -248,8 +248,8 @@ static struct {
};
static const struct pci_device_id natsemi_pci_tbl[] = {
- { PCI_VENDOR_ID_NS, 0x0020, 0x12d9, 0x000c, 0, 0, 0 },
- { PCI_VENDOR_ID_NS, 0x0020, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
+ { PCI_VDEVICE_SUB(NS, 0x0020, 0x12d9, 0x000c), .driver_data = 0 },
+ { PCI_VDEVICE(NS, 0x0020), .driver_data = 1 },
{ } /* terminate list */
};
MODULE_DEVICE_TABLE(pci, natsemi_pci_tbl);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_main.c b/drivers/net/ethernet/netronome/nfp/nfp_main.c
index 48390b2fd44d..e8e4b84d505a 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_main.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_main.c
@@ -33,39 +33,56 @@
static const char nfp_driver_name[] = "nfp";
static const struct pci_device_id nfp_pci_device_ids[] = {
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP3800,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP3800,
+ {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP3800,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP3800,
+ }, {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP4000,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
+ }, {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP5000,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
+ }, {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP6000,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP3800,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP3800,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP4000,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP5000,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP6000,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000,
},
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP4000,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP5000,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP6000,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP3800,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP3800,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP4000,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP5000,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP6000,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000,
- },
- { 0, } /* Required last entry. */
+ { } /* Required last entry. */
};
MODULE_DEVICE_TABLE(pci, nfp_pci_device_ids);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_netvf_main.c b/drivers/net/ethernet/netronome/nfp/nfp_netvf_main.c
index b5646c884371..cf557e0ce011 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_netvf_main.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_netvf_main.c
@@ -38,23 +38,32 @@ struct nfp_net_vf {
static const char nfp_net_driver_name[] = "nfp_netvf";
static const struct pci_device_id nfp_netvf_pci_device_ids[] = {
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP3800_VF,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP3800_VF,
+ {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP3800_VF,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP3800_VF,
+ }, {
+ PCI_VDEVICE_SUB(NETRONOME, PCI_DEVICE_ID_NFP6000_VF,
+ PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000_VF,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP3800_VF,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP3800_VF,
+ }, {
+ PCI_VDEVICE_SUB(CORIGINE, PCI_DEVICE_ID_NFP6000_VF,
+ PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID),
+ .class = PCI_ANY_ID,
+ .class_mask = 0,
+ .driver_data = NFP_DEV_NFP6000_VF,
},
- { PCI_VENDOR_ID_NETRONOME, PCI_DEVICE_ID_NFP6000_VF,
- PCI_VENDOR_ID_NETRONOME, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000_VF,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP3800_VF,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP3800_VF,
- },
- { PCI_VENDOR_ID_CORIGINE, PCI_DEVICE_ID_NFP6000_VF,
- PCI_VENDOR_ID_CORIGINE, PCI_ANY_ID,
- PCI_ANY_ID, 0, NFP_DEV_NFP6000_VF,
- },
- { 0, } /* Required last entry. */
+ { } /* Required last entry. */
};
MODULE_DEVICE_TABLE(pci, nfp_netvf_pci_device_ids);
diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 39842eb73bc3..cb0ae0650905 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -76,20 +76,20 @@ enum qede_pci_private {
};
static const struct pci_device_id qede_pci_tbl[] = {
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_40), QEDE_PRIVATE_PF},
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_10), QEDE_PRIVATE_PF},
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_MF), QEDE_PRIVATE_PF},
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_100), QEDE_PRIVATE_PF},
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_50), QEDE_PRIVATE_PF},
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_25), QEDE_PRIVATE_PF},
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_40), .driver_data = QEDE_PRIVATE_PF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_10), .driver_data = QEDE_PRIVATE_PF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_MF), .driver_data = QEDE_PRIVATE_PF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_100), .driver_data = QEDE_PRIVATE_PF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_50), .driver_data = QEDE_PRIVATE_PF },
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_25), .driver_data = QEDE_PRIVATE_PF },
#ifdef CONFIG_QED_SRIOV
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_IOV), QEDE_PRIVATE_VF},
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_57980S_IOV), .driver_data = QEDE_PRIVATE_VF },
#endif
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_AH), QEDE_PRIVATE_PF},
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_AH), .driver_data = QEDE_PRIVATE_PF },
#ifdef CONFIG_QED_SRIOV
- {PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_AH_IOV), QEDE_PRIVATE_VF},
+ { PCI_VDEVICE(QLOGIC, PCI_DEVICE_ID_AH_IOV), .driver_data = QEDE_PRIVATE_VF },
#endif
- { 0 }
+ { }
};
MODULE_DEVICE_TABLE(pci, qede_pci_tbl);
diff --git a/drivers/net/ethernet/realtek/8139too.c b/drivers/net/ethernet/realtek/8139too.c
index a8532ebd42ec..8241bcf76664 100644
--- a/drivers/net/ethernet/realtek/8139too.c
+++ b/drivers/net/ethernet/realtek/8139too.c
@@ -235,44 +235,44 @@ static const struct {
static const struct pci_device_id rtl8139_pci_tbl[] = {
- {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
- {0x16ec, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
+ { PCI_DEVICE(0x10ec, 0x8139), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x10ec, 0x8138), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1113, 0x1211), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1500, 0x1360), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x4033, 0x1360), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1186, 0x1300), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1186, 0x1340), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x13d1, 0xab06), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1259, 0xa117), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1259, 0xa11e), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x14ea, 0xab06), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x14ea, 0xab07), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x11db, 0x1234), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1432, 0x9130), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x02ac, 0x1012), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x018a, 0x0106), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x126c, 0x1211), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x1743, 0x8139), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x021b, 0x8139), .driver_data = RTL8139 },
+ { PCI_DEVICE(0x16ec, 0xab06), .driver_data = RTL8139 },
#ifdef CONFIG_SH_SECUREEDGE5410
/* Bogus 8139 silicon reports 8129 without external PROM :-( */
- {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
+ { PCI_DEVICE(0x10ec, 0x8129), .driver_data = RTL8139 },
#endif
#ifdef CONFIG_8139TOO_8129
- {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
+ { PCI_DEVICE(0x10ec, 0x8129), .driver_data = RTL8129 },
#endif
/* some crazy cards report invalid vendor ids like
* 0x0001 here. The other ids are valid and constant,
* so we simply don't match on the main vendor id.
*/
- {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
- {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
- {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
+ { PCI_DEVICE_SUB(PCI_ANY_ID, 0x8139, 0x10ec, 0x8139), .driver_data = RTL8139 },
+ { PCI_DEVICE_SUB(PCI_ANY_ID, 0x8139, 0x1186, 0x1300), .driver_data = RTL8139 },
+ { PCI_DEVICE_SUB(PCI_ANY_ID, 0x8139, 0x13d1, 0xab06), .driver_data = RTL8139 },
- {0,}
+ { }
};
MODULE_DEVICE_TABLE (pci, rtl8139_pci_tbl);
diff --git a/drivers/net/ethernet/realtek/r8169_main.c b/drivers/net/ethernet/realtek/r8169_main.c
index 791277e750ba..ec4fc21fa21f 100644
--- a/drivers/net/ethernet/realtek/r8169_main.c
+++ b/drivers/net/ethernet/realtek/r8169_main.c
@@ -229,7 +229,7 @@ static const struct pci_device_id rtl8169_pci_tbl[] = {
{ PCI_VDEVICE(REALTEK, 0x2502) },
{ PCI_VDEVICE(REALTEK, 0x2600) },
{ PCI_VDEVICE(REALTEK, 0x8129) },
- { PCI_VDEVICE(REALTEK, 0x8136), RTL_CFG_NO_GBIT },
+ { PCI_VDEVICE(REALTEK, 0x8136), .driver_data = RTL_CFG_NO_GBIT },
{ PCI_VDEVICE(REALTEK, 0x8161) },
{ PCI_VDEVICE(REALTEK, 0x8162) },
{ PCI_VDEVICE(REALTEK, 0x8167) },
@@ -240,15 +240,15 @@ static const struct pci_device_id rtl8169_pci_tbl[] = {
{ PCI_VDEVICE(DLINK, 0x4302) },
{ PCI_VDEVICE(AT, 0xc107) },
{ PCI_VDEVICE(USR, 0x0116) },
- { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0024 },
- { 0x0001, 0x8168, PCI_ANY_ID, 0x2410 },
+ { PCI_VDEVICE_SUB(LINKSYS, 0x1032, PCI_ANY_ID, 0x0024) },
+ { PCI_DEVICE_SUB(0x0001, 0x8168, PCI_ANY_ID, 0x2410) },
{ PCI_VDEVICE(REALTEK, 0x8125) },
{ PCI_VDEVICE(REALTEK, 0x8126) },
{ PCI_VDEVICE(REALTEK, 0x8127) },
{ PCI_VDEVICE(REALTEK, 0x3000) },
{ PCI_VDEVICE(REALTEK, 0x5000) },
{ PCI_VDEVICE(REALTEK, 0x0e10) },
- {}
+ { }
};
MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl);
diff --git a/drivers/net/ethernet/rocker/rocker_main.c b/drivers/net/ethernet/rocker/rocker_main.c
index ff6ca7b2cd4f..84a55f2b48ff 100644
--- a/drivers/net/ethernet/rocker/rocker_main.c
+++ b/drivers/net/ethernet/rocker/rocker_main.c
@@ -40,8 +40,8 @@
static const char rocker_driver_name[] = "rocker";
static const struct pci_device_id rocker_pci_id_table[] = {
- {PCI_VDEVICE(REDHAT, PCI_DEVICE_ID_REDHAT_ROCKER), 0},
- {0, }
+ { PCI_VDEVICE(REDHAT, PCI_DEVICE_ID_REDHAT_ROCKER) },
+ { }
};
struct rocker_wait {
diff --git a/drivers/net/ethernet/sis/sis190.c b/drivers/net/ethernet/sis/sis190.c
index 12ddea514910..ed5276d492b9 100644
--- a/drivers/net/ethernet/sis/sis190.c
+++ b/drivers/net/ethernet/sis/sis190.c
@@ -331,9 +331,9 @@ static const struct {
};
static const struct pci_device_id sis190_pci_tbl[] = {
- { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0190), 0, 0, 0 },
- { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0191), 0, 0, 1 },
- { 0, },
+ { PCI_VDEVICE(SI, 0x0190), .driver_data = 0 },
+ { PCI_VDEVICE(SI, 0x0191), .driver_data = 1 },
+ { },
};
MODULE_DEVICE_TABLE(pci, sis190_pci_tbl);
diff --git a/drivers/net/ethernet/sis/sis900.c b/drivers/net/ethernet/sis/sis900.c
index 1349ef50cd26..6e9afd9042f7 100644
--- a/drivers/net/ethernet/sis/sis900.c
+++ b/drivers/net/ethernet/sis/sis900.c
@@ -104,11 +104,11 @@ static const char * card_names[] = {
};
static const struct pci_device_id sis900_pci_tbl[] = {
- {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_900,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_900},
- {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7016,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7016},
- {0,}
+ { PCI_VDEVICE(SI, PCI_DEVICE_ID_SI_900),
+ .driver_data = SIS_900 },
+ { PCI_VDEVICE(SI, PCI_DEVICE_ID_SI_7016),
+ .driver_data = SIS_7016 },
+ { }
};
MODULE_DEVICE_TABLE (pci, sis900_pci_tbl);
diff --git a/drivers/net/ethernet/smsc/epic100.c b/drivers/net/ethernet/smsc/epic100.c
index 389659db06a8..60538b7fe684 100644
--- a/drivers/net/ethernet/smsc/epic100.c
+++ b/drivers/net/ethernet/smsc/epic100.c
@@ -166,11 +166,19 @@ static const struct epic_chip_info pci_id_tbl[] = {
static const struct pci_device_id epic_pci_tbl[] = {
- { 0x10B8, 0x0005, 0x1092, 0x0AB4, 0, 0, SMSC_83C170_0 },
- { 0x10B8, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMSC_83C170 },
- { 0x10B8, 0x0006, PCI_ANY_ID, PCI_ANY_ID,
- PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, SMSC_83C175 },
- { 0,}
+ {
+ PCI_DEVICE_SUB(0x10B8, 0x0005, 0x1092, 0x0AB4),
+ .driver_data = SMSC_83C170_0,
+ }, {
+ PCI_DEVICE(0x10B8, 0x0005),
+ .driver_data = SMSC_83C170,
+ }, {
+ PCI_DEVICE(0x10B8, 0x0006),
+ .class = PCI_CLASS_NETWORK_ETHERNET << 8,
+ .class_mask = 0xffff00,
+ .driver_data = SMSC_83C175,
+ },
+ { }
};
MODULE_DEVICE_TABLE (pci, epic_pci_tbl);
diff --git a/drivers/net/ethernet/sun/cassini.c b/drivers/net/ethernet/sun/cassini.c
index fe00e7dd3fe4..823870c999bf 100644
--- a/drivers/net/ethernet/sun/cassini.c
+++ b/drivers/net/ethernet/sun/cassini.c
@@ -218,11 +218,9 @@ static u16 link_modes[] = {
};
static const struct pci_device_id cas_pci_tbl[] = {
- { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_CASSINI,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SATURN,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { 0, }
+ { PCI_VDEVICE(SUN, PCI_DEVICE_ID_SUN_CASSINI) },
+ { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_SATURN) },
+ { }
};
MODULE_DEVICE_TABLE(pci, cas_pci_tbl);
diff --git a/drivers/net/ethernet/sun/sungem.c b/drivers/net/ethernet/sun/sungem.c
index 8e69d917d827..234ffc3c6a61 100644
--- a/drivers/net/ethernet/sun/sungem.c
+++ b/drivers/net/ethernet/sun/sungem.c
@@ -85,8 +85,7 @@ MODULE_LICENSE("GPL");
#define GEM_MODULE_NAME "gem"
static const struct pci_device_id gem_pci_tbl[] = {
- { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_GEM,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
+ { PCI_VDEVICE(SUN, PCI_DEVICE_ID_SUN_GEM) },
/* These models only differ from the original GEM in
* that their tx/rx fifos are of a different size and
@@ -95,21 +94,14 @@ static const struct pci_device_id gem_pci_tbl[] = {
* Apple's GMAC does support gigabit on machines with
* the BCM54xx PHYs. -BenH
*/
- { PCI_VENDOR_ID_SUN, PCI_DEVICE_ID_SUN_RIO_GEM,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMACP,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC2,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_K2_GMAC,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_SH_SUNGEM,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- { PCI_VENDOR_ID_APPLE, PCI_DEVICE_ID_APPLE_IPID2_GMAC,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0UL },
- {0, }
+ { PCI_VDEVICE(SUN, PCI_DEVICE_ID_SUN_RIO_GEM) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMACP) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_UNI_N_GMAC2) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_K2_GMAC) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_SH_SUNGEM) },
+ { PCI_VDEVICE(APPLE, PCI_DEVICE_ID_APPLE_IPID2_GMAC) },
+ { }
};
MODULE_DEVICE_TABLE(pci, gem_pci_tbl);
diff --git a/drivers/net/ethernet/ti/tlan.c b/drivers/net/ethernet/ti/tlan.c
index a55b0f951181..274a1837025c 100644
--- a/drivers/net/ethernet/ti/tlan.c
+++ b/drivers/net/ethernet/ti/tlan.c
@@ -119,33 +119,20 @@ static struct board {
};
static const struct pci_device_id tlan_pci_tbl[] = {
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
- { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2183,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
- { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2325,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
- { PCI_VENDOR_ID_OLICOM, PCI_DEVICE_ID_OLICOM_OC2326,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
- { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2,
- PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
- { 0,}
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL10), .driver_data = 0 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100), .driver_data = 1 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3I), .driver_data = 2 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_THUNDER), .driver_data = 3 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETFLEX3B), .driver_data = 4 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100PI), .driver_data = 5 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100D), .driver_data = 6 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_NETEL100I), .driver_data = 7 },
+ { PCI_VDEVICE(OLICOM, PCI_DEVICE_ID_OLICOM_OC2183), .driver_data = 8 },
+ { PCI_VDEVICE(OLICOM, PCI_DEVICE_ID_OLICOM_OC2325), .driver_data = 9 },
+ { PCI_VDEVICE(OLICOM, PCI_DEVICE_ID_OLICOM_OC2326), .driver_data = 10 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_100_WS_5100), .driver_data = 11 },
+ { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_NETELLIGENT_10_T2), .driver_data = 12 },
+ { }
};
MODULE_DEVICE_TABLE(pci, tlan_pci_tbl);
diff --git a/drivers/net/ethernet/wangxun/ngbe/ngbe_main.c b/drivers/net/ethernet/wangxun/ngbe/ngbe_main.c
index d8e3827a8b1f..d51d8db95a76 100644
--- a/drivers/net/ethernet/wangxun/ngbe/ngbe_main.c
+++ b/drivers/net/ethernet/wangxun/ngbe/ngbe_main.c
@@ -30,20 +30,20 @@ char ngbe_driver_name[] = "ngbe";
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id ngbe_pci_tbl[] = {
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL_W), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A2), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A2S), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A4), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A4S), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL2), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL2S), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL4), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL4S), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860LC), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A1), 0},
- { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A1L), 0},
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL_W) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A2) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A2S) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A4) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A4S) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL2) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL2S) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL4) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860AL4S) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860LC) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A1) },
+ { PCI_VDEVICE(WANGXUN, NGBE_DEV_ID_EM_WX1860A1L) },
/* required last entry */
- { .device = 0 }
+ { }
};
/**
diff --git a/drivers/net/ethernet/wangxun/ngbevf/ngbevf_main.c b/drivers/net/ethernet/wangxun/ngbevf/ngbevf_main.c
index 6ef43adcc425..d79cf8d8484f 100644
--- a/drivers/net/ethernet/wangxun/ngbevf/ngbevf_main.c
+++ b/drivers/net/ethernet/wangxun/ngbevf/ngbevf_main.c
@@ -26,20 +26,20 @@
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id ngbevf_pci_tbl[] = {
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL_W), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A2), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A2S), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A4), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A4S), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL2), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL2S), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL4), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL4S), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860NCSI), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A1), 0},
- { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL1), 0},
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL_W) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A2) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A2S) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A4) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A4S) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL2) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL2S) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL4) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL4S) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860NCSI) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860A1) },
+ { PCI_VDEVICE(WANGXUN, NGBEVF_DEV_ID_EM_WX1860AL1) },
/* required last entry */
- { .device = 0 }
+ { }
};
static const struct net_device_ops ngbevf_netdev_ops = {
diff --git a/drivers/net/ethernet/wangxun/txgbe/txgbe_main.c b/drivers/net/ethernet/wangxun/txgbe/txgbe_main.c
index 8b7c3753bb6a..4c549c2644ab 100644
--- a/drivers/net/ethernet/wangxun/txgbe/txgbe_main.c
+++ b/drivers/net/ethernet/wangxun/txgbe/txgbe_main.c
@@ -37,16 +37,16 @@ char txgbe_driver_name[] = "txgbe";
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id txgbe_pci_tbl[] = {
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_SP1000), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_WX1820), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5010), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5110), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5025), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5125), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5040), 0},
- { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5140), 0},
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_SP1000) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_WX1820) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5010) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5110) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5025) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5125) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5040) },
+ { PCI_VDEVICE(WANGXUN, TXGBE_DEV_ID_AML5140) },
/* required last entry */
- { .device = 0 }
+ { }
};
#define DEFAULT_DEBUG_LEVEL_SHIFT 3
diff --git a/drivers/net/ethernet/wangxun/txgbevf/txgbevf_main.c b/drivers/net/ethernet/wangxun/txgbevf/txgbevf_main.c
index 37e4ec487afd..8b16b900820a 100644
--- a/drivers/net/ethernet/wangxun/txgbevf/txgbevf_main.c
+++ b/drivers/net/ethernet/wangxun/txgbevf/txgbevf_main.c
@@ -26,16 +26,16 @@
* Class, Class Mask, private data (not used) }
*/
static const struct pci_device_id txgbevf_pci_tbl[] = {
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_SP1000), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_WX1820), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML500F), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML510F), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML5024), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML5124), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML503F), 0},
- { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML513F), 0},
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_SP1000) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_WX1820) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML500F) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML510F) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML5024) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML5124) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML503F) },
+ { PCI_VDEVICE(WANGXUN, TXGBEVF_DEV_ID_AML513F) },
/* required last entry */
- { .device = 0 }
+ { }
};
static const struct net_device_ops txgbevf_netdev_ops = {
diff --git a/drivers/net/wan/farsync.c b/drivers/net/wan/farsync.c
index 73f393900710..6508c53bdc24 100644
--- a/drivers/net/wan/farsync.c
+++ b/drivers/net/wan/farsync.c
@@ -524,27 +524,21 @@ do { \
/* PCI ID lookup table
*/
static const struct pci_device_id fst_pci_dev_id[] = {
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_T2P, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_T2P},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_T2P), .driver_data = FST_TYPE_T2P },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_T4P, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_T4P},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_T4P), .driver_data = FST_TYPE_T4P },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_T1U, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_T1U},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_T1U), .driver_data = FST_TYPE_T1U },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_T2U, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_T2U},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_T2U), .driver_data = FST_TYPE_T2U },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_T4U, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_T4U},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_T4U), .driver_data = FST_TYPE_T4U },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_TE1, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_TE1},
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_TE1), .driver_data = FST_TYPE_TE1 },
- {PCI_VENDOR_ID_FARSITE, PCI_DEVICE_ID_FARSITE_TE1C, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, FST_TYPE_TE1},
- {0,} /* End */
+ { PCI_VDEVICE(FARSITE, PCI_DEVICE_ID_FARSITE_TE1C), .driver_data = FST_TYPE_TE1 },
+
+ { } /* End */
};
MODULE_DEVICE_TABLE(pci, fst_pci_dev_id);
diff --git a/drivers/net/wan/pc300too.c b/drivers/net/wan/pc300too.c
index 7e57d289b62c..a91564e53caa 100644
--- a/drivers/net/wan/pc300too.c
+++ b/drivers/net/wan/pc300too.c
@@ -461,15 +461,11 @@ static int pc300_pci_init_one(struct pci_dev *pdev,
}
static const struct pci_device_id pc300_pci_tbl[] = {
- { PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_PC300_RX_1, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_PC300_RX_2, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_PC300_TE_1, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_PC300_TE_2, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { 0, }
+ { PCI_VDEVICE(CYCLADES, PCI_DEVICE_ID_PC300_RX_1) },
+ { PCI_VDEVICE(CYCLADES, PCI_DEVICE_ID_PC300_RX_2) },
+ { PCI_VDEVICE(CYCLADES, PCI_DEVICE_ID_PC300_TE_1) },
+ { PCI_VDEVICE(CYCLADES, PCI_DEVICE_ID_PC300_TE_2) },
+ { }
};
static struct pci_driver pc300_pci_driver = {
diff --git a/drivers/net/wan/pci200syn.c b/drivers/net/wan/pci200syn.c
index 89f4b4584a33..9503130fd9a8 100644
--- a/drivers/net/wan/pci200syn.c
+++ b/drivers/net/wan/pci200syn.c
@@ -397,9 +397,9 @@ static int pci200_pci_init_one(struct pci_dev *pdev,
}
static const struct pci_device_id pci200_pci_tbl[] = {
- { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_PLX,
- PCI_DEVICE_ID_PLX_PCI200SYN, 0, 0, 0 },
- { 0, }
+ { PCI_VDEVICE_SUB(PLX, PCI_DEVICE_ID_PLX_9050,
+ PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_PCI200SYN) },
+ { }
};
static struct pci_driver pci200_pci_driver = {
diff --git a/drivers/net/wan/wanxl.c b/drivers/net/wan/wanxl.c
index 3f7707118450..d4da88c77112 100644
--- a/drivers/net/wan/wanxl.c
+++ b/drivers/net/wan/wanxl.c
@@ -806,13 +806,10 @@ static int wanxl_pci_init_one(struct pci_dev *pdev,
}
static const struct pci_device_id wanxl_pci_tbl[] = {
- { PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_SBE_WANXL100, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_SBE_WANXL200, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { PCI_VENDOR_ID_SBE, PCI_DEVICE_ID_SBE_WANXL400, PCI_ANY_ID,
- PCI_ANY_ID, 0, 0, 0 },
- { 0, }
+ { PCI_VDEVICE(SBE, PCI_DEVICE_ID_SBE_WANXL100) },
+ { PCI_VDEVICE(SBE, PCI_DEVICE_ID_SBE_WANXL200) },
+ { PCI_VDEVICE(SBE, PCI_DEVICE_ID_SBE_WANXL400) },
+ { }
};
static struct pci_driver wanxl_pci_driver = {
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
index 45b342ea0637..13662aa4b4ea 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
@@ -2708,17 +2708,18 @@ static const struct dev_pm_ops brcmf_pciedrvr_pm = {
#define BRCMF_PCIE_DEVICE(dev_id, fw_vend) \
{ \
- BRCM_PCIE_VENDOR_ID_BROADCOM, (dev_id), \
- PCI_ANY_ID, PCI_ANY_ID, \
- PCI_CLASS_NETWORK_OTHER << 8, 0xffff00, \
- BRCMF_DRVDATA_ ## fw_vend \
+ PCI_DEVICE(BRCM_PCIE_VENDOR_ID_BROADCOM, (dev_id)), \
+ .class = PCI_CLASS_NETWORK_OTHER << 8, \
+ .class_mask = 0xffff00, \
+ .driver_data = BRCMF_DRVDATA_ ## fw_vend, \
}
#define BRCMF_PCIE_DEVICE_SUB(dev_id, subvend, subdev, fw_vend) \
{ \
- BRCM_PCIE_VENDOR_ID_BROADCOM, (dev_id), \
- (subvend), (subdev), \
- PCI_CLASS_NETWORK_OTHER << 8, 0xffff00, \
- BRCMF_DRVDATA_ ## fw_vend \
+ PCI_DEVICE_SUB(BRCM_PCIE_VENDOR_ID_BROADCOM, (dev_id), \
+ (subvend), (subdev)), \
+ .class = PCI_CLASS_NETWORK_OTHER << 8, \
+ .class_mask = 0xffff00, \
+ .driver_data = BRCMF_DRVDATA_ ## fw_vend, \
}
static const struct pci_device_id brcmf_pcie_devid_table[] = {
diff --git a/drivers/net/wireless/intel/ipw2x00/ipw2200.c b/drivers/net/wireless/intel/ipw2x00/ipw2200.c
index dd64d21174e3..4bc9bb406e8e 100644
--- a/drivers/net/wireless/intel/ipw2x00/ipw2200.c
+++ b/drivers/net/wireless/intel/ipw2x00/ipw2200.c
@@ -11366,37 +11366,41 @@ static int ipw_wdev_init(struct net_device *dev)
/* PCI driver stuff */
static const struct pci_device_id card_ids[] = {
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
- {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2701) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2702) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2711) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2712) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2721) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2722) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2731) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2732) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2741) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x103c, 0x2741) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2742) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2751) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2752) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2753) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2754) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2761) },
+ { PCI_VDEVICE_SUB(INTEL, 0x1043, 0x8086, 0x2762) },
+
/*
* This ID conflicts with i40e, but the devices can be differentiated
* because i40e devices use PCI_CLASS_NETWORK_ETHERNET and ipw2200
* devices use PCI_CLASS_NETWORK_OTHER.
*/
- {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x104f),
- PCI_CLASS_NETWORK_OTHER << 8, 0xffff00, 0},
- {PCI_VDEVICE(INTEL, 0x4220), 0}, /* BG */
- {PCI_VDEVICE(INTEL, 0x4221), 0}, /* BG */
- {PCI_VDEVICE(INTEL, 0x4223), 0}, /* ABG */
- {PCI_VDEVICE(INTEL, 0x4224), 0}, /* ABG */
+ {
+ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x104f),
+ .class = PCI_CLASS_NETWORK_OTHER << 8,
+ .class_mask = 0xffff00,
+ },
+ { PCI_VDEVICE(INTEL, 0x4220) }, /* BG */
+ { PCI_VDEVICE(INTEL, 0x4221) }, /* BG */
+ { PCI_VDEVICE(INTEL, 0x4223) }, /* ABG */
+ { PCI_VDEVICE(INTEL, 0x4224) }, /* ABG */
/* required last entry */
- {0,}
+ { }
};
MODULE_DEVICE_TABLE(pci, card_ids);
base-commit: 254f49634ee16a731174d2ae34bc50bd5f45e731
--
2.47.3
^ permalink raw reply related
* Re: [PATCH] iw: Makefile: support out-of-tree builds
From: Johannes Berg @ 2026-04-28 17:18 UTC (permalink / raw)
To: Maxin John; +Cc: linux-wireless
In-Reply-To: <afDqaQc-Vxoz3OEL@Thor.home>
On Tue, 2026-04-28 at 20:12 +0300, Maxin John wrote:
>
> > > +CPPFLAGS += -I.
> >
> > The "-I." seems questionable since you evidently intend to have "."
> > *not* be the source dir?
>
> The -I. was intended to ensure that generated files such as
> nl80211-commands.inc, which are produced in the build directory,
> remain discoverable by the compiler. Agree that it doesn't look right
> and I will update it.
Oh, I guess that makes sense, maybe just add a comment? But that's after
guessing you somehow intend to call 'make -f ../src/Makefile' or
something, which seems a little odd to me?
johannes
^ permalink raw reply
* Re: [PATCH] iw: Makefile: support out-of-tree builds
From: Maxin John @ 2026-04-28 17:12 UTC (permalink / raw)
To: Johannes Berg; +Cc: linux-wireless
In-Reply-To: <1672e78507b643f4610265f018ccddcb141ee726.camel@sipsolutions.net>
Hi Johannes,
Thanks for the review comments.
On Mon, Apr 27, 2026 at 11:43:54AM +0200, Johannes Berg wrote:
> On Thu, 2026-04-23 at 14:31 +0300, Maxin John wrote:
> > Enable out-of-tree builds without modifying the source tree.
> > Out-of-tree builds are required by build frameworks such as OpenEmbedded.
>
> You should probably say how this is intended to be used, clearly not in
> the O= way that the kernel has, for example.
I will clarify the intended usage in the next iteration.
> > +SRCDIR := $(dir $(lastword $(MAKEFILE_LIST)))
>
> That doesn't work if there's whitespace anywhere along the path.
>
> > +CPPFLAGS += -I$(SRCDIR)
> > +CPPFLAGS += -I.
>
> The "-I." seems questionable since you evidently intend to have "."
> *not* be the source dir?
The -I. was intended to ensure that generated files such as
nl80211-commands.inc, which are produced in the build directory,
remain discoverable by the compiler. Agree that it doesn't look right
and I will update it.
>
> Overall it might be simpler to actually do it with the kernel-style O=
> so you just need to change all the outputs, rather than all the inputs?
Got it. I will update it as per your comments and send a v2.
>
> johannes
Best Regards,
Maxin
^ permalink raw reply
* Re: [PATCH v4 12/15] net: ipa: Switch to generic PAS TZ APIs
From: Alex Elder @ 2026-04-28 16:54 UTC (permalink / raw)
To: Sumit Garg, andersson, konradybcio
Cc: linux-arm-msm, devicetree, dri-devel, freedreno, linux-media,
netdev, linux-wireless, ath12k, linux-remoteproc, robh, krzk+dt,
conor+dt, robin.clark, sean, akhilpo, lumag, abhinav.kumar,
jesszhan0024, marijn.suijten, airlied, simona, vikash.garodia,
dikshita.agarwal, bod, mchehab, elder, andrew+netdev, davem,
edumazet, kuba, pabeni, jjohnson, mathieu.poirier,
trilokkumar.soni, mukesh.ojha, pavan.kondeti, jorge.ramirez,
tonyh, vignesh.viswanathan, srinivas.kandagatla, amirreza.zarrabi,
jens.wiklander, op-tee, apurupa, skare, linux-kernel, Sumit Garg
In-Reply-To: <20260427095603.1157963-13-sumit.garg@kernel.org>
On 4/27/26 4:56 AM, Sumit Garg wrote:
> From: Sumit Garg <sumit.garg@oss.qualcomm.com>
>
> Switch ipa client driver over to generic PAS TZ APIs. Generic PAS TZ
> service allows to support multiple TZ implementation backends like QTEE
> based SCM PAS service, OP-TEE based PAS service and any further future TZ
> backend service.
>
> Signed-off-by: Sumit Garg <sumit.garg@oss.qualcomm.com>
Looks good to me.
Reviewed-by: Alex Elder <elder@riscstar.com>
> ---
> drivers/net/ipa/Kconfig | 2 +-
> drivers/net/ipa/ipa_main.c | 13 ++++++++-----
> 2 files changed, 9 insertions(+), 6 deletions(-)
>
> diff --git a/drivers/net/ipa/Kconfig b/drivers/net/ipa/Kconfig
> index 01d219d3760c..a9aff1b7977d 100644
> --- a/drivers/net/ipa/Kconfig
> +++ b/drivers/net/ipa/Kconfig
> @@ -6,7 +6,7 @@ config QCOM_IPA
> depends on QCOM_RPROC_COMMON || (QCOM_RPROC_COMMON=n && COMPILE_TEST)
> depends on QCOM_AOSS_QMP || QCOM_AOSS_QMP=n
> select QCOM_MDT_LOADER
> - select QCOM_SCM
> + select QCOM_PAS
> select QCOM_QMI_HELPERS
> help
> Choose Y or M here to include support for the Qualcomm
> diff --git a/drivers/net/ipa/ipa_main.c b/drivers/net/ipa/ipa_main.c
> index 788dd99af2a4..3cd9e44680e9 100644
> --- a/drivers/net/ipa/ipa_main.c
> +++ b/drivers/net/ipa/ipa_main.c
> @@ -14,7 +14,7 @@
> #include <linux/pm_runtime.h>
> #include <linux/types.h>
>
> -#include <linux/firmware/qcom/qcom_scm.h>
> +#include <linux/firmware/qcom/qcom_pas.h>
> #include <linux/soc/qcom/mdt_loader.h>
>
> #include "ipa.h"
> @@ -624,10 +624,13 @@ static int ipa_firmware_load(struct device *dev)
> }
>
> ret = qcom_mdt_load(dev, fw, path, IPA_PAS_ID, virt, phys, size, NULL);
> - if (ret)
> + if (ret) {
> dev_err(dev, "error %d loading \"%s\"\n", ret, path);
> - else if ((ret = qcom_scm_pas_auth_and_reset(IPA_PAS_ID)))
> - dev_err(dev, "error %d authenticating \"%s\"\n", ret, path);
> + } else {
> + ret = qcom_pas_auth_and_reset(IPA_PAS_ID);
> + if (ret)
> + dev_err(dev, "error %d authenticating \"%s\"\n", ret, path);
> + }
>
> memunmap(virt);
> out_release_firmware:
> @@ -758,7 +761,7 @@ static enum ipa_firmware_loader ipa_firmware_loader(struct device *dev)
> return IPA_LOADER_INVALID;
> out_self:
> /* We need Trust Zone to load firmware; make sure it's available */
> - if (qcom_scm_is_available())
> + if (qcom_pas_is_available())
> return IPA_LOADER_SELF;
>
> return IPA_LOADER_DEFER;
^ permalink raw reply
* Re: [PATCH v2 1/4] net: ipa: Use the unified QMI service ID instead of defining it locally
From: Alex Elder @ 2026-04-28 16:47 UTC (permalink / raw)
To: Daniel Lezcano, konradybcio, andersson
Cc: linux-kernel, Alex Elder, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Jeff Johnson,
Mathieu Poirier, Srinivas Kandagatla, Jaroslav Kysela,
Takashi Iwai, Kees Cook, Greg Kroah-Hartman, Arnd Bergmann,
Mark Brown, Wesley Cheng, netdev, linux-wireless, ath10k, ath11k,
ath12k, linux-arm-msm, linux-remoteproc, linux-sound,
Dmitry Baryshkov
In-Reply-To: <20260316171419.2619620-2-daniel.lezcano@oss.qualcomm.com>
On 3/16/26 12:14 PM, Daniel Lezcano wrote:
> Instead of defining a local macro with a custom name for the QMI
> service identifier, use the one provided in qmi.h and remove the
> locally defined macro.
>
> Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
> Signed-off-by: Daniel Lezcano <daniel.lezcano@oss.qualcomm.com>
Looks good!
Reviewed-by: Alex Elder <elder@riscstar.com>
> ---
> drivers/net/ipa/ipa_qmi.c | 6 ++----
> 1 file changed, 2 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/net/ipa/ipa_qmi.c b/drivers/net/ipa/ipa_qmi.c
> index d771f3a71f94..37936ad132a2 100644
> --- a/drivers/net/ipa/ipa_qmi.c
> +++ b/drivers/net/ipa/ipa_qmi.c
> @@ -66,11 +66,9 @@
> * determination of when things are "ready"
> */
>
> -#define IPA_HOST_SERVICE_SVC_ID 0x31
> #define IPA_HOST_SVC_VERS 1
> #define IPA_HOST_SERVICE_INS_ID 1
>
> -#define IPA_MODEM_SERVICE_SVC_ID 0x31
> #define IPA_MODEM_SERVICE_INS_ID 2
> #define IPA_MODEM_SVC_VERS 1
>
> @@ -484,7 +482,7 @@ int ipa_qmi_setup(struct ipa *ipa)
> if (ret)
> return ret;
>
> - ret = qmi_add_server(&ipa_qmi->server_handle, IPA_HOST_SERVICE_SVC_ID,
> + ret = qmi_add_server(&ipa_qmi->server_handle, QMI_SERVICE_ID_IPA,
> IPA_HOST_SVC_VERS, IPA_HOST_SERVICE_INS_ID);
> if (ret)
> goto err_server_handle_release;
> @@ -501,7 +499,7 @@ int ipa_qmi_setup(struct ipa *ipa)
> /* We need this ready before the service lookup is added */
> INIT_WORK(&ipa_qmi->init_driver_work, ipa_client_init_driver_work);
>
> - ret = qmi_add_lookup(&ipa_qmi->client_handle, IPA_MODEM_SERVICE_SVC_ID,
> + ret = qmi_add_lookup(&ipa_qmi->client_handle, QMI_SERVICE_ID_IPA,
> IPA_MODEM_SVC_VERS, IPA_MODEM_SERVICE_INS_ID);
> if (ret)
> goto err_client_handle_release;
^ permalink raw reply
* Re: [PATCH v2 2/4] wifi: ath: Use the unified QMI service ID instead of defining it locally
From: Jeff Johnson @ 2026-04-28 16:39 UTC (permalink / raw)
To: Daniel Lezcano, konradybcio, andersson
Cc: linux-kernel, Alex Elder, Andrew Lunn, David S. Miller,
Eric Dumazet, Jakub Kicinski, Paolo Abeni, Jeff Johnson,
Mathieu Poirier, Srinivas Kandagatla, Jaroslav Kysela,
Takashi Iwai, Kees Cook, Greg Kroah-Hartman, Arnd Bergmann,
Mark Brown, Wesley Cheng, netdev, linux-wireless, ath10k, ath11k,
ath12k, linux-arm-msm, linux-remoteproc, linux-sound,
Dmitry Baryshkov
In-Reply-To: <51e28a7f-8362-4bf1-9b9a-9af9cda1d748@oss.qualcomm.com>
On 3/19/2026 7:26 AM, Jeff Johnson wrote:
> On 3/16/2026 10:14 AM, Daniel Lezcano wrote:
>> Instead of defining a local macro with a custom name for the QMI
>> service identifier, use the one provided in qmi.h and remove the
>> locally defined macro.
>>
>> Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
>> Signed-off-by: Daniel Lezcano <daniel.lezcano@oss.qualcomm.com>
>
> Bjorn,
> Feel free to take this through your tree since I don't think it will conflict
> with anything in mine and it will take time for the definition to propagate
> back to my tree via the normal workflow (which I would prefer over merging the
> immutable branch).
>
> Acked-by: Jeff Johnson <jeff.johnson@oss.qualcomm.com>
Now NAK...
The definitions have now propagated back to my tree, so I'll now take this
patch through my tree.
/jeff
^ permalink raw reply
* [PATCH] wifi: ath10k: drop gpio_led reference
From: Arnd Bergmann @ 2026-04-28 16:29 UTC (permalink / raw)
To: Jeff Johnson
Cc: Arnd Bergmann, Kang Yang, Loic Poulain, Baochen Qiang,
Sumanth Gavini, linux-wireless, ath10k, linux-kernel
From: Arnd Bergmann <arnd@arndb.de>
The driver uses a 'struct gpio_led' internally, but does not actually interact
with the gpio_led driver, in particular it does not actually use gpiolib here.
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
---
drivers/net/wireless/ath/ath10k/core.h | 1 -
drivers/net/wireless/ath/ath10k/leds.c | 8 +-------
2 files changed, 1 insertion(+), 8 deletions(-)
diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h
index 73a9db302245..dfee432615eb 100644
--- a/drivers/net/wireless/ath/ath10k/core.h
+++ b/drivers/net/wireless/ath/ath10k/core.h
@@ -1269,7 +1269,6 @@ struct ath10k {
} testmode;
struct {
- struct gpio_led wifi_led;
struct led_classdev cdev;
char label[48];
u32 gpio_state_pin;
diff --git a/drivers/net/wireless/ath/ath10k/leds.c b/drivers/net/wireless/ath/ath10k/leds.c
index 3a6c8111e7c6..a3961e7760a5 100644
--- a/drivers/net/wireless/ath/ath10k/leds.c
+++ b/drivers/net/wireless/ath/ath10k/leds.c
@@ -19,15 +19,13 @@ static int ath10k_leds_set_brightness_blocking(struct led_classdev *led_cdev,
{
struct ath10k *ar = container_of(led_cdev, struct ath10k,
leds.cdev);
- struct gpio_led *led = &ar->leds.wifi_led;
mutex_lock(&ar->conf_mutex);
if (ar->state != ATH10K_STATE_ON)
goto out;
- ar->leds.gpio_state_pin = (brightness != LED_OFF) ^ led->active_low;
- ath10k_wmi_gpio_output(ar, ar->hw_params.led_pin, ar->leds.gpio_state_pin);
+ ath10k_wmi_gpio_output(ar, ar->hw_params.led_pin, brightness == LED_OFF);
out:
mutex_unlock(&ar->conf_mutex);
@@ -63,13 +61,9 @@ int ath10k_leds_register(struct ath10k *ar)
snprintf(ar->leds.label, sizeof(ar->leds.label), "ath10k-%s",
wiphy_name(ar->hw->wiphy));
- ar->leds.wifi_led.active_low = 1;
- ar->leds.wifi_led.name = ar->leds.label;
- ar->leds.wifi_led.default_state = LEDS_GPIO_DEFSTATE_KEEP;
ar->leds.cdev.name = ar->leds.label;
ar->leds.cdev.brightness_set_blocking = ath10k_leds_set_brightness_blocking;
- ar->leds.cdev.default_trigger = ar->leds.wifi_led.default_trigger;
ret = led_classdev_register(wiphy_dev(ar->hw->wiphy), &ar->leds.cdev);
if (ret)
--
2.39.5
^ permalink raw reply related
* RTL8922AE: Severe latency spikes (>200ms) during wifi scan triggers
From: Sivanantham Chinnaiyan @ 2026-04-28 14:28 UTC (permalink / raw)
To: linux-wireless
Severe latency spikes (200ms+) occur whenever a Wi-Fi scan is
triggered (e.g., clicking Wi-Fi menu in GUI). This happens
consistently on both 2.4 GHz and 5 GHz networks, though it is much
more evident in 2.4GHz channel. I know that latency spikes during
scans are normal. But I am not sure if 150+ms is considered normal.
Hardware:
Chipset: Realtek rtw89_8922ae
Device: Lenovo Ideapad pro 5
Firmware version: [from dmesg | grep firmware] 0.35.80.3 (8ef4f0cf)
Kernel: fedora 6.19.13-200.fc43.x86_64
Software Stack:
Network Manager: NetworkManager (iwd backend)
Distribution: Fedora
Configuration: default
Steps to Reproduce:
1. Connect to a Wi-Fi network (2.4 GHz or 5 GHz)
2. Start continuous ping:
3. ```ping 8.8.8.8```
4.Open Wi-Fi menu in GUI (triggers scan)
Behavior:
Latency spikes to 200ms+ periodically
Happens every time a scan is triggered
Additional Observations:
Issue reproducible 100% of the time
Logs:
1. sudo dmesg | grep rtw
[ 7.466016] rtw89_8922ae 0000:63:00.0: loaded firmware
rtw89/rtw8922a_fw-4.bin
[ 7.466182] rtw89_8922ae 0000:63:00.0: enabling device (0000 -> 0003)
[ 7.473628] rtw89_8922ae 0000:63:00.0: Firmware version 0.35.80.3
(8ef4f0cf), cmd version 1, type 1
[ 7.473635] rtw89_8922ae 0000:63:00.0: Firmware version 0.35.80.3
(8ef4f0cf), cmd version 1, type 3
[ 7.491846] rtw89_8922ae 0000:63:00.0: chip rfe_type is 1
[ 7.494234] rtw89_8922ae 0000:63:00.0: Firmware version 0.1.0.0
(7b393818), cmd version 0, type 64
[ 7.494239] rtw89_8922ae 0000:63:00.0: Firmware element BB version:
00 49 00 00
[ 7.494244] rtw89_8922ae 0000:63:00.0: Firmware element radio A
version: 00 33 00 00
[ 7.494252] rtw89_8922ae 0000:63:00.0: Firmware element NCTL
version: 00 0f 00 00
[ 7.494296] rtw89_8922ae 0000:63:00.0: Firmware element TXPWR
version: 00 46 00 00
[ 7.494297] rtw89_8922ae 0000:63:00.0: Firmware element TXPWR
version: 00 46 00 00
[ 7.494297] rtw89_8922ae 0000:63:00.0: Firmware element TXPWR
version: 00 46 00 00
[ 7.494307] rtw89_8922ae 0000:63:00.0: Firmware element PWR_TRK
version: 00 33 00 00
[ 7.494313] rtw89_8922ae 0000:63:00.0: Firmware element REGD
version: 00 49 00 08
[ 7.707799] rtw89_8922ae 0000:63:00.0: rfkill hardware state
changed to enable
[ 7.717083] rtw89_8922ae 0000:63:00.0 wlp99s0: renamed from wlan0
2. ping -i 0.2 8.8.8.8 while connected to 2.4GHz( scan simulated using
`watch --interval=3 nmcli dev wifi rescan`)
)
64 bytes from 8.8.8.8: icmp_seq=24 ttl=118 time=34.9 ms
64 bytes from 8.8.8.8: icmp_seq=25 ttl=118 time=44.2 ms
64 bytes from 8.8.8.8: icmp_seq=26 ttl=118 time=6.61 ms
64 bytes from 8.8.8.8: icmp_seq=27 ttl=118 time=4.51 ms
64 bytes from 8.8.8.8: icmp_seq=28 ttl=118 time=92.3 ms
64 bytes from 8.8.8.8: icmp_seq=29 ttl=118 time=82.8 ms
64 bytes from 8.8.8.8: icmp_seq=30 ttl=118 time=20.4 ms
64 bytes from 8.8.8.8: icmp_seq=31 ttl=118 time=306 ms
64 bytes from 8.8.8.8: icmp_seq=32 ttl=118 time=102 ms
64 bytes from 8.8.8.8: icmp_seq=33 ttl=118 time=59.3 ms
64 bytes from 8.8.8.8: icmp_seq=34 ttl=118 time=183 ms
64 bytes from 8.8.8.8: icmp_seq=35 ttl=118 time=10.5 ms
64 bytes from 8.8.8.8: icmp_seq=36 ttl=118 time=116 ms
64 bytes from 8.8.8.8: icmp_seq=38 ttl=118 time=112 ms
64 bytes from 8.8.8.8: icmp_seq=39 ttl=118 time=108 ms
64 bytes from 8.8.8.8: icmp_seq=40 ttl=118 time=231 ms
64 bytes from 8.8.8.8: icmp_seq=41 ttl=118 time=24.0 ms
64 bytes from 8.8.8.8: icmp_seq=42 ttl=118 time=28.2 ms
64 bytes from 8.8.8.8: icmp_seq=43 ttl=118 time=32.0 ms
64 bytes from 8.8.8.8: icmp_seq=44 ttl=118 time=140 ms
64 bytes from 8.8.8.8: icmp_seq=45 ttl=118 time=146 ms
64 bytes from 8.8.8.8: icmp_seq=46 ttl=118 time=47.6 ms
64 bytes from 8.8.8.8: icmp_seq=47 ttl=118 time=52.0 ms
64 bytes from 8.8.8.8: icmp_seq=48 ttl=118 time=57.1 ms
64 bytes from 8.8.8.8: icmp_seq=49 ttl=118 time=60.9 ms
64 bytes from 8.8.8.8: icmp_seq=50 ttl=118 time=67.0 ms
64 bytes from 8.8.8.8: icmp_seq=51 ttl=118 time=3.90 ms
64 bytes from 8.8.8.8: icmp_seq=52 ttl=118 time=20.3 ms
64 bytes from 8.8.8.8: icmp_seq=53 ttl=118 time=4.81 ms
64 bytes from 8.8.8.8: icmp_seq=54 ttl=118 time=87.0 ms
64 bytes from 8.8.8.8: icmp_seq=55 ttl=118 time=92.9 ms
64 bytes from 8.8.8.8: icmp_seq=56 ttl=118 time=200 ms
64 bytes from 8.8.8.8: icmp_seq=57 ttl=118 time=4.52 ms
64 bytes from 8.8.8.8: icmp_seq=58 ttl=118 time=5.47 ms
64 bytes from 8.8.8.8: icmp_seq=59 ttl=118 time=98.4 ms
64 bytes from 8.8.8.8: icmp_seq=61 ttl=118 time=120 ms
64 bytes from 8.8.8.8: icmp_seq=62 ttl=118 time=133 ms
64 bytes from 8.8.8.8: icmp_seq=63 ttl=118 time=128 ms
64 bytes from 8.8.8.8: icmp_seq=64 ttl=118 time=235 ms
64 bytes from 8.8.8.8: icmp_seq=65 ttl=118 time=30.6 ms
64 bytes from 8.8.8.8: icmp_seq=66 ttl=118 time=139 ms
64 bytes from 8.8.8.8: icmp_seq=67 ttl=118 time=245 ms
64 bytes from 8.8.8.8: icmp_seq=68 ttl=118 time=41.3 ms
64 bytes from 8.8.8.8: icmp_seq=69 ttl=118 time=138 ms
64 bytes from 8.8.8.8: icmp_seq=70 ttl=118 time=253 ms
64 bytes from 8.8.8.8: icmp_seq=71 ttl=118 time=47.8 ms
64 bytes from 8.8.8.8: icmp_seq=72 ttl=118 time=51.9 ms
64 bytes from 8.8.8.8: icmp_seq=73 ttl=118 time=56.8 ms
64 bytes from 8.8.8.8: icmp_seq=74 ttl=118 time=62.3 ms
64 bytes from 8.8.8.8: icmp_seq=75 ttl=118 time=67.8 ms
64 bytes from 8.8.8.8: icmp_seq=76 ttl=118 time=206 ms
64 bytes from 8.8.8.8: icmp_seq=77 ttl=118 time=4.67 ms
64 bytes from 8.8.8.8: icmp_seq=78 ttl=118 time=148 ms
64 bytes from 8.8.8.8: icmp_seq=79 ttl=118 time=207 ms
64 bytes from 8.8.8.8: icmp_seq=80 ttl=118 time=3.99 ms
64 bytes from 8.8.8.8: icmp_seq=81 ttl=118 time=4.59 ms
64 bytes from 8.8.8.8: icmp_seq=82 ttl=118 time=38.8 ms
64 bytes from 8.8.8.8: icmp_seq=83 ttl=118 time=4.59 ms
64 bytes from 8.8.8.8: icmp_seq=84 ttl=118 time=82.3 ms
64 bytes from 8.8.8.8: icmp_seq=85 ttl=118 time=105 ms
64 bytes from 8.8.8.8: icmp_seq=86 ttl=118 time=54.2 ms
64 bytes from 8.8.8.8: icmp_seq=87 ttl=118 time=15.2 ms
64 bytes from 8.8.8.8: icmp_seq=88 ttl=118 time=4.62 ms
64 bytes from 8.8.8.8: icmp_seq=89 ttl=118 time=104 ms
64 bytes from 8.8.8.8: icmp_seq=90 ttl=118 time=69.6 ms
64 bytes from 8.8.8.8: icmp_seq=91 ttl=118 time=28.3 ms
64 bytes from 8.8.8.8: icmp_seq=92 ttl=118 time=6.45 ms
64 bytes from 8.8.8.8: icmp_seq=93 ttl=118 time=113 ms
64 bytes from 8.8.8.8: icmp_seq=94 ttl=118 time=77.2 ms
64 bytes from 8.8.8.8: icmp_seq=95 ttl=118 time=38.4 ms
64 bytes from 8.8.8.8: icmp_seq=96 ttl=118 time=6.64 ms
64 bytes from 8.8.8.8: icmp_seq=97 ttl=118 time=120 ms
64 bytes from 8.8.8.8: icmp_seq=98 ttl=118 time=60.1 ms
64 bytes from 8.8.8.8: icmp_seq=99 ttl=118 time=155 ms
64 bytes from 8.8.8.8: icmp_seq=100 ttl=118 time=107 ms
64 bytes from 8.8.8.8: icmp_seq=101 ttl=118 time=56.9 ms
64 bytes from 8.8.8.8: icmp_seq=102 ttl=118 time=14.3 ms
64 bytes from 8.8.8.8: icmp_seq=103 ttl=118 time=5.59 ms
64 bytes from 8.8.8.8: icmp_seq=104 ttl=118 time=4.53 ms
64 bytes from 8.8.8.8: icmp_seq=105 ttl=118 time=117 ms
64 bytes from 8.8.8.8: icmp_seq=106 ttl=118 time=4.51 ms
64 bytes from 8.8.8.8: icmp_seq=107 ttl=118 time=4.54 ms
64 bytes from 8.8.8.8: icmp_seq=108 ttl=118 time=150 ms
64 bytes from 8.8.8.8: icmp_seq=109 ttl=118 time=5.36 ms
64 bytes from 8.8.8.8: icmp_seq=110 ttl=118 time=10.1 ms
64 bytes from 8.8.8.8: icmp_seq=111 ttl=118 time=32.2 ms
64 bytes from 8.8.8.8: icmp_seq=112 ttl=118 time=70.1 ms
64 bytes from 8.8.8.8: icmp_seq=113 ttl=118 time=23.4 ms
64 bytes from 8.8.8.8: icmp_seq=114 ttl=118 time=4.57 ms
64 bytes from 8.8.8.8: icmp_seq=115 ttl=118 time=122 ms
64 bytes from 8.8.8.8: icmp_seq=116 ttl=118 time=84.8 ms
64 bytes from 8.8.8.8: icmp_seq=117 ttl=118 time=45.8 ms
64 bytes from 8.8.8.8: icmp_seq=118 ttl=118 time=7.48 ms
64 bytes from 8.8.8.8: icmp_seq=119 ttl=118 time=4.42 ms
^C
--- 8.8.8.8 ping statistics ---
119 packets transmitted, 116 received, 2.52101% packet loss, time 23754ms
rtt min/avg/max/mdev = 3.624/70.204/305.533/64.207 ms, pipe 2
^ permalink raw reply
* Re: [PATCH] wifi: mac80211: drop stray 'static' from fast-RX rx_result
From: Jeff Johnson @ 2026-04-28 14:23 UTC (permalink / raw)
To: Catherine, linux-wireless, Felix Fietkau; +Cc: johannes, linux-kernel, stable
In-Reply-To: <20260424131435.83212-2-enderaoelyther@gmail.com>
On 4/24/2026 6:14 AM, Catherine wrote:
> ieee80211_invoke_fast_rx() is documented as safe for parallel RX, but
> its per-invocation rx_result is declared static. Concurrent callers then
> share one instance and can overwrite each other's result between
> ieee80211_rx_mesh_data() and the switch on res.
>
> That can make a packet that was queued or consumed by
> ieee80211_rx_mesh_data() fall through into ieee80211_rx_8023(), or make
> a packet that should continue return as queued.
>
> Make res an automatic variable so each invocation keeps its own result.
>
> Fixes: 3468e1e0c639 ("wifi: mac80211: add mesh fast-rx support")
@Felix: Any recollection why this was static in your original patch?
> Cc: stable@vger.kernel.org
> Signed-off-by: Catherine <enderaoelyther@gmail.com>
Is this an identity you commonly use? Note that anonymous contributions are
not allowed:
https://www.kernel.org/doc/html/latest/process/submitting-patches.html#developer-s-certificate-of-origin-1-1
> ---
> net/mac80211/rx.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
> index 3e5d1c47a..8719db8f3 100644
> --- a/net/mac80211/rx.c
> +++ b/net/mac80211/rx.c
> @@ -4971,7 +4971,7 @@ static bool ieee80211_invoke_fast_rx(struct ieee80211_rx_data *rx,
> struct sk_buff *skb = rx->skb;
> struct ieee80211_hdr *hdr = (void *)skb->data;
> struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
> - static ieee80211_rx_result res;
> + ieee80211_rx_result res;
> int orig_len = skb->len;
> int hdrlen = ieee80211_hdrlen(hdr->frame_control);
> int snap_offs = hdrlen;
Actual patch seem reasonable..
Reviewed-by: Jeff Johnson <jeff.johnson@oss.qualcomm.com>
^ permalink raw reply
* [PATCH 8/9] Bluetooth: qca: Set NVMEM BD address quirks when address is invalid
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
When the controller BD address is invalid (zero or default),
set the NVMEM quirks to allow retrieving the address from a
'local-bd-address' NVMEM cell. The BD address is often stored
alongside the WiFi MAC address in big-endian format, so also
set the big-endian quirk.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
drivers/bluetooth/btqca.c | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/drivers/bluetooth/btqca.c b/drivers/bluetooth/btqca.c
index dda76365726f0bfe0e80e05fe04859fa4f0592e1..df33eacfd29fa680f393f90215150743e6001d5b 100644
--- a/drivers/bluetooth/btqca.c
+++ b/drivers/bluetooth/btqca.c
@@ -721,8 +721,11 @@ static int qca_check_bdaddr(struct hci_dev *hdev, const struct qca_fw_config *co
}
bda = (struct hci_rp_read_bd_addr *)skb->data;
- if (!bacmp(&bda->bdaddr, &config->bdaddr))
+ if (!bacmp(&bda->bdaddr, &config->bdaddr)) {
hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
+ hci_set_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM);
+ hci_set_quirk(hdev, HCI_QUIRK_BDADDR_NVMEM_BE);
+ }
kfree_skb(skb);
--
2.34.1
^ permalink raw reply related
* [PATCH 9/9] arm64: dts: qcom: arduino-imola: Get Bluetooth BD address from NVMEM
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
On Arduino Uno-Q, the Bluetooth Device address is stored in the eMMC
boot1 partition. Point to the appropriate NVMEM cell to retrieve it.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts | 3 +++
1 file changed, 3 insertions(+)
diff --git a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
index 35a30cd6f47d6d2e018f6841a05fe929fec15738..109fa76e05625461935e321e15dbfe6c7d452e78 100644
--- a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
+++ b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
@@ -536,6 +536,9 @@ bluetooth {
vddch0-supply = <&pm4125_l22>;
enable-gpios = <&tlmm 87 GPIO_ACTIVE_HIGH>;
max-speed = <3000000>;
+
+ nvmem-cells = <&bd_addr>;
+ nvmem-cell-names = "local-bd-address";
};
};
--
2.34.1
^ permalink raw reply related
* [PATCH 7/9] Bluetooth: hci_sync: Add NVMEM-backed BD address retrieval
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
Some devices store the Bluetooth BD address in non-volatile
memory, which can be accessed through the NVMEM framework.
Similar to Ethernet or WiFi MAC addresses, add support for
reading the BD address from a 'local-bd-address' NVMEM cell.
As with the device-tree provided BD address, add a quirk to
indicate whether a device or platform should attempt to read
the address from NVMEM when no valid in-chip address is present.
Also add a quirk to indicate if the address is stored in
big-endian byte order.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
include/net/bluetooth/hci.h | 18 +++++++++++++++
net/bluetooth/hci_sync.c | 56 ++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 73 insertions(+), 1 deletion(-)
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index 572b1c620c5d653a1fe10b26c1b0ba33e8f4968f..7686466d1109253b0d75edeb5f6a99fb98ce4cc6 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -164,6 +164,24 @@ enum {
*/
HCI_QUIRK_BDADDR_PROPERTY_BROKEN,
+ /* When this quirk is set, the public Bluetooth address
+ * initially reported by HCI Read BD Address command
+ * is considered invalid. The public BD Address can be
+ * retrieved via a 'local-bd-address' NVMEM cell.
+ *
+ * This quirk can be set before hci_register_dev is called or
+ * during the hdev->setup vendor callback.
+ */
+ HCI_QUIRK_USE_BDADDR_NVMEM,
+
+ /* When this quirk is set, the Bluetooth Device Address provided by
+ * the 'local-bd-address' NVMEM is stored in big-endian order.
+ *
+ * This quirk can be set before hci_register_dev is called or
+ * during the hdev->setup vendor callback.
+ */
+ HCI_QUIRK_BDADDR_NVMEM_BE,
+
/* When this quirk is set, the duplicate filtering during
* scanning is based on Bluetooth devices addresses. To allow
* RSSI based updates, restart scanning if needed.
diff --git a/net/bluetooth/hci_sync.c b/net/bluetooth/hci_sync.c
index fd3aacdea512a37c22b9a2be90c89ddca4b4d99f..f87cb6ae85c3a5754fe79f415ba05dd177f75fad 100644
--- a/net/bluetooth/hci_sync.c
+++ b/net/bluetooth/hci_sync.c
@@ -6,6 +6,7 @@
* Copyright 2023 NXP
*/
+#include <linux/nvmem-consumer.h>
#include <linux/property.h>
#include <net/bluetooth/bluetooth.h>
@@ -3588,6 +3589,54 @@ int hci_powered_update_sync(struct hci_dev *hdev)
return 0;
}
+/**
+ * hci_dev_get_bd_addr_from_nvmem - Get the Bluetooth Device Address
+ * (BD_ADDR) for a HCI device from
+ * an NVMEM cell.
+ * @hdev: The HCI device
+ *
+ * Search for 'local-bd-address' NVMEM cell.
+ *
+ * All-zero BD addresses are rejected (unprovisioned).
+ */
+static int hci_dev_get_bd_addr_from_nvmem(struct hci_dev *hdev)
+{
+ struct device *dev = hdev->dev.parent;
+ struct nvmem_cell *cell;
+ const void *ba;
+ int err = 0;
+ size_t len;
+
+ cell = nvmem_cell_get(dev, "local-bd-address");
+ if (IS_ERR(cell))
+ return PTR_ERR(cell);
+
+ ba = nvmem_cell_read(cell, &len);
+ nvmem_cell_put(cell);
+
+ if (IS_ERR(ba)) {
+ bt_dev_warn(hdev, "Error reading BD address from NVMEM (%ld)\n",
+ PTR_ERR(ba));
+ err = PTR_ERR(ba);
+ goto done;
+ }
+
+ if (len != sizeof(bdaddr_t) || !bacmp(ba, BDADDR_ANY)) {
+ bt_dev_warn(hdev, "NVMEM BD address has incorrect format\n");
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (hci_test_quirk(hdev, HCI_QUIRK_BDADDR_NVMEM_BE))
+ baswap(&hdev->public_addr, (bdaddr_t *)ba);
+ else
+ bacpy(&hdev->public_addr, (bdaddr_t *)ba);
+
+done:
+ kfree(ba);
+ return err;
+}
+
/**
* hci_dev_get_bd_addr_from_property - Get the Bluetooth Device Address
* (BD_ADDR) for a HCI device from
@@ -5042,12 +5091,17 @@ static int hci_dev_setup_sync(struct hci_dev *hdev)
* its setup callback.
*/
invalid_bdaddr = hci_test_quirk(hdev, HCI_QUIRK_INVALID_BDADDR) ||
- hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY);
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) ||
+ hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM);
if (!ret) {
if (hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_PROPERTY) &&
!bacmp(&hdev->public_addr, BDADDR_ANY))
hci_dev_get_bd_addr_from_property(hdev);
+ if (hci_test_quirk(hdev, HCI_QUIRK_USE_BDADDR_NVMEM) &&
+ !bacmp(&hdev->public_addr, BDADDR_ANY))
+ hci_dev_get_bd_addr_from_nvmem(hdev);
+
if (invalid_bdaddr && bacmp(&hdev->public_addr, BDADDR_ANY) &&
hdev->set_bdaddr) {
ret = hdev->set_bdaddr(hdev, &hdev->public_addr);
--
2.34.1
^ permalink raw reply related
* [PATCH 6/9] dt-bindings: bluetooth: qcom: Add NVMEM BD address cell
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
Add support for an NVMEM cell provider for "local-bd-address",
allowing the Bluetooth stack to retrieve controller's BD address
from non-volatile storage such as an EEPROM or an eMMC partition.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
.../bindings/net/bluetooth/qcom,bluetooth-common.yaml | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml b/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
index c8e9c55c1afb4c8e05ba2dae41ce2db4194b4a0f..ecb3de65506f7f0f1fc1d0b9bbd316163b7c26e8 100644
--- a/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
+++ b/Documentation/devicetree/bindings/net/bluetooth/qcom,bluetooth-common.yaml
@@ -22,4 +22,14 @@ properties:
description:
boot firmware is incorrectly passing the address in big-endian order
+ nvmem-cells:
+ maxItems: 1
+ description:
+ Nvmem data cell that contains a 6 byte BD address with the most
+ significant byte first (big-endian).
+
+ nvmem-cell-names:
+ items:
+ - const: local-bd-address
+
additionalProperties: true
--
2.34.1
^ permalink raw reply related
* [PATCH 5/9] arm64: dts: qcom: arduino-imola: Get WiFi MAC from NVMEM
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
On Arduino Uno-Q, the WiFi MAC address is stored in the eMMC
boot1 partition. Point to the appropriate NVMEM cell to
retrieve it.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts | 3 +++
1 file changed, 3 insertions(+)
diff --git a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
index dc85cf94f71cac8666cab30ccf37cc2d2f8fd941..35a30cd6f47d6d2e018f6841a05fe929fec15738 100644
--- a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
+++ b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
@@ -581,6 +581,9 @@ &wifi {
qcom,ath10k-calibration-variant = "ArduinoImola";
firmware-name = "qcm2290";
+ nvmem-cells = <&wifi_mac_addr>;
+ nvmem-cell-names = "mac-address";
+
status = "okay";
};
--
2.34.1
^ permalink raw reply related
* [PATCH 4/9] dt-bindings: net: wireless: qcom,ath10k: Add NVMEM MAC address cell
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
Add support for an NVMEM cell provider with the standard "mac-address"
cell name. This allows the ath10k device to retrieve its MAC address
from non-volatile storage such as an EEPROM or an eMMC partition.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
.../devicetree/bindings/net/wireless/qcom,ath10k.yaml | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml b/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
index c21d66c7cd558ab792524be9afec8b79272d1c87..7155d8b15cc145c3a7d703db0c9c3e056a54c07e 100644
--- a/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
+++ b/Documentation/devicetree/bindings/net/wireless/qcom,ath10k.yaml
@@ -92,6 +92,16 @@ properties:
ieee80211-freq-limit: true
+ nvmem-cells:
+ maxItems: 1
+ description:
+ Nvmem data cell that contains a 6 byte MAC address with the most
+ significant byte first (big-endian).
+
+ nvmem-cell-names:
+ items:
+ - const: mac-address
+
qcom,calibration-data:
$ref: /schemas/types.yaml#/definitions/uint8-array
description:
--
2.34.1
^ permalink raw reply related
* [PATCH 3/9] block: implement NVMEM provider
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
From: Daniel Golle <daniel@makrotopia.org>
On embedded devices using an eMMC it is common that one or more partitions
on the eMMC are used to store MAC addresses and Wi-Fi calibration EEPROM
data. Allow referencing the partition in device tree for the kernel and
Wi-Fi drivers accessing it via the NVMEM layer.
Signed-off-by: Daniel Golle <daniel@makrotopia.org>
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
block/Kconfig | 9 +++
block/Makefile | 1 +
block/blk-nvmem.c | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 174 insertions(+)
diff --git a/block/Kconfig b/block/Kconfig
index 15027963472d7b40e27b9097a5993c457b5b3054..0b33747e16dc33473683706f75c92bdf8b648f7c 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -209,6 +209,15 @@ config BLK_INLINE_ENCRYPTION_FALLBACK
by falling back to the kernel crypto API when inline
encryption hardware is not present.
+config BLK_NVMEM
+ bool "Block device NVMEM provider"
+ depends on OF
+ depends on NVMEM
+ help
+ Allow block devices (or partitions) to act as NVMEM providers,
+ typically used with eMMC to store MAC addresses or Wi-Fi
+ calibration data on embedded devices.
+
source "block/partitions/Kconfig"
config BLK_PM
diff --git a/block/Makefile b/block/Makefile
index 7dce2e44276c4274c11a0a61121c83d9c43d6e0c..d7ac389e71902bc091a8800ea266190a43b3e63d 100644
--- a/block/Makefile
+++ b/block/Makefile
@@ -36,3 +36,4 @@ obj-$(CONFIG_BLK_INLINE_ENCRYPTION) += blk-crypto.o blk-crypto-profile.o \
blk-crypto-sysfs.o
obj-$(CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK) += blk-crypto-fallback.o
obj-$(CONFIG_BLOCK_HOLDER_DEPRECATED) += holder.o
+obj-$(CONFIG_BLK_NVMEM) += blk-nvmem.o
diff --git a/block/blk-nvmem.c b/block/blk-nvmem.c
new file mode 100644
index 0000000000000000000000000000000000000000..01b67c638a6dfd1393043024b6a7f3ebb947a57c
--- /dev/null
+++ b/block/blk-nvmem.c
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * block device NVMEM provider
+ *
+ * Copyright (c) 2024 Daniel Golle <daniel@makrotopia.org>
+ *
+ * Useful on devices using a partition on an eMMC for MAC addresses or
+ * Wi-Fi calibration EEPROM data.
+ */
+
+#include "blk.h"
+#include <linux/nvmem-provider.h>
+#include <linux/of.h>
+#include <linux/pagemap.h>
+#include <linux/property.h>
+
+/* List of all NVMEM devices */
+static LIST_HEAD(nvmem_devices);
+static DEFINE_MUTEX(devices_mutex);
+
+struct blk_nvmem {
+ struct nvmem_device *nvmem;
+ struct device *dev;
+ struct list_head list;
+};
+
+static int blk_nvmem_reg_read(void *priv, unsigned int from,
+ void *val, size_t bytes)
+{
+ blk_mode_t mode = BLK_OPEN_READ | BLK_OPEN_RESTRICT_WRITES;
+ unsigned long offs = from & ~PAGE_MASK, to_read;
+ pgoff_t f_index = from >> PAGE_SHIFT;
+ struct blk_nvmem *bnv = priv;
+ size_t bytes_left = bytes;
+ struct file *bdev_file;
+ struct folio *folio;
+ void *p;
+ int ret = 0;
+
+ bdev_file = bdev_file_open_by_dev(bnv->dev->devt, mode, priv, NULL);
+ if (!bdev_file)
+ return -ENODEV;
+
+ if (IS_ERR(bdev_file))
+ return PTR_ERR(bdev_file);
+
+ while (bytes_left) {
+ folio = read_mapping_folio(bdev_file->f_mapping, f_index++, NULL);
+ if (IS_ERR(folio)) {
+ ret = PTR_ERR(folio);
+ goto err_release_bdev;
+ }
+ to_read = min_t(unsigned long, bytes_left, PAGE_SIZE - offs);
+ p = folio_address(folio) + offset_in_folio(folio, offs);
+ memcpy(val, p, to_read);
+ offs = 0;
+ bytes_left -= to_read;
+ val += to_read;
+ folio_put(folio);
+ }
+
+err_release_bdev:
+ fput(bdev_file);
+
+ return ret;
+}
+
+static int blk_nvmem_register(struct device *dev)
+{
+ struct device_node *np = dev_of_node(dev);
+ struct block_device *bdev = dev_to_bdev(dev);
+ struct nvmem_config config = {};
+ struct blk_nvmem *bnv;
+
+ /* skip devices which do not have a device tree node */
+ if (!np)
+ return 0;
+
+ /* skip devices without an nvmem layout defined */
+ if (!of_get_child_by_name(np, "nvmem-layout"))
+ return 0;
+
+ /*
+ * skip block device too large to be represented as NVMEM devices
+ * which are using an 'int' as address
+ */
+ if (bdev_nr_bytes(bdev) > INT_MAX)
+ return -EFBIG;
+
+ bnv = kzalloc_obj(*bnv);
+ if (!bnv)
+ return -ENOMEM;
+
+ config.id = NVMEM_DEVID_NONE;
+ config.dev = &bdev->bd_device;
+ config.name = dev_name(&bdev->bd_device);
+ config.owner = THIS_MODULE;
+ config.priv = bnv;
+ config.reg_read = blk_nvmem_reg_read;
+ config.size = bdev_nr_bytes(bdev);
+ config.word_size = 1;
+ config.stride = 1;
+ config.read_only = true;
+ config.root_only = true;
+ config.ignore_wp = true;
+ config.of_node = to_of_node(dev->fwnode);
+
+ bnv->dev = &bdev->bd_device;
+ bnv->nvmem = nvmem_register(&config);
+ if (IS_ERR(bnv->nvmem)) {
+ dev_err_probe(&bdev->bd_device, PTR_ERR(bnv->nvmem),
+ "Failed to register NVMEM device\n");
+
+ kfree(bnv);
+ return PTR_ERR(bnv->nvmem);
+ }
+
+ mutex_lock(&devices_mutex);
+ list_add_tail(&bnv->list, &nvmem_devices);
+ mutex_unlock(&devices_mutex);
+
+ return 0;
+}
+
+static void blk_nvmem_unregister(struct device *dev)
+{
+ struct blk_nvmem *bnv_c, *bnv = NULL;
+
+ mutex_lock(&devices_mutex);
+ list_for_each_entry(bnv_c, &nvmem_devices, list) {
+ if (bnv_c->dev == dev) {
+ bnv = bnv_c;
+ break;
+ }
+ }
+
+ if (!bnv) {
+ mutex_unlock(&devices_mutex);
+ return;
+ }
+
+ list_del(&bnv->list);
+ mutex_unlock(&devices_mutex);
+ nvmem_unregister(bnv->nvmem);
+ kfree(bnv);
+}
+
+static struct class_interface blk_nvmem_bus_interface __refdata = {
+ .class = &block_class,
+ .add_dev = &blk_nvmem_register,
+ .remove_dev = &blk_nvmem_unregister,
+};
+
+static int __init blk_nvmem_init(void)
+{
+ int ret;
+
+ ret = class_interface_register(&blk_nvmem_bus_interface);
+ if (ret)
+ return ret;
+
+ return 0;
+}
+device_initcall(blk_nvmem_init);
--
2.34.1
^ permalink raw reply related
* [PATCH 2/9] arm64: dts: qcom: arduino-imola: Describe boot1 NVMEM layout
From: Loic Poulain @ 2026-04-28 14:23 UTC (permalink / raw)
To: Ulf Hansson, Rob Herring, Krzysztof Kozlowski, Conor Dooley,
Bjorn Andersson, Konrad Dybcio, Jens Axboe, Johannes Berg,
Jeff Johnson, Bartosz Golaszewski, Marcel Holtmann,
Luiz Augusto von Dentz, Balakrishna Godavarthi, Rocky Liao,
David S. Miller, Eric Dumazet, Jakub Kicinski, Paolo Abeni,
Simon Horman
Cc: linux-mmc, devicetree, linux-kernel, linux-arm-msm, linux-block,
linux-wireless, ath10k, linux-bluetooth, netdev, daniel,
Loic Poulain
In-Reply-To: <20260428-block-as-nvmem-v1-0-6ad23e75190a@oss.qualcomm.com>
On Arduino Uno-Q, the eMMC boot1 partition is factory provisioned
with device-specific information such as the WiFi MAC address
and the Bluetooth BD address. This partition can serve as an
alternative to additional non-volatile memory, such as a
dedicated EEPROM.
The eMMC boot partitions are typically good candidates, as they
are realively small, read-only by default (and can be enforced
as hardware read-only), and are not affected by board reflashing
procedures, which generally target the eMMC user or GP partitions.
Describe the corresponding nvmem-layout for the WiFi and
Bluetooth addresses.
Signed-off-by: Loic Poulain <loic.poulain@oss.qualcomm.com>
---
arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts | 24 ++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
index bf088fa9807f040f0c8f405f9111b01790b09377..dc85cf94f71cac8666cab30ccf37cc2d2f8fd941 100644
--- a/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
+++ b/arch/arm64/boot/dts/qcom/qrb2210-arduino-imola.dts
@@ -409,7 +409,31 @@ &sdhc_1 {
no-sdio;
no-sd;
+ #address-cells = <1>;
+ #size-cells = <0>;
+
status = "okay";
+
+ card@0 {
+ compatible = "mmc-card";
+ reg = <0>;
+
+ partitions-boot1 {
+ nvmem-layout {
+ compatible = "fixed-layout";
+ #address-cells = <1>;
+ #size-cells = <1>;
+
+ wifi_mac_addr: mac-addr@4400 {
+ reg = <0x4400 0x6>;
+ };
+
+ bd_addr: bd-addr@5400 {
+ reg = <0x5400 0x6>;
+ };
+ };
+ };
+ };
};
&spi5 {
--
2.34.1
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox