mwifiex: store card specific data in PCI device table entry

This patch adds support for storing PCIe device specific data
into driver_data structure of pci_device_id. When a device with
known device_id is probed, we use this driver_data to populate
card specific structres in driver.
This enables to remove device specific defines for scratch
registers, firmware name, FW download block size, etc. from
source code.

This will make addition of support for new chipsets a lot easier.

Signed-off-by: Avinash Patil <patila@marvell.com>
Signed-off-by: Bing Zhao <bzhao@marvell.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 122 insertions, 89 deletions

diff --git a/drivers/net/wireless/mwifiex/pcie.c b/drivers/net/wireless/mwifiex/pcie.c
index df88e65595c8..29c539b9424b 100644
--- a/drivers/net/wireless/mwifiex/pcie.c
+++ b/drivers/net/wireless/mwifiex/pcie.c
@@ -94,6 +94,13 @@ static int mwifiex_pcie_probe(struct pci_dev *pdev,
 
         card->dev = pdev;
 
+        if (ent->driver_data) {
+                struct mwifiex_pcie_device *data = (void *)ent->driver_data;
+                card->pcie.firmware = data->firmware;
+                card->pcie.reg = data->reg;
+                card->pcie.blksz_fw_dl = data->blksz_fw_dl;
+        }
+
         if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
                              MWIFIEX_PCIE)) {
                 pr_err("%s failed\n", __func__);
@@ -237,6 +244,7 @@ static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
         {
                 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                .driver_data = (unsigned long) &mwifiex_pcie8766,
         },
         {},
 };
@@ -369,6 +377,7 @@ static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         int i;
 
         /*
@@ -377,7 +386,7 @@ static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
          * starts at zero with rollover bit set
          */
         card->txbd_wrptr = 0;
-        card->txbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->txbd_rdptr |= reg->tx_rollover_ind;
 
         /* allocate shared memory for the BD ring and divide the same in to
            several descriptors */
@@ -417,6 +426,7 @@ static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb;
         int i;
 
@@ -440,7 +450,7 @@ static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
                                     card->txbd_ring_pbase);
         card->txbd_ring_size = 0;
         card->txbd_wrptr = 0;
-        card->txbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->txbd_rdptr = 0 | reg->tx_rollover_ind;
         card->txbd_ring_vbase = NULL;
         card->txbd_ring_pbase = 0;
 
@@ -453,6 +463,7 @@ static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb;
         int i;
         dma_addr_t buf_pa;
@@ -463,7 +474,7 @@ static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
          * starts at zero with rollover bit set
          */
         card->rxbd_wrptr = 0;
-        card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->rxbd_rdptr = reg->rx_rollover_ind;
 
         card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
                                                         MWIFIEX_MAX_TXRX_BD;
@@ -526,6 +537,7 @@ static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb;
         int i;
 
@@ -550,7 +562,7 @@ static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
                                     card->rxbd_ring_pbase);
         card->rxbd_ring_size = 0;
         card->rxbd_wrptr = 0;
-        card->rxbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
         card->rxbd_ring_vbase = NULL;
         card->rxbd_ring_pbase = 0;
 
@@ -563,6 +575,7 @@ static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb;
         int i;
         dma_addr_t buf_pa;
@@ -573,7 +586,7 @@ static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
          * starts at zero with rollover bit set
          */
         card->evtbd_wrptr = 0;
-        card->evtbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->evtbd_rdptr = reg->evt_rollover_ind;
 
         card->evtbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
                                                         MWIFIEX_MAX_EVT_BD;
@@ -636,6 +649,7 @@ static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb;
         int i;
 
@@ -658,7 +672,7 @@ static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
                                     card->evtbd_ring_vbase,
                                     card->evtbd_ring_pbase);
         card->evtbd_wrptr = 0;
-        card->evtbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
+        card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
         card->evtbd_ring_size = 0;
         card->evtbd_ring_vbase = NULL;
         card->evtbd_ring_pbase = 0;
@@ -771,12 +785,13 @@ static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         u32 rdptr;
 
         /* Read the TX ring read pointer set by firmware */
-        if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) {
+        if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
                 dev_err(adapter->dev,
-                        "Flush TXBD: failed to read REG_TXBD_RDPTR\n");
+                        "Flush TXBD: failed to read reg->tx_rdptr\n");
                 return -1;
         }
 
@@ -805,14 +820,15 @@ static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
         dma_addr_t buf_pa;
         u32 wrdoneidx, rdptr, unmap_count = 0;
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 
         if (!mwifiex_pcie_ok_to_access_hw(adapter))
                 mwifiex_pm_wakeup_card(adapter);
 
         /* Read the TX ring read pointer set by firmware */
-        if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) {
+        if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
                 dev_err(adapter->dev,
-                        "SEND COMP: failed to read REG_TXBD_RDPTR\n");
+                        "SEND COMP: failed to read reg->tx_rdptr\n");
                 return -1;
         }
 
@@ -820,11 +836,11 @@ static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
                 card->txbd_rdptr, rdptr);
 
         /* free from previous txbd_rdptr to current txbd_rdptr */
-        while (((card->txbd_rdptr & MWIFIEX_TXBD_MASK) !=
-                (rdptr & MWIFIEX_TXBD_MASK)) ||
-               ((card->txbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) !=
-                (rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
-                wrdoneidx = card->txbd_rdptr & MWIFIEX_TXBD_MASK;
+        while (((card->txbd_rdptr & reg->tx_mask) !=
+                (rdptr & reg->tx_mask)) ||
+               ((card->txbd_rdptr & reg->tx_rollover_ind) !=
+                (rdptr & reg->tx_rollover_ind))) {
+                wrdoneidx = card->txbd_rdptr & reg->tx_mask;
 
                 skb = card->tx_buf_list[wrdoneidx];
                 if (skb) {
@@ -850,20 +866,20 @@ static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
                 card->txbd_ring[wrdoneidx]->flags = 0;
                 card->txbd_rdptr++;
 
-                if ((card->txbd_rdptr & MWIFIEX_TXBD_MASK) == num_tx_buffs)
+                if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
                         card->txbd_rdptr = ((card->txbd_rdptr &
-                                            MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
-                                            MWIFIEX_BD_FLAG_ROLLOVER_IND);
+                                             reg->tx_rollover_ind) ^
+                                             reg->tx_rollover_ind);
         }
 
         if (unmap_count)
                 adapter->data_sent = false;
 
         if (card->txbd_flush) {
-                if (((card->txbd_wrptr & MWIFIEX_TXBD_MASK) ==
-                     (card->txbd_rdptr & MWIFIEX_TXBD_MASK)) &&
-                    ((card->txbd_wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) !=
-                     (card->txbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND)))
+                if (((card->txbd_wrptr & reg->tx_mask) ==
+                     (card->txbd_rdptr & reg->tx_mask)) &&
+                    ((card->txbd_wrptr & reg->tx_rollover_ind) !=
+                     (card->txbd_rdptr & reg->tx_rollover_ind)))
                         card->txbd_flush = 0;
                 else
                         mwifiex_clean_pcie_ring_buf(adapter);
@@ -883,6 +899,7 @@ mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
                        struct mwifiex_tx_param *tx_param)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         u32 wrindx;
         int ret;
         dma_addr_t buf_pa;
@@ -913,7 +930,7 @@ mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
                                            PCI_DMA_TODEVICE))
                         return -1;
 
-                wrindx = card->txbd_wrptr & MWIFIEX_TXBD_MASK;
+                wrindx = card->txbd_wrptr & reg->tx_mask;
                 MWIFIEX_SKB_PACB(skb, &buf_pa);
                 card->tx_buf_list[wrindx] = skb;
                 card->txbd_ring[wrindx]->paddr = buf_pa;
@@ -921,17 +938,17 @@ mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
                 card->txbd_ring[wrindx]->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
                                                 MWIFIEX_BD_FLAG_LAST_DESC;
 
-                if ((++card->txbd_wrptr & MWIFIEX_TXBD_MASK) ==
+                if ((++card->txbd_wrptr & reg->tx_mask) ==
                                                         MWIFIEX_MAX_TXRX_BD)
                         card->txbd_wrptr = ((card->txbd_wrptr &
-                                                MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
-                                                MWIFIEX_BD_FLAG_ROLLOVER_IND);
+                                                reg->tx_rollover_ind) ^
+                                                reg->tx_rollover_ind);
 
-                /* Write the TX ring write pointer in to REG_TXBD_WRPTR */
-                if (mwifiex_write_reg(adapter, REG_TXBD_WRPTR,
+                /* Write the TX ring write pointer in to reg->tx_wrptr */
+                if (mwifiex_write_reg(adapter, reg->tx_wrptr,
                                       card->txbd_wrptr)) {
                         dev_err(adapter->dev,
-                                "SEND DATA: failed to write REG_TXBD_WRPTR\n");
+                                "SEND DATA: failed to write reg->tx_wrptr\n");
                         ret = -1;
                         goto done_unmap;
                 }
@@ -984,6 +1001,7 @@ done_unmap:
 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         u32 wrptr, rd_index;
         dma_addr_t buf_pa;
         int ret = 0;
@@ -993,23 +1011,23 @@ static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
                 mwifiex_pm_wakeup_card(adapter);
 
         /* Read the RX ring Write pointer set by firmware */
-        if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
+        if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
                 dev_err(adapter->dev,
-                        "RECV DATA: failed to read REG_TXBD_RDPTR\n");
+                        "RECV DATA: failed to read reg->rx_wrptr\n");
                 ret = -1;
                 goto done;
         }
         card->rxbd_wrptr = wrptr;
 
-        while (((wrptr & MWIFIEX_RXBD_MASK) !=
-                (card->rxbd_rdptr & MWIFIEX_RXBD_MASK)) ||
-               ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
-                (card->rxbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
+        while (((wrptr & reg->rx_mask) !=
+                (card->rxbd_rdptr & reg->rx_mask)) ||
+               ((wrptr & reg->rx_rollover_ind) ==
+                (card->rxbd_rdptr & reg->rx_rollover_ind))) {
                 struct sk_buff *skb_data;
                 u16 rx_len;
                 __le16 pkt_len;
 
-                rd_index = card->rxbd_rdptr & MWIFIEX_RXBD_MASK;
+                rd_index = card->rxbd_rdptr & reg->rx_mask;
                 skb_data = card->rx_buf_list[rd_index];
 
                 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
@@ -1051,28 +1069,28 @@ static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
                 card->rxbd_ring[rd_index]->len = skb_tmp->len;
                 card->rxbd_ring[rd_index]->flags = 0;
 
-                if ((++card->rxbd_rdptr & MWIFIEX_RXBD_MASK) ==
+                if ((++card->rxbd_rdptr & reg->rx_mask) ==
                                                         MWIFIEX_MAX_TXRX_BD) {
                         card->rxbd_rdptr = ((card->rxbd_rdptr &
-                                             MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
-                                            MWIFIEX_BD_FLAG_ROLLOVER_IND);
+                                             reg->rx_rollover_ind) ^
+                                             reg->rx_rollover_ind);
                 }
                 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
                         card->rxbd_rdptr, wrptr);
 
-                /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
-                if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR,
+                /* Write the RX ring read pointer in to reg->rx_rdptr */
+                if (mwifiex_write_reg(adapter, reg->rx_rdptr,
                                       card->rxbd_rdptr)) {
                         dev_err(adapter->dev,
-                                "RECV DATA: failed to write REG_RXBD_RDPTR\n");
+                                "RECV DATA: failed to write reg->rx_rdptr\n");
                         ret = -1;
                         goto done;
                 }
 
                 /* Read the RX ring Write pointer set by firmware */
-                if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
+                if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
                         dev_err(adapter->dev,
-                                "RECV DATA: failed to read REG_TXBD_RDPTR\n");
+                                "RECV DATA: failed to read reg->rx_wrptr\n");
                         ret = -1;
                         goto done;
                 }
@@ -1093,6 +1111,7 @@ mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 {
         dma_addr_t buf_pa;
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 
         if (!(skb->data && skb->len)) {
                 dev_err(adapter->dev,
@@ -1106,9 +1125,10 @@ mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 
         MWIFIEX_SKB_PACB(skb, &buf_pa);
 
-        /* Write the lower 32bits of the physical address to scratch
-         * register 0 */
-        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)buf_pa)) {
+        /* Write the lower 32bits of the physical address to low command
+         * address scratch register
+         */
+        if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
                 dev_err(adapter->dev,
                         "%s: failed to write download command to boot code.\n",
                         __func__);
@@ -1117,9 +1137,10 @@ mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
                 return -1;
         }
 
-        /* Write the upper 32bits of the physical address to scratch
-         * register 1 */
-        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG,
+        /* Write the upper 32bits of the physical address to high command
+         * address scratch register
+         */
+        if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
                               (u32)((u64)buf_pa >> 32))) {
                 dev_err(adapter->dev,
                         "%s: failed to write download command to boot code.\n",
@@ -1129,10 +1150,10 @@ mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
                 return -1;
         }
 
-        /* Write the command length to scratch register 2 */
-        if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) {
+        /* Write the command length to cmd_size scratch register */
+        if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
                 dev_err(adapter->dev,
-                        "%s: failed to write command len to scratch reg 2\n",
+                        "%s: failed to write command len to cmd_size scratch reg\n",
                         __func__);
                 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
                                  PCI_DMA_TODEVICE);
@@ -1158,11 +1179,12 @@ mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 
-        /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
-        if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR, card->rxbd_rdptr | 0)) {
+        /* Write the RX ring read pointer in to reg->rx_rdptr */
+        if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr)) {
                 dev_err(adapter->dev,
-                        "RECV DATA: failed to write REG_RXBD_RDPTR\n");
+                        "RECV DATA: failed to write reg->rx_rdptr\n");
                 return -1;
         }
         return 0;
@@ -1174,6 +1196,7 @@ static int
 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         int ret = 0;
         dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
         u8 *payload = (u8 *)skb->data;
@@ -1206,7 +1229,7 @@ mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
 
         /* To send a command, the driver will:
                 1. Write the 64bit physical address of the data buffer to
-                   SCRATCH1 + SCRATCH0
+                   cmd response address low  + cmd response address high
                 2. Ring the door bell (i.e. set the door bell interrupt)
 
                 In response to door bell interrupt, the firmware will perform
@@ -1218,7 +1241,7 @@ mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
                 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
                 /* Write the lower 32bits of the cmdrsp buffer physical
                    address */
-                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO,
+                if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
                                       (u32)cmdrsp_buf_pa)) {
                         dev_err(adapter->dev,
                                 "Failed to write download cmd to boot code.\n");
@@ -1227,7 +1250,7 @@ mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
                 }
                 /* Write the upper 32bits of the cmdrsp buffer physical
                    address */
-                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI,
+                if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
                                       (u32)((u64)cmdrsp_buf_pa >> 32))) {
                         dev_err(adapter->dev,
                                 "Failed to write download cmd to boot code.\n");
@@ -1237,15 +1260,16 @@ mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
         }
 
         MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
-        /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
-        if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO, (u32)cmd_buf_pa)) {
+        /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
+        if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
+                              (u32)cmd_buf_pa)) {
                 dev_err(adapter->dev,
                         "Failed to write download cmd to boot code.\n");
                 ret = -1;
                 goto done;
         }
-        /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
-        if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI,
+        /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
+        if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
                               (u32)((u64)cmd_buf_pa >> 32))) {
                 dev_err(adapter->dev,
                         "Failed to write download cmd to boot code.\n");
@@ -1253,10 +1277,11 @@ mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
                 goto done;
         }
 
-        /* Write the command length to REG_CMD_SIZE */
-        if (mwifiex_write_reg(adapter, REG_CMD_SIZE, card->cmd_buf->len)) {
+        /* Write the command length to reg->cmd_size */
+        if (mwifiex_write_reg(adapter, reg->cmd_size,
+                              card->cmd_buf->len)) {
                 dev_err(adapter->dev,
-                        "Failed to write cmd len to REG_CMD_SIZE\n");
+                        "Failed to write cmd len to reg->cmd_size\n");
                 ret = -1;
                 goto done;
         }
@@ -1283,6 +1308,7 @@ done:
 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         struct sk_buff *skb = card->cmdrsp_buf;
         int count = 0;
         u16 rx_len;
@@ -1328,14 +1354,14 @@ static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
                 /* Clear the cmd-rsp buffer address in scratch registers. This
                    will prevent firmware from writing to the same response
                    buffer again. */
-                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) {
+                if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
                         dev_err(adapter->dev,
                                 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
                         return -1;
                 }
                 /* Write the upper 32bits of the cmdrsp buffer physical
                    address */
-                if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) {
+                if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
                         dev_err(adapter->dev,
                                 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
                         return -1;
@@ -1380,6 +1406,7 @@ static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
         u32 wrptr, event;
         dma_addr_t buf_pa;
@@ -1399,9 +1426,9 @@ static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
         }
 
         /* Read the event ring write pointer set by firmware */
-        if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
+        if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
                 dev_err(adapter->dev,
-                        "EventReady: failed to read REG_EVTBD_WRPTR\n");
+                        "EventReady: failed to read reg->evt_wrptr\n");
                 return -1;
         }
 
@@ -1409,8 +1436,8 @@ static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
                 card->evtbd_rdptr, wrptr);
         if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
                                               & MWIFIEX_EVTBD_MASK)) ||
-            ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
-             (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
+            ((wrptr & reg->evt_rollover_ind) ==
+             (card->evtbd_rdptr & reg->evt_rollover_ind))) {
                 struct sk_buff *skb_cmd;
                 __le16 data_len = 0;
                 u16 evt_len;
@@ -1462,6 +1489,7 @@ static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
                                        struct sk_buff *skb)
 {
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         int ret = 0;
         u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
         u32 wrptr;
@@ -1477,9 +1505,9 @@ static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
         }
 
         /* Read the event ring write pointer set by firmware */
-        if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
+        if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
                 dev_err(adapter->dev,
-                        "event_complete: failed to read REG_EVTBD_WRPTR\n");
+                        "event_complete: failed to read reg->evt_wrptr\n");
                 return -1;
         }
 
@@ -1504,17 +1532,18 @@ static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
 
         if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
                 card->evtbd_rdptr = ((card->evtbd_rdptr &
-                                        MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
-                                        MWIFIEX_BD_FLAG_ROLLOVER_IND);
+                                        reg->evt_rollover_ind) ^
+                                        reg->evt_rollover_ind);
         }
 
         dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
                 card->evtbd_rdptr, wrptr);
 
-        /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
-        if (mwifiex_write_reg(adapter, REG_EVTBD_RDPTR, card->evtbd_rdptr)) {
+        /* Write the event ring read pointer in to reg->evt_rdptr */
+        if (mwifiex_write_reg(adapter, reg->evt_rdptr,
+                              card->evtbd_rdptr)) {
                 dev_err(adapter->dev,
-                        "event_complete: failed to read REG_EVTBD_RDPTR\n");
+                        "event_complete: failed to read reg->evt_rdptr\n");
                 return -1;
         }
 
@@ -1543,6 +1572,7 @@ static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
         u32 block_retry_cnt = 0;
         dma_addr_t buf_pa;
         struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 
         if (!firmware || !firmware_len) {
                 dev_err(adapter->dev,
@@ -1574,7 +1604,7 @@ static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
                         break;
 
                 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
-                        ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_2_REG,
+                        ret = mwifiex_read_reg(adapter, reg->cmd_size,
                                                &len);
                         if (ret) {
                                 dev_warn(adapter->dev,
@@ -1620,16 +1650,15 @@ static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
 
                         dev_dbg(adapter->dev, ".");
 
-                        tx_blocks = (txlen +
-                                     MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
-                                     MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
+                        tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
+                                    card->pcie.blksz_fw_dl;
 
                         /* Copy payload to buffer */
                         memmove(skb->data, &firmware[offset], txlen);
                 }
 
                 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
-                skb_trim(skb, tx_blocks * MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD);
+                skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
 
                 /* Send the boot command to device */
                 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
@@ -1682,6 +1711,8 @@ mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
 {
         int ret = 0;
         u32 firmware_stat, winner_status;
+        struct pcie_service_card *card = adapter->card;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
         u32 tries;
 
         /* Mask spurios interrupts */
@@ -1692,7 +1723,8 @@ mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
         }
 
         dev_dbg(adapter->dev, "Setting driver ready signature\n");
-        if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) {
+        if (mwifiex_write_reg(adapter, reg->drv_rdy,
+                              FIRMWARE_READY_PCIE)) {
                 dev_err(adapter->dev,
                         "Failed to write driver ready signature\n");
                 return -1;
@@ -1700,7 +1732,7 @@ mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
 
         /* Wait for firmware initialization event */
         for (tries = 0; tries < poll_num; tries++) {
-                if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
+                if (mwifiex_read_reg(adapter, reg->fw_status,
                                      &firmware_stat))
                         ret = -1;
                 else
@@ -1717,7 +1749,7 @@ mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
         }
 
         if (ret) {
-                if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
+                if (mwifiex_read_reg(adapter, reg->fw_status,
                                      &winner_status))
                         ret = -1;
                 else if (!winner_status) {
@@ -2061,10 +2093,11 @@ static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
 {
         struct pcie_service_card *card = adapter->card;
         struct pci_dev *pdev = card->dev;
+        const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
 
         if (user_rmmod) {
                 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
-                if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000))
+                if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
                         dev_err(adapter->dev,
                                 "Failed to write driver not-ready signature\n");
         }
@@ -2102,7 +2135,7 @@ static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
         }
 
         adapter->dev = &pdev->dev;
-        strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
+        strcpy(adapter->fw_name, card->pcie.firmware);
 
         return 0;
 }