Commit 293f82d5 authored by Jing Huang's avatar Jing Huang Committed by James Bottomley
Browse files

[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: default avatarJing Huang <huangj@brocade.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@suse.de>
parent 3cb5469a

drivers/scsi/bfa/bfa_core.c

+1 −0
Original line number Diff line number Diff line
@@ -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]);

drivers/scsi/bfa/bfa_fwimg_priv.h

+19 −6
Original line number Diff line number Diff line
@@ -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__ */

drivers/scsi/bfa/bfa_ioc.c

+17 −16
Original line number Diff line number Diff line
@@ -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);

}



/**

drivers/scsi/bfa/bfa_ioc.h

+4 −3
Original line number Diff line number Diff line
@@ -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)

drivers/scsi/bfa/bfa_ioc_cb.c

+10 −26
Original line number Diff line number Diff line
@@ -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;

}



/**

CRA Git | Maintained and supported by SUSTech CRA and CCSE