[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / scsi / bfa / bfa_core.c

/*
 * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
 * All rights reserved
 * www.brocade.com
 *
 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License (GPL) Version 2 as
 * published by the Free Software Foundation
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <bfa.h>
#include <defs/bfa_defs_pci.h>
#include <cs/bfa_debug.h>
#include <bfa_iocfc.h>

#define DEF_CFG_NUM_FABRICS         1
#define DEF_CFG_NUM_LPORTS          256
#define DEF_CFG_NUM_CQS             4
#define DEF_CFG_NUM_IOIM_REQS       (BFA_IOIM_MAX)
#define DEF_CFG_NUM_TSKIM_REQS      128
#define DEF_CFG_NUM_FCXP_REQS       64
#define DEF_CFG_NUM_UF_BUFS         64
#define DEF_CFG_NUM_RPORTS          1024
#define DEF_CFG_NUM_ITNIMS          (DEF_CFG_NUM_RPORTS)
#define DEF_CFG_NUM_TINS            256

#define DEF_CFG_NUM_SGPGS           2048
#define DEF_CFG_NUM_REQQ_ELEMS      256
#define DEF_CFG_NUM_RSPQ_ELEMS      64
#define DEF_CFG_NUM_SBOOT_TGTS      16
#define DEF_CFG_NUM_SBOOT_LUNS      16

/**
 * Use this function query the memory requirement of the BFA library.
 * This function needs to be called before bfa_attach() to get the
 * memory required of the BFA layer for a given driver configuration.
 *
 * This call will fail, if the cap is out of range compared to pre-defined
 * values within the BFA library
 *
 * @param[in] cfg - 	pointer to bfa_ioc_cfg_t. Driver layer should indicate
 * 			its configuration in this structure.
 *			The default values for struct bfa_iocfc_cfg_s can be
 *			fetched using bfa_cfg_get_default() API.
 *
 * 			If cap's boundary check fails, the library will use
 *			the default bfa_cap_t values (and log a warning msg).
 *
 * @param[out] meminfo - pointer to bfa_meminfo_t. This content
 * 			indicates the memory type (see bfa_mem_type_t) and
 *			amount of memory required.
 *
 *			Driver should allocate the memory, populate the
 *			starting address for each block and provide the same
 *			structure as input parameter to bfa_attach() call.
 *
 * @return void
 *
 * Special Considerations: @note
 */
void
bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s *cfg, struct bfa_meminfo_s *meminfo)
{
	int             i;
	u32        km_len = 0, dm_len = 0;

	bfa_assert((cfg != NULL) && (meminfo != NULL));

	bfa_os_memset((void *)meminfo, 0, sizeof(struct bfa_meminfo_s));
	meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_type =
		BFA_MEM_TYPE_KVA;
	meminfo->meminfo[BFA_MEM_TYPE_DMA - 1].mem_type =
		BFA_MEM_TYPE_DMA;

	bfa_iocfc_meminfo(cfg, &km_len, &dm_len);

	for (i = 0; hal_mods[i]; i++)
		hal_mods[i]->meminfo(cfg, &km_len, &dm_len);

	dm_len += bfa_port_meminfo();

	meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_len = km_len;
	meminfo->meminfo[BFA_MEM_TYPE_DMA - 1].mem_len = dm_len;
}

static void
bfa_com_port_attach(struct bfa_s *bfa, struct bfa_meminfo_s *mi)
{
	struct bfa_port_s       *port = &bfa->modules.port;
	uint32_t                dm_len;
	uint8_t                 *dm_kva;
	uint64_t                dm_pa;

	dm_len = bfa_port_meminfo();
	dm_kva = bfa_meminfo_dma_virt(mi);
	dm_pa  = bfa_meminfo_dma_phys(mi);

	memset(port, 0, sizeof(struct bfa_port_s));
	bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod, bfa->logm);
	bfa_port_mem_claim(port, dm_kva, dm_pa);

	bfa_meminfo_dma_virt(mi) = dm_kva + dm_len;
	bfa_meminfo_dma_phys(mi) = dm_pa + dm_len;
}

/**
 * Use this function to do attach the driver instance with the BFA
 * library. This function will not trigger any HW initialization
 * process (which will be done in bfa_init() call)
 *
 * This call will fail, if the cap is out of range compared to
 * pre-defined values within the BFA library
 *
 * @param[out]	bfa	Pointer to bfa_t.
 * @param[in]	bfad 	Opaque handle back to the driver's IOC structure
 * @param[in]	cfg	Pointer to bfa_ioc_cfg_t. Should be same structure
 * 			that was used in bfa_cfg_get_meminfo().
 * @param[in] 	meminfo Pointer to bfa_meminfo_t. The driver should
 * 			use the bfa_cfg_get_meminfo() call to
 * 			find the memory blocks required, allocate the
 * 			required memory and provide the starting addresses.
 * @param[in] 	pcidev	pointer to struct bfa_pcidev_s
 *
 * @return
 * void
 *
 * Special Considerations:
 *
 * @note
 *
 */
void
bfa_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
	       struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
{
	int             i;
	struct bfa_mem_elem_s *melem;

	bfa->fcs = BFA_FALSE;

	bfa_assert((cfg != NULL) && (meminfo != NULL));

	/**
	 * initialize all memory pointers for iterative allocation
	 */
	for (i = 0; i < BFA_MEM_TYPE_MAX; i++) {
		melem = meminfo->meminfo + i;
		melem->kva_curp = melem->kva;
		melem->dma_curp = melem->dma;
	}

	bfa_iocfc_attach(bfa, bfad, cfg, meminfo, pcidev);

	for (i = 0; hal_mods[i]; i++)
		hal_mods[i]->attach(bfa, bfad, cfg, meminfo, pcidev);

	bfa_com_port_attach(bfa, meminfo);
}

/**
 * Use this function to delete a BFA IOC. IOC should be stopped (by
 * calling bfa_stop()) before this function call.
 *
 * @param[in] bfa - pointer to bfa_t.
 *
 * @return
 * void
 *
 * Special Considerations:
 *
 * @note
 */
void
bfa_detach(struct bfa_s *bfa)
{
	int	i;

	for (i = 0; hal_mods[i]; i++)
		hal_mods[i]->detach(bfa);

	bfa_iocfc_detach(bfa);
}


void
bfa_init_trc(struct bfa_s *bfa, struct bfa_trc_mod_s *trcmod)
{
	bfa->trcmod = trcmod;
}


void
bfa_init_log(struct bfa_s *bfa, struct bfa_log_mod_s *logmod)
{
	bfa->logm = logmod;
}


void
bfa_init_aen(struct bfa_s *bfa, struct bfa_aen_s *aen)
{
	bfa->aen = aen;
}

void
bfa_init_plog(struct bfa_s *bfa, struct bfa_plog_s *plog)
{
	bfa->plog = plog;
}

/**
 * Initialize IOC.
 *
 * This function will return immediately, when the IOC initialization is
 * completed, the bfa_cb_init() will be called.
 *
 * @param[in]	bfa	instance
 *
 * @return void
 *
 * Special Considerations:
 *
 * @note
 * When this function returns, the driver should register the interrupt service
 * routine(s) and enable the device interrupts. If this is not done,
 * bfa_cb_init() will never get called
 */
void
bfa_init(struct bfa_s *bfa)
{
	bfa_iocfc_init(bfa);
}

/**
 * Use this function initiate the IOC configuration setup. This function
 * will return immediately.
 *
 * @param[in]	bfa	instance
 *
 * @return None
 */
void
bfa_start(struct bfa_s *bfa)
{
	bfa_iocfc_start(bfa);
}

/**
 * Use this function quiese the IOC. This function will return immediately,
 * when the IOC is actually stopped, the bfa_cb_stop() will be called.
 *
 * @param[in] 	bfa - pointer to bfa_t.
 *
 * @return None
 *
 * Special Considerations:
 * bfa_cb_stop() could be called before or after bfa_stop() returns.
 *
 * @note
 * In case of any failure, we could handle it automatically by doing a
 * reset and then succeed the bfa_stop() call.
 */
void
bfa_stop(struct bfa_s *bfa)
{
	bfa_iocfc_stop(bfa);
}

void
bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q)
{
	INIT_LIST_HEAD(comp_q);
	list_splice_tail_init(&bfa->comp_q, comp_q);
}

void
bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q)
{
	struct list_head        *qe;
	struct list_head        *qen;
	struct bfa_cb_qe_s   *hcb_qe;

	list_for_each_safe(qe, qen, comp_q) {
		hcb_qe = (struct bfa_cb_qe_s *) qe;
		hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE);
	}
}

void
bfa_comp_free(struct bfa_s *bfa, struct list_head *comp_q)
{
	struct list_head        *qe;
	struct bfa_cb_qe_s   *hcb_qe;

	while (!list_empty(comp_q)) {
		bfa_q_deq(comp_q, &qe);
		hcb_qe = (struct bfa_cb_qe_s *) qe;
		hcb_qe->cbfn(hcb_qe->cbarg, BFA_FALSE);
	}
}

void
bfa_attach_fcs(struct bfa_s *bfa)
{
	bfa->fcs = BFA_TRUE;
}

/**
 * Periodic timer heart beat from driver
 */
void
bfa_timer_tick(struct bfa_s *bfa)
{
	bfa_timer_beat(&bfa->timer_mod);
}

#ifndef BFA_BIOS_BUILD
/**
 * Return the list of PCI vendor/device id lists supported by this
 * BFA instance.
 */
void
bfa_get_pciids(struct bfa_pciid_s **pciids, int *npciids)
{
	static struct bfa_pciid_s __pciids[] = {
		{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 = ARRAY_SIZE(__pciids);
	*pciids = __pciids;
}

/**
 * Use this function query the default struct bfa_iocfc_cfg_s value (compiled
 * into BFA layer). The OS driver can then turn back and overwrite entries that
 * have been configured by the user.
 *
 * @param[in] cfg - pointer to bfa_ioc_cfg_t
 *
 * @return
 *	void
 *
 * Special Considerations:
 * 	note
 */
void
bfa_cfg_get_default(struct bfa_iocfc_cfg_s *cfg)
{
	cfg->fwcfg.num_fabrics = DEF_CFG_NUM_FABRICS;
	cfg->fwcfg.num_lports = DEF_CFG_NUM_LPORTS;
	cfg->fwcfg.num_rports = DEF_CFG_NUM_RPORTS;
	cfg->fwcfg.num_ioim_reqs = DEF_CFG_NUM_IOIM_REQS;
	cfg->fwcfg.num_tskim_reqs = DEF_CFG_NUM_TSKIM_REQS;
	cfg->fwcfg.num_fcxp_reqs = DEF_CFG_NUM_FCXP_REQS;
	cfg->fwcfg.num_uf_bufs = DEF_CFG_NUM_UF_BUFS;
	cfg->fwcfg.num_cqs = DEF_CFG_NUM_CQS;

	cfg->drvcfg.num_reqq_elems = DEF_CFG_NUM_REQQ_ELEMS;
	cfg->drvcfg.num_rspq_elems = DEF_CFG_NUM_RSPQ_ELEMS;
	cfg->drvcfg.num_sgpgs = DEF_CFG_NUM_SGPGS;
	cfg->drvcfg.num_sboot_tgts = DEF_CFG_NUM_SBOOT_TGTS;
	cfg->drvcfg.num_sboot_luns = DEF_CFG_NUM_SBOOT_LUNS;
	cfg->drvcfg.path_tov = BFA_FCPIM_PATHTOV_DEF;
	cfg->drvcfg.ioc_recover = BFA_FALSE;
	cfg->drvcfg.delay_comp = BFA_FALSE;

}

void
bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg)
{
	bfa_cfg_get_default(cfg);
	cfg->fwcfg.num_ioim_reqs   = BFA_IOIM_MIN;
	cfg->fwcfg.num_tskim_reqs  = BFA_TSKIM_MIN;
	cfg->fwcfg.num_fcxp_reqs   = BFA_FCXP_MIN;
	cfg->fwcfg.num_uf_bufs     = BFA_UF_MIN;
	cfg->fwcfg.num_rports      = BFA_RPORT_MIN;

	cfg->drvcfg.num_sgpgs      = BFA_SGPG_MIN;
	cfg->drvcfg.num_reqq_elems = BFA_REQQ_NELEMS_MIN;
	cfg->drvcfg.num_rspq_elems = BFA_RSPQ_NELEMS_MIN;
	cfg->drvcfg.min_cfg        = BFA_TRUE;
}

void
bfa_get_attr(struct bfa_s *bfa, struct bfa_ioc_attr_s *ioc_attr)
{
	bfa_ioc_get_attr(&bfa->ioc, ioc_attr);
}

/**
 * Retrieve firmware trace information on IOC failure.
 */
bfa_status_t
bfa_debug_fwsave(struct bfa_s *bfa, void *trcdata, int *trclen)
{
	return bfa_ioc_debug_fwsave(&bfa->ioc, trcdata, trclen);
}

/**
 * Clear the saved firmware trace information of an IOC.
 */
void
bfa_debug_fwsave_clear(struct bfa_s *bfa)
{
	bfa_ioc_debug_fwsave_clear(&bfa->ioc);
}

/**
 * 		Fetch firmware trace data.
 *
 * @param[in]		bfa			BFA instance
 * @param[out]		trcdata		Firmware trace buffer
 * @param[in,out]	trclen		Firmware trace buffer len
 *
 * @retval BFA_STATUS_OK			Firmware trace is fetched.
 * @retval BFA_STATUS_INPROGRESS	Firmware trace fetch is in progress.
 */
bfa_status_t
bfa_debug_fwtrc(struct bfa_s *bfa, void *trcdata, int *trclen)
{
	return bfa_ioc_debug_fwtrc(&bfa->ioc, trcdata, trclen);
}

/**
 * Reset hw semaphore & usage cnt regs and initialize.
 */
void
bfa_chip_reset(struct bfa_s *bfa)
{
	bfa_ioc_ownership_reset(&bfa->ioc);
	bfa_ioc_pll_init(&bfa->ioc);
}
#endif
Commit	Line	Data
7725ccfd JH	1	/*
	2	* Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
	3	* All rights reserved
	4	* www.brocade.com
	5	*
	6	* Linux driver for Brocade Fibre Channel Host Bus Adapter.
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License (GPL) Version 2 as
	10	* published by the Free Software Foundation
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*/
	17
	18	#include <bfa.h>
	19	#include <defs/bfa_defs_pci.h>
	20	#include <cs/bfa_debug.h>
	21	#include <bfa_iocfc.h>
	22
	23	#define DEF_CFG_NUM_FABRICS 1
	24	#define DEF_CFG_NUM_LPORTS 256
	25	#define DEF_CFG_NUM_CQS 4
	26	#define DEF_CFG_NUM_IOIM_REQS (BFA_IOIM_MAX)
	27	#define DEF_CFG_NUM_TSKIM_REQS 128
	28	#define DEF_CFG_NUM_FCXP_REQS 64
	29	#define DEF_CFG_NUM_UF_BUFS 64
	30	#define DEF_CFG_NUM_RPORTS 1024
	31	#define DEF_CFG_NUM_ITNIMS (DEF_CFG_NUM_RPORTS)
	32	#define DEF_CFG_NUM_TINS 256
	33
	34	#define DEF_CFG_NUM_SGPGS 2048
	35	#define DEF_CFG_NUM_REQQ_ELEMS 256
	36	#define DEF_CFG_NUM_RSPQ_ELEMS 64
	37	#define DEF_CFG_NUM_SBOOT_TGTS 16
	38	#define DEF_CFG_NUM_SBOOT_LUNS 16
	39
	40	/**
	41	* Use this function query the memory requirement of the BFA library.
	42	* This function needs to be called before bfa_attach() to get the
	43	* memory required of the BFA layer for a given driver configuration.
	44	*
	45	* This call will fail, if the cap is out of range compared to pre-defined
	46	* values within the BFA library
	47	*
	48	* @param[in] cfg - pointer to bfa_ioc_cfg_t. Driver layer should indicate
	49	* its configuration in this structure.
	50	* The default values for struct bfa_iocfc_cfg_s can be
	51	* fetched using bfa_cfg_get_default() API.
	52	*
	53	* If cap's boundary check fails, the library will use
	54	* the default bfa_cap_t values (and log a warning msg).
	55	*
	56	* @param[out] meminfo - pointer to bfa_meminfo_t. This content
	57	* indicates the memory type (see bfa_mem_type_t) and
	58	* amount of memory required.
	59	*
	60	* Driver should allocate the memory, populate the
	61	* starting address for each block and provide the same
	62	* structure as input parameter to bfa_attach() call.
	63	*
	64	* @return void
65	*
66	* Special Considerations: @note
67	*/
68	void
69	bfa_cfg_get_meminfo(struct bfa_iocfc_cfg_s cfg, struct bfa_meminfo_s meminfo)
70	{
71	int i;
72	u32 km_len = 0, dm_len = 0;
73
74	bfa_assert((cfg != NULL) && (meminfo != NULL));
75
76	bfa_os_memset((void *)meminfo, 0, sizeof(struct bfa_meminfo_s));
77	meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_type =
78	BFA_MEM_TYPE_KVA;
79	meminfo->meminfo[BFA_MEM_TYPE_DMA - 1].mem_type =
80	BFA_MEM_TYPE_DMA;
81
82	bfa_iocfc_meminfo(cfg, &km_len, &dm_len);
83
84	for (i = 0; hal_mods[i]; i++)
85	hal_mods[i]->meminfo(cfg, &km_len, &dm_len);
86
7873ca4e	87	dm_len += bfa_port_meminfo();
7725ccfd JH	88
	89	meminfo->meminfo[BFA_MEM_TYPE_KVA - 1].mem_len = km_len;
	90	meminfo->meminfo[BFA_MEM_TYPE_DMA - 1].mem_len = dm_len;
	91	}
	92
7873ca4e KG	93	static void
	94	bfa_com_port_attach(struct bfa_s bfa, struct bfa_meminfo_s mi)
	95	{
	96	struct bfa_port_s *port = &bfa->modules.port;
	97	uint32_t dm_len;
	98	uint8_t *dm_kva;
	99	uint64_t dm_pa;
	100
	101	dm_len = bfa_port_meminfo();
	102	dm_kva = bfa_meminfo_dma_virt(mi);
	103	dm_pa = bfa_meminfo_dma_phys(mi);
	104
	105	memset(port, 0, sizeof(struct bfa_port_s));
	106	bfa_port_attach(port, &bfa->ioc, bfa, bfa->trcmod, bfa->logm);
	107	bfa_port_mem_claim(port, dm_kva, dm_pa);
	108
	109	bfa_meminfo_dma_virt(mi) = dm_kva + dm_len;
	110	bfa_meminfo_dma_phys(mi) = dm_pa + dm_len;
	111	}
	112
7725ccfd JH	113	/**
	114	* Use this function to do attach the driver instance with the BFA
	115	* library. This function will not trigger any HW initialization
	116	* process (which will be done in bfa_init() call)
	117	*
	118	* This call will fail, if the cap is out of range compared to
	119	* pre-defined values within the BFA library
	120	*
	121	* @param[out] bfa Pointer to bfa_t.
	122	* @param[in] bfad Opaque handle back to the driver's IOC structure
	123	* @param[in] cfg Pointer to bfa_ioc_cfg_t. Should be same structure
	124	* that was used in bfa_cfg_get_meminfo().
	125	* @param[in] meminfo Pointer to bfa_meminfo_t. The driver should
	126	* use the bfa_cfg_get_meminfo() call to
	127	* find the memory blocks required, allocate the
	128	* required memory and provide the starting addresses.
	129	* @param[in] pcidev pointer to struct bfa_pcidev_s
	130	*
	131	* @return
	132	* void
	133	*
	134	* Special Considerations:
	135	*
	136	* @note
	137	*
	138	*/
	139	void
	140	bfa_attach(struct bfa_s bfa, void bfad, struct bfa_iocfc_cfg_s *cfg,
	141	struct bfa_meminfo_s meminfo, struct bfa_pcidev_s pcidev)
	142	{
	143	int i;
	144	struct bfa_mem_elem_s *melem;
	145
	146	bfa->fcs = BFA_FALSE;
	147
	148	bfa_assert((cfg != NULL) && (meminfo != NULL));
	149
	150	/**
	151	* initialize all memory pointers for iterative allocation
	152	*/
	153	for (i = 0; i < BFA_MEM_TYPE_MAX; i++) {
	154	melem = meminfo->meminfo + i;
	155	melem->kva_curp = melem->kva;
	156	melem->dma_curp = melem->dma;
	157	}
	158
	159	bfa_iocfc_attach(bfa, bfad, cfg, meminfo, pcidev);
	160
	161	for (i = 0; hal_mods[i]; i++)
	162	hal_mods[i]->attach(bfa, bfad, cfg, meminfo, pcidev);
	163
7873ca4e	164	bfa_com_port_attach(bfa, meminfo);
7725ccfd JH	165	}
	166
	167	/**
	168	* Use this function to delete a BFA IOC. IOC should be stopped (by
	169	* calling bfa_stop()) before this function call.
	170	*
	171	* @param[in] bfa - pointer to bfa_t.
	172	*
	173	* @return
	174	* void
	175	*
	176	* Special Considerations:
	177	*
	178	* @note
	179	*/
	180	void
	181	bfa_detach(struct bfa_s *bfa)
	182	{
	183	int i;
	184
	185	for (i = 0; hal_mods[i]; i++)
	186	hal_mods[i]->detach(bfa);
	187
	188	bfa_iocfc_detach(bfa);
	189	}
	190
	191
	192	void
	193	bfa_init_trc(struct bfa_s bfa, struct bfa_trc_mod_s trcmod)
	194	{
	195	bfa->trcmod = trcmod;
	196	}
	197
	198
	199	void
	200	bfa_init_log(struct bfa_s bfa, struct bfa_log_mod_s logmod)
	201	{
	202	bfa->logm = logmod;
	203	}
	204
	205
	206	void
	207	bfa_init_aen(struct bfa_s bfa, struct bfa_aen_s aen)
	208	{
	209	bfa->aen = aen;
	210	}
	211
	212	void
	213	bfa_init_plog(struct bfa_s bfa, struct bfa_plog_s plog)
	214	{
	215	bfa->plog = plog;
	216	}
	217
	218	/**
	219	* Initialize IOC.
	220	*
	221	* This function will return immediately, when the IOC initialization is
	222	* completed, the bfa_cb_init() will be called.
	223	*
	224	* @param[in] bfa instance
	225	*
	226	* @return void
	227	*
	228	* Special Considerations:
229	*
230	* @note
231	* When this function returns, the driver should register the interrupt service
232	* routine(s) and enable the device interrupts. If this is not done,
233	* bfa_cb_init() will never get called
234	*/
235	void
236	bfa_init(struct bfa_s *bfa)
237	{
238	bfa_iocfc_init(bfa);
239	}
240
241	/**
242	* Use this function initiate the IOC configuration setup. This function
243	* will return immediately.
244	*
245	* @param[in] bfa instance
246	*
247	* @return None
248	*/
249	void
250	bfa_start(struct bfa_s *bfa)
251	{
252	bfa_iocfc_start(bfa);
253	}
254
255	/**
256	* Use this function quiese the IOC. This function will return immediately,
257	* when the IOC is actually stopped, the bfa_cb_stop() will be called.
258	*
259	* @param[in] bfa - pointer to bfa_t.
260	*
261	* @return None
262	*
263	* Special Considerations:
264	* bfa_cb_stop() could be called before or after bfa_stop() returns.
265	*
266	* @note
267	* In case of any failure, we could handle it automatically by doing a
268	* reset and then succeed the bfa_stop() call.
269	*/
270	void
271	bfa_stop(struct bfa_s *bfa)
272	{
273	bfa_iocfc_stop(bfa);
274	}
275
276	void
277	bfa_comp_deq(struct bfa_s bfa, struct list_head comp_q)
278	{
279	INIT_LIST_HEAD(comp_q);
280	list_splice_tail_init(&bfa->comp_q, comp_q);
281	}
282
283	void
284	bfa_comp_process(struct bfa_s bfa, struct list_head comp_q)
285	{
286	struct list_head *qe;
287	struct list_head *qen;
288	struct bfa_cb_qe_s *hcb_qe;
289
290	list_for_each_safe(qe, qen, comp_q) {
291	hcb_qe = (struct bfa_cb_qe_s *) qe;
292	hcb_qe->cbfn(hcb_qe->cbarg, BFA_TRUE);
293	}
294	}
295
296	void
297	bfa_comp_free(struct bfa_s bfa, struct list_head comp_q)
298	{
299	struct list_head *qe;
300	struct bfa_cb_qe_s *hcb_qe;
301
302	while (!list_empty(comp_q)) {
303	bfa_q_deq(comp_q, &qe);
304	hcb_qe = (struct bfa_cb_qe_s *) qe;
305	hcb_qe->cbfn(hcb_qe->cbarg, BFA_FALSE);
306	}
307	}
308
309	void
310	bfa_attach_fcs(struct bfa_s *bfa)
311	{
312	bfa->fcs = BFA_TRUE;
313	}
314
315	/**
316	* Periodic timer heart beat from driver
317	*/
318	void
319	bfa_timer_tick(struct bfa_s *bfa)
320	{
321	bfa_timer_beat(&bfa->timer_mod);
322	}
323
324	#ifndef BFA_BIOS_BUILD
325	/**
326	* Return the list of PCI vendor/device id lists supported by this
327	* BFA instance.
328	*/
329	void
330	bfa_get_pciids(struct bfa_pciid_s *pciids, int npciids)
331	{
332	static struct bfa_pciid_s __pciids[] = {
333	{BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G2P},
334	{BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_FC_8G1P},
335	{BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT},
293f82d5	336	{BFA_PCI_VENDOR_ID_BROCADE, BFA_PCI_DEVICE_ID_CT_FC},
7725ccfd JH	337	};
7725ccfd JH	338
501af8d1	339	*npciids = ARRAY_SIZE(__pciids);
7725ccfd JH	340	*pciids = __pciids;
	341	}
	342
	343	/**
	344	* Use this function query the default struct bfa_iocfc_cfg_s value (compiled
	345	* into BFA layer). The OS driver can then turn back and overwrite entries that
	346	* have been configured by the user.
	347	*
	348	* @param[in] cfg - pointer to bfa_ioc_cfg_t
	349	*
	350	* @return
	351	* void
	352	*
	353	* Special Considerations:
	354	* note
	355	*/
	356	void
	357	bfa_cfg_get_default(struct bfa_iocfc_cfg_s *cfg)
	358	{
	359	cfg->fwcfg.num_fabrics = DEF_CFG_NUM_FABRICS;
	360	cfg->fwcfg.num_lports = DEF_CFG_NUM_LPORTS;
	361	cfg->fwcfg.num_rports = DEF_CFG_NUM_RPORTS;
	362	cfg->fwcfg.num_ioim_reqs = DEF_CFG_NUM_IOIM_REQS;
	363	cfg->fwcfg.num_tskim_reqs = DEF_CFG_NUM_TSKIM_REQS;
	364	cfg->fwcfg.num_fcxp_reqs = DEF_CFG_NUM_FCXP_REQS;
	365	cfg->fwcfg.num_uf_bufs = DEF_CFG_NUM_UF_BUFS;
	366	cfg->fwcfg.num_cqs = DEF_CFG_NUM_CQS;
	367
	368	cfg->drvcfg.num_reqq_elems = DEF_CFG_NUM_REQQ_ELEMS;
	369	cfg->drvcfg.num_rspq_elems = DEF_CFG_NUM_RSPQ_ELEMS;
	370	cfg->drvcfg.num_sgpgs = DEF_CFG_NUM_SGPGS;
	371	cfg->drvcfg.num_sboot_tgts = DEF_CFG_NUM_SBOOT_TGTS;
	372	cfg->drvcfg.num_sboot_luns = DEF_CFG_NUM_SBOOT_LUNS;
	373	cfg->drvcfg.path_tov = BFA_FCPIM_PATHTOV_DEF;
	374	cfg->drvcfg.ioc_recover = BFA_FALSE;
	375	cfg->drvcfg.delay_comp = BFA_FALSE;
	376
	377	}
	378
	379	void
	380	bfa_cfg_get_min(struct bfa_iocfc_cfg_s *cfg)
	381	{
	382	bfa_cfg_get_default(cfg);
	383	cfg->fwcfg.num_ioim_reqs = BFA_IOIM_MIN;
	384	cfg->fwcfg.num_tskim_reqs = BFA_TSKIM_MIN;
	385	cfg->fwcfg.num_fcxp_reqs = BFA_FCXP_MIN;
	386	cfg->fwcfg.num_uf_bufs = BFA_UF_MIN;
	387	cfg->fwcfg.num_rports = BFA_RPORT_MIN;
	388
	389	cfg->drvcfg.num_sgpgs = BFA_SGPG_MIN;
	390	cfg->drvcfg.num_reqq_elems = BFA_REQQ_NELEMS_MIN;
	391	cfg->drvcfg.num_rspq_elems = BFA_RSPQ_NELEMS_MIN;
	392	cfg->drvcfg.min_cfg = BFA_TRUE;
	393	}
	394
	395	void
	396	bfa_get_attr(struct bfa_s bfa, struct bfa_ioc_attr_s ioc_attr)
	397	{
	398	bfa_ioc_get_attr(&bfa->ioc, ioc_attr);
	399	}
	400
	401	/**
	402	* Retrieve firmware trace information on IOC failure.
	403	*/
404	bfa_status_t
405	bfa_debug_fwsave(struct bfa_s bfa, void trcdata, int *trclen)
406	{
407	return bfa_ioc_debug_fwsave(&bfa->ioc, trcdata, trclen);
408	}
409
738c9e66 KG	410	/**
	411	* Clear the saved firmware trace information of an IOC.
	412	*/
	413	void
	414	bfa_debug_fwsave_clear(struct bfa_s *bfa)
	415	{
	416	bfa_ioc_debug_fwsave_clear(&bfa->ioc);
	417	}
	418
7725ccfd JH	419	/**
	420	* Fetch firmware trace data.
	421	*
	422	* @param[in] bfa BFA instance
	423	* @param[out] trcdata Firmware trace buffer
	424	* @param[in,out] trclen Firmware trace buffer len
	425	*
	426	* @retval BFA_STATUS_OK Firmware trace is fetched.
	427	* @retval BFA_STATUS_INPROGRESS Firmware trace fetch is in progress.
	428	*/
	429	bfa_status_t
	430	bfa_debug_fwtrc(struct bfa_s bfa, void trcdata, int *trclen)
	431	{
	432	return bfa_ioc_debug_fwtrc(&bfa->ioc, trcdata, trclen);
	433	}
0a20de44 KG	434
	435	/**
	436	* Reset hw semaphore & usage cnt regs and initialize.
	437	*/
	438	void
	439	bfa_chip_reset(struct bfa_s *bfa)
	440	{
	441	bfa_ioc_ownership_reset(&bfa->ioc);
	442	bfa_ioc_pll_init(&bfa->ioc);
	443	}
7725ccfd	444	#endif