[SCSI] bfa: enable new hardware

This patch enables support of new mezzanine cards for HP and IBM blade server.

- Add new pciids for HP and IBM mezzanine card.
- Add a new firmware image for HP mezzanine card, which is running in
  FC only mode. Rename firmware image to reflect the difference. Change the
  firmware download code accordingly for the above changes.

Signed-off-by: Jing Huang <huangj@brocade.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>

14 files changed, 155 insertions, 115 deletions

diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 3a7b3f88932..bef70924d5c 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -333,6 +333,7 @@ bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids)
                 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G2P},
                 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G1P},
                 {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT},
+                {BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT_FC},
         };
 
         *npciids = sizeof(__pciids) / sizeof(__pciids[0]);
diff --git a/drivers/scsi/bfa/bfa_fwimg_priv.h b/drivers/scsi/bfa/bfa_fwimg_priv.h
index 1ec1355924d..d33e19e5439 100644
--- a/drivers/scsi/bfa/bfa_fwimg_priv.h
+++ b/drivers/scsi/bfa/bfa_fwimg_priv.h
@@ -21,11 +21,24 @@
 #define BFI_FLASH_CHUNK_SZ              256     /*  Flash chunk size */
 #define BFI_FLASH_CHUNK_SZ_WORDS        (BFI_FLASH_CHUNK_SZ/sizeof(u32))
 
-extern u32 *bfi_image_ct_get_chunk(u32 off);
-extern u32 bfi_image_ct_size;
-extern u32 *bfi_image_cb_get_chunk(u32 off);
-extern u32 bfi_image_cb_size;
-extern u32 *bfi_image_cb;
-extern u32 *bfi_image_ct;
+/**
+ * BFI FW image type
+ */
+enum {
+        BFI_IMAGE_CB_FC,
+        BFI_IMAGE_CT_FC,
+        BFI_IMAGE_CT_CNA,
+        BFI_IMAGE_MAX,
+};
+
+extern u32 *bfi_image_get_chunk(int type, uint32_t off);
+extern u32 bfi_image_get_size(int type);
+extern u32 bfi_image_ct_fc_size;
+extern u32 bfi_image_ct_cna_size;
+extern u32 bfi_image_cb_fc_size;
+extern u32 *bfi_image_ct_fc;
+extern u32 *bfi_image_ct_cna;
+extern u32 *bfi_image_cb_fc;
+
 
 #endif /* __BFA_FWIMG_PRIV_H__ */
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index e038bc9769f..ef3b3fefbe7 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -59,14 +59,12 @@ BFA_TRC_FILE(CNA, IOC);
                         ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
 #define bfa_ioc_firmware_unlock(__ioc)                  \
                         ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
-#define bfa_ioc_fwimg_get_chunk(__ioc, __off)           \
-                        ((__ioc)->ioc_hwif->ioc_fwimg_get_chunk(__ioc, __off))
-#define bfa_ioc_fwimg_get_size(__ioc)                   \
-                        ((__ioc)->ioc_hwif->ioc_fwimg_get_size(__ioc))
 #define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
 #define bfa_ioc_notify_hbfail(__ioc)                    \
                         ((__ioc)->ioc_hwif->ioc_notify_hbfail(__ioc))
+#define bfa_ioc_is_optrom(__ioc)        \
+        (bfi_image_get_size(BFA_IOC_FWIMG_TYPE(__ioc)) < BFA_IOC_FWIMG_MINSZ)
 
 bfa_boolean_t   bfa_auto_recover = BFA_TRUE;
 
@@ -879,8 +877,8 @@ bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
         struct bfi_ioc_image_hdr_s *drv_fwhdr;
         int             i;
 
-        drv_fwhdr =
-                (struct bfi_ioc_image_hdr_s *)bfa_ioc_fwimg_get_chunk(ioc, 0);
+        drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
+                        bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
 
         for (i = 0; i < BFI_IOC_MD5SUM_SZ; i++) {
                 if (fwhdr->md5sum[i] != drv_fwhdr->md5sum[i]) {
@@ -907,12 +905,13 @@ bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc)
         /**
          * If bios/efi boot (flash based) -- return true
          */
-        if (bfa_ioc_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+        if (bfa_ioc_is_optrom(ioc))
                 return BFA_TRUE;
 
         bfa_ioc_fwver_get(ioc, &fwhdr);
-        drv_fwhdr =
-                (struct bfi_ioc_image_hdr_s *)bfa_ioc_fwimg_get_chunk(ioc, 0);
+        drv_fwhdr = (struct bfi_ioc_image_hdr_s *)
+                        bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), 0);
+
 
         if (fwhdr.signature != drv_fwhdr->signature) {
                 bfa_trc(ioc, fwhdr.signature);
@@ -1125,21 +1124,22 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
         /**
          * Flash based firmware boot
          */
-        bfa_trc(ioc, bfa_ioc_fwimg_get_size(ioc));
-        if (bfa_ioc_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+        bfa_trc(ioc, bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)));
+        if (bfa_ioc_is_optrom(ioc))
                 boot_type = BFI_BOOT_TYPE_FLASH;
-        fwimg = bfa_ioc_fwimg_get_chunk(ioc, chunkno);
+        fwimg = bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc), chunkno);
+
 
         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
 
         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
 
-        for (i = 0; i < bfa_ioc_fwimg_get_size(ioc); i++) {
+        for (i = 0; i < bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)); i++) {
 
                 if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
                         chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
-                        fwimg = bfa_ioc_fwimg_get_chunk(ioc,
+                        fwimg = bfi_image_get_chunk(BFA_IOC_FWIMG_TYPE(ioc),
                                         BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
                 }
 
@@ -1188,6 +1188,7 @@ bfa_ioc_getattr_reply(struct bfa_ioc_s *ioc)
         struct bfi_ioc_attr_s *attr = ioc->attr;
 
         attr->adapter_prop = bfa_os_ntohl(attr->adapter_prop);
+        attr->card_type     = bfa_os_ntohl(attr->card_type);
         attr->maxfrsize = bfa_os_ntohs(attr->maxfrsize);
 
         bfa_fsm_send_event(ioc, IOC_E_FWRSP_GETATTR);
@@ -1416,7 +1417,7 @@ bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
 {
         ioc->ioc_mc = mc;
         ioc->pcidev = *pcidev;
-        ioc->ctdev = (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT);
+        ioc->ctdev  = bfa_asic_id_ct(ioc->pcidev.device_id);
         ioc->cna = ioc->ctdev && !ioc->fcmode;
 
         /**
@@ -1916,7 +1917,7 @@ bfa_ioc_set_fcmode(struct bfa_ioc_s *ioc)
 bfa_boolean_t
 bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc)
 {
-        return ioc->fcmode || (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_CT);
+        return ioc->fcmode || !bfa_asic_id_ct(ioc->pcidev.device_id);
 }
 
 /**
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index d0804406ea1..2fbb6b2efc7 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -186,9 +186,6 @@ struct bfa_ioc_hwif_s {
         bfa_status_t    (*ioc_pll_init) (struct bfa_ioc_s *ioc);
         bfa_boolean_t   (*ioc_firmware_lock)    (struct bfa_ioc_s *ioc);
         void            (*ioc_firmware_unlock)  (struct bfa_ioc_s *ioc);
-        u32 *           (*ioc_fwimg_get_chunk)  (struct bfa_ioc_s *ioc,
-                                                u32 off);
-        u32             (*ioc_fwimg_get_size)   (struct bfa_ioc_s *ioc);
         void            (*ioc_reg_init) (struct bfa_ioc_s *ioc);
         void            (*ioc_map_port) (struct bfa_ioc_s *ioc);
         void            (*ioc_isr_mode_set)     (struct bfa_ioc_s *ioc,
@@ -214,6 +211,10 @@ struct bfa_ioc_hwif_s {
 
 #define bfa_ioc_stats(_ioc, _stats)     ((_ioc)->stats._stats++)
 #define BFA_IOC_FWIMG_MINSZ     (16 * 1024)
+#define BFA_IOC_FWIMG_TYPE(__ioc)                                       \
+        (((__ioc)->ctdev) ?                                             \
+         (((__ioc)->fcmode) ? BFI_IMAGE_CT_FC : BFI_IMAGE_CT_CNA) :     \
+         BFI_IMAGE_CB_FC)
 
 #define BFA_IOC_FLASH_CHUNK_NO(off)             (off / BFI_FLASH_CHUNK_SZ_WORDS)
 #define BFA_IOC_FLASH_OFFSET_IN_CHUNK(off)      (off % BFI_FLASH_CHUNK_SZ_WORDS)
diff --git a/drivers/scsi/bfa/bfa_ioc_cb.c b/drivers/scsi/bfa/bfa_ioc_cb.c
index 3ce85319f73..324bdde7ea2 100644
--- a/drivers/scsi/bfa/bfa_ioc_cb.c
+++ b/drivers/scsi/bfa/bfa_ioc_cb.c
@@ -33,26 +33,13 @@ BFA_TRC_FILE(CNA, IOC_CB);
 static bfa_status_t bfa_ioc_cb_pll_init(struct bfa_ioc_s *ioc);
 static bfa_boolean_t bfa_ioc_cb_firmware_lock(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_firmware_unlock(struct bfa_ioc_s *ioc);
-static u32  *bfa_ioc_cb_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off);
-static u32 bfa_ioc_cb_fwimg_get_size(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_reg_init(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
 static void bfa_ioc_cb_notify_hbfail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc);
 
-struct bfa_ioc_hwif_s hwif_cb = {
-        bfa_ioc_cb_pll_init,
-        bfa_ioc_cb_firmware_lock,
-        bfa_ioc_cb_firmware_unlock,
-        bfa_ioc_cb_fwimg_get_chunk,
-        bfa_ioc_cb_fwimg_get_size,
-        bfa_ioc_cb_reg_init,
-        bfa_ioc_cb_map_port,
-        bfa_ioc_cb_isr_mode_set,
-        bfa_ioc_cb_notify_hbfail,
-        bfa_ioc_cb_ownership_reset,
-};
+struct bfa_ioc_hwif_s hwif_cb;
 
 /**
  * Called from bfa_ioc_attach() to map asic specific calls.
@@ -60,19 +47,16 @@ struct bfa_ioc_hwif_s hwif_cb = {
 void
 bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc)
 {
-        ioc->ioc_hwif = &hwif_cb;
-}
-
-static u32 *
-bfa_ioc_cb_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off)
-{
-        return bfi_image_cb_get_chunk(off);
-}
+        hwif_cb.ioc_pll_init = bfa_ioc_cb_pll_init;
+        hwif_cb.ioc_firmware_lock = bfa_ioc_cb_firmware_lock;
+        hwif_cb.ioc_firmware_unlock = bfa_ioc_cb_firmware_unlock;
+        hwif_cb.ioc_reg_init = bfa_ioc_cb_reg_init;
+        hwif_cb.ioc_map_port = bfa_ioc_cb_map_port;
+        hwif_cb.ioc_isr_mode_set = bfa_ioc_cb_isr_mode_set;
+        hwif_cb.ioc_notify_hbfail = bfa_ioc_cb_notify_hbfail;
+        hwif_cb.ioc_ownership_reset = bfa_ioc_cb_ownership_reset;
 
-static u32
-bfa_ioc_cb_fwimg_get_size(struct bfa_ioc_s *ioc)
-{
-        return bfi_image_cb_size;
+        ioc->ioc_hwif = &hwif_cb;
 }
 
 /**
diff --git a/drivers/scsi/bfa/bfa_ioc_ct.c b/drivers/scsi/bfa/bfa_ioc_ct.c
index 20b58ad5f95..17bd1513b34 100644
--- a/drivers/scsi/bfa/bfa_ioc_ct.c
+++ b/drivers/scsi/bfa/bfa_ioc_ct.c
@@ -33,27 +33,13 @@ BFA_TRC_FILE(CNA, IOC_CT);
 static bfa_status_t bfa_ioc_ct_pll_init(struct bfa_ioc_s *ioc);
 static bfa_boolean_t bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc);
-static u32* bfa_ioc_ct_fwimg_get_chunk(struct bfa_ioc_s *ioc,
-                                        u32 off);
-static u32 bfa_ioc_ct_fwimg_get_size(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
 static void bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc);
 
-struct bfa_ioc_hwif_s hwif_ct = {
-        bfa_ioc_ct_pll_init,
-        bfa_ioc_ct_firmware_lock,
-        bfa_ioc_ct_firmware_unlock,
-        bfa_ioc_ct_fwimg_get_chunk,
-        bfa_ioc_ct_fwimg_get_size,
-        bfa_ioc_ct_reg_init,
-        bfa_ioc_ct_map_port,
-        bfa_ioc_ct_isr_mode_set,
-        bfa_ioc_ct_notify_hbfail,
-        bfa_ioc_ct_ownership_reset,
-};
+struct bfa_ioc_hwif_s hwif_ct;
 
 /**
  * Called from bfa_ioc_attach() to map asic specific calls.
@@ -61,19 +47,16 @@ struct bfa_ioc_hwif_s hwif_ct = {
 void
 bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc)
 {
-        ioc->ioc_hwif = &hwif_ct;
-}
+        hwif_ct.ioc_pll_init = bfa_ioc_ct_pll_init;
+        hwif_ct.ioc_firmware_lock = bfa_ioc_ct_firmware_lock;
+        hwif_ct.ioc_firmware_unlock = bfa_ioc_ct_firmware_unlock;
+        hwif_ct.ioc_reg_init = bfa_ioc_ct_reg_init;
+        hwif_ct.ioc_map_port = bfa_ioc_ct_map_port;
+        hwif_ct.ioc_isr_mode_set = bfa_ioc_ct_isr_mode_set;
+        hwif_ct.ioc_notify_hbfail = bfa_ioc_ct_notify_hbfail;
+        hwif_ct.ioc_ownership_reset = bfa_ioc_ct_ownership_reset;
 
-static u32*
-bfa_ioc_ct_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off)
-{
-        return bfi_image_ct_get_chunk(off);
-}
-
-static u32
-bfa_ioc_ct_fwimg_get_size(struct bfa_ioc_s *ioc)
-{
-        return bfi_image_ct_size;
+        ioc->ioc_hwif = &hwif_ct;
 }
 
 /**
@@ -95,7 +78,7 @@ bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
         /**
          * If bios boot (flash based) -- do not increment usage count
          */
-        if (bfa_ioc_ct_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+        if (bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)) < BFA_IOC_FWIMG_MINSZ)
                 return BFA_TRUE;
 
         bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
@@ -146,9 +129,14 @@ bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc)
 
         /**
          * Firmware lock is relevant only for CNA.
+         */
+        if (!ioc->cna)
+                return;
+
+        /**
          * If bios boot (flash based) -- do not decrement usage count
          */
-        if (!ioc->cna || bfa_ioc_ct_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+        if (bfi_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)) < BFA_IOC_FWIMG_MINSZ)
                 return;
 
         /**
diff --git a/drivers/scsi/bfa/bfa_iocfc.c b/drivers/scsi/bfa/bfa_iocfc.c
index a76de2669bf..273ecece79a 100644
--- a/drivers/scsi/bfa/bfa_iocfc.c
+++ b/drivers/scsi/bfa/bfa_iocfc.c
@@ -170,7 +170,7 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         /**
          * Initialize chip specific handlers.
          */
-        if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT) {
+        if (bfa_asic_id_ct(bfa_ioc_devid(&bfa->ioc))) {
                 iocfc->hwif.hw_reginit = bfa_hwct_reginit;
                 iocfc->hwif.hw_reqq_ack = bfa_hwct_reqq_ack;
                 iocfc->hwif.hw_rspq_ack = bfa_hwct_rspq_ack;
@@ -625,9 +625,9 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
                 bfa->trcmod, bfa->aen, bfa->logm);
 
         /**
-         * Choose FC (ssid: 0x1C) v/s FCoE (ssid: 0x14) mode.
+         * Set FC mode for BFA_PCI_DEVICE_ID_CT_FC.
          */
-        if (0)
+        if (pcidev->device_id == BFA_PCI_DEVICE_ID_CT_FC)
                 bfa_ioc_set_fcmode(&bfa->ioc);
 
         bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_MC_IOCFC);
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index d4fc4287ebd..1b869add20b 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -1172,6 +1172,14 @@ static struct pci_device_id bfad_id_table[] = {
          .class = (PCI_CLASS_SERIAL_FIBER << 8),
          .class_mask = ~0,
          },
+        {
+         .vendor = BFA_PCI_VENDOR_ID_BROCADE,
+         .device = BFA_PCI_DEVICE_ID_CT_FC,
+         .subvendor = PCI_ANY_ID,
+         .subdevice = PCI_ANY_ID,
+         .class = (PCI_CLASS_SERIAL_FIBER << 8),
+         .class_mask = ~0,
+        },
 
         {0, 0},
 };
diff --git a/drivers/scsi/bfa/bfad_fwimg.c b/drivers/scsi/bfa/bfad_fwimg.c
index 2ad65f275a9..1baca1a1208 100644
--- a/drivers/scsi/bfa/bfad_fwimg.c
+++ b/drivers/scsi/bfa/bfad_fwimg.c
@@ -33,16 +33,20 @@
 #include <bfa_fwimg_priv.h>
 #include <bfa.h>
 
-u32 bfi_image_ct_size;
-u32 bfi_image_cb_size;
-u32 *bfi_image_ct;
-u32 *bfi_image_cb;
+u32 bfi_image_ct_fc_size;
+u32 bfi_image_ct_cna_size;
+u32 bfi_image_cb_fc_size;
+u32 *bfi_image_ct_fc;
+u32 *bfi_image_ct_cna;
+u32 *bfi_image_cb_fc;
 
 
-#define BFAD_FW_FILE_CT "ctfw.bin"
-#define BFAD_FW_FILE_CB "cbfw.bin"
-MODULE_FIRMWARE(BFAD_FW_FILE_CT);
-MODULE_FIRMWARE(BFAD_FW_FILE_CB);
+#define BFAD_FW_FILE_CT_FC      "ctfw_fc.bin"
+#define BFAD_FW_FILE_CT_CNA     "ctfw_cna.bin"
+#define BFAD_FW_FILE_CB_FC      "cbfw_fc.bin"
+MODULE_FIRMWARE(BFAD_FW_FILE_CT_FC);
+MODULE_FIRMWARE(BFAD_FW_FILE_CT_CNA);
+MODULE_FIRMWARE(BFAD_FW_FILE_CB_FC);
 
 u32 *
 bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
@@ -74,24 +78,54 @@ error:
 u32 *
 bfad_get_firmware_buf(struct pci_dev *pdev)
 {
-        if (pdev->device == BFA_PCI_DEVICE_ID_CT) {
-                if (bfi_image_ct_size == 0)
-                        bfad_read_firmware(pdev, &bfi_image_ct,
-                                &bfi_image_ct_size, BFAD_FW_FILE_CT);
-                return bfi_image_ct;
+        if (pdev->device == BFA_PCI_DEVICE_ID_CT_FC) {
+                if (bfi_image_ct_fc_size == 0)
+                        bfad_read_firmware(pdev, &bfi_image_ct_fc,
+                                &bfi_image_ct_fc_size, BFAD_FW_FILE_CT_FC);
+                return bfi_image_ct_fc;
+        } else if (pdev->device == BFA_PCI_DEVICE_ID_CT) {
+                if (bfi_image_ct_cna_size == 0)
+                        bfad_read_firmware(pdev, &bfi_image_ct_cna,
+                                &bfi_image_ct_cna_size, BFAD_FW_FILE_CT_CNA);
+                return bfi_image_ct_cna;
         } else {
-                if (bfi_image_cb_size == 0)
-                        bfad_read_firmware(pdev, &bfi_image_cb,
-                                &bfi_image_cb_size, BFAD_FW_FILE_CB);
-                return bfi_image_cb;
+                if (bfi_image_cb_fc_size == 0)
+                        bfad_read_firmware(pdev, &bfi_image_cb_fc,
+                                &bfi_image_cb_fc_size, BFAD_FW_FILE_CB_FC);
+                return bfi_image_cb_fc;
         }
 }
 
 u32 *
-bfi_image_ct_get_chunk(u32 off)
-{ return (u32 *)(bfi_image_ct + off); }
+bfi_image_ct_fc_get_chunk(u32 off)
+{ return (u32 *)(bfi_image_ct_fc + off); }
 
 u32 *
-bfi_image_cb_get_chunk(u32 off)
-{ return (u32 *)(bfi_image_cb + off); }
+bfi_image_ct_cna_get_chunk(u32 off)
+{ return (u32 *)(bfi_image_ct_cna + off); }
 
+u32 *
+bfi_image_cb_fc_get_chunk(u32 off)
+{ return (u32 *)(bfi_image_cb_fc + off); }
+
+uint32_t *
+bfi_image_get_chunk(int type, uint32_t off)
+{
+        switch (type) {
+        case BFI_IMAGE_CT_FC: return bfi_image_ct_fc_get_chunk(off); break;
+        case BFI_IMAGE_CT_CNA: return bfi_image_ct_cna_get_chunk(off); break;
+        case BFI_IMAGE_CB_FC: return bfi_image_cb_fc_get_chunk(off); break;
+        default: return 0; break;
+        }
+}
+
+uint32_t
+bfi_image_get_size(int type)
+{
+        switch (type) {
+        case BFI_IMAGE_CT_FC: return bfi_image_ct_fc_size; break;
+        case BFI_IMAGE_CT_CNA: return bfi_image_ct_cna_size; break;
+        case BFI_IMAGE_CB_FC: return bfi_image_cb_fc_size; break;
+        default: return 0; break;
+        }
+}
diff --git a/drivers/scsi/bfa/bfad_im_compat.h b/drivers/scsi/bfa/bfad_im_compat.h
index b36be15044a..0a122abbbe8 100644
--- a/drivers/scsi/bfa/bfad_im_compat.h
+++ b/drivers/scsi/bfa/bfad_im_compat.h
@@ -18,9 +18,6 @@
 #ifndef __BFAD_IM_COMPAT_H__
 #define __BFAD_IM_COMPAT_H__
 
-extern u32 *bfi_image_buf;
-extern u32 bfi_image_size;
-
 extern struct device_attribute *bfad_im_host_attrs[];
 extern struct device_attribute *bfad_im_vport_attrs[];
 
@@ -37,10 +34,12 @@ bfad_load_fwimg(struct pci_dev *pdev)
 static inline void
 bfad_free_fwimg(void)
 {
-        if (bfi_image_ct_size && bfi_image_ct)
-                vfree(bfi_image_ct);
-        if (bfi_image_cb_size && bfi_image_cb)
-                vfree(bfi_image_cb);
+        if (bfi_image_ct_fc_size && bfi_image_ct_fc)
+                vfree(bfi_image_ct_fc);
+        if (bfi_image_ct_cna_size && bfi_image_ct_cna)
+                vfree(bfi_image_ct_cna);
+        if (bfi_image_cb_fc_size && bfi_image_cb_fc)
+                vfree(bfi_image_cb_fc);
 }
 
 #endif
diff --git a/drivers/scsi/bfa/bfad_intr.c b/drivers/scsi/bfa/bfad_intr.c
index 2b7dbecbebc..fed27d16365 100644
--- a/drivers/scsi/bfa/bfad_intr.c
+++ b/drivers/scsi/bfa/bfad_intr.c
@@ -151,8 +151,8 @@ bfad_setup_intr(struct bfad_s *bfad)
         /* Set up the msix entry table */
         bfad_init_msix_entry(bfad, msix_entries, mask, max_bit);
 
-        if ((pdev->device == BFA_PCI_DEVICE_ID_CT && !msix_disable_ct) ||
-            (pdev->device != BFA_PCI_DEVICE_ID_CT && !msix_disable_cb)) {
+        if ((bfa_asic_id_ct(pdev->device) && !msix_disable_ct) ||
+                (!bfa_asic_id_ct(pdev->device) && !msix_disable_cb)) {
 
                 error = pci_enable_msix(bfad->pcidev, msix_entries, bfad->nvec);
                 if (error) {
diff --git a/drivers/scsi/bfa/include/bfi/bfi_ioc.h b/drivers/scsi/bfa/include/bfi/bfi_ioc.h
index a0158aac002..03a9c9408ca 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_ioc.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_ioc.h
@@ -63,6 +63,7 @@ struct bfi_ioc_attr_s {
         char            fw_version[BFA_VERSION_LEN];
         char            optrom_version[BFA_VERSION_LEN];
         struct bfa_mfg_vpd_s    vpd;
+        uint32_t        card_type;      /* card type */
 };
 
 /**
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h b/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
index c5bd9c36ad4..bfb50eb2124 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
@@ -86,6 +86,9 @@ enum {
         BFA_MFG_TYPE_FC4P1   = 415,      /*  4G 1port FC card           */
         BFA_MFG_TYPE_CNA10P2 = 1020,     /*  10G 2port CNA card */
         BFA_MFG_TYPE_CNA10P1 = 1010,     /*  10G 1port CNA card */
+        BFA_MFG_TYPE_JAYHAWK = 804,      /*  Jayhawk mezz card */
+        BFA_MFG_TYPE_WANCHESE = 1007,    /*  Wanchese mezz card */
+        BFA_MFG_TYPE_INVALID = 0,        /*  Invalid card type */
 };
 
 #pragma pack(1)
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_pci.h b/drivers/scsi/bfa/include/defs/bfa_defs_pci.h
index c9b83321694..ea7d89bbc0b 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_pci.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_pci.h
@@ -26,8 +26,13 @@ enum {
         BFA_PCI_DEVICE_ID_FC_8G2P       = 0x13,
         BFA_PCI_DEVICE_ID_FC_8G1P       = 0x17,
         BFA_PCI_DEVICE_ID_CT            = 0x14,
+        BFA_PCI_DEVICE_ID_CT_FC         = 0x21,
 };
 
+#define bfa_asic_id_ct(devid)                   \
+        ((devid) == BFA_PCI_DEVICE_ID_CT ||     \
+         (devid) == BFA_PCI_DEVICE_ID_CT_FC)
+
 /**
  * PCI sub-system device and vendor ID information
  */
@@ -35,7 +40,9 @@ enum {
         BFA_PCI_FCOE_SSDEVICE_ID        = 0x14,
 };
 
-#define BFA_PCI_ACCESS_RANGES 1 /* Maximum number of device address ranges
-                                 * mapped through different BAR(s). */
+/**
+ * Maximum number of device address ranges mapped through different BAR(s)
+ */
+#define BFA_PCI_ACCESS_RANGES 1
 
 #endif /* __BFA_DEFS_PCI_H__ */