adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 19:26:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

[SCSI] bfa: fixed checkpatch errors for bfad files

Browse source 
This patch fixes checkpatch errors/warnings in bfad files.

Signed-off-by: Jing Huang <huangj@brocade.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
This commit is contained in:
Jing Huang 2009-09-25 12:29:54 -07:00 committed by James Bottomley
parent 8798a694da
commit f8ceafde6f
53 changed files with 323 additions and 538 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
drivers/scsi/bfa/bfa_cb_ioim_macros.h
View file

@ -51,7 +51,7 @@ bfad_int_to_lun(u32 luno)
lun.bfa_lun = 0;
lun.scsi_lun[0] = bfa_os_htons(luno);
return (lun.bfa_lun);
return lun.bfa_lun;
}
/**
@ -68,7 +68,7 @@ bfa_cb_ioim_get_cdb(struct bfad_ioim_s *dio)
{
struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
return ((u8 *) cmnd->cmnd);
return (u8 *) cmnd->cmnd;
}
/**
@ -97,7 +97,7 @@ bfa_cb_ioim_get_size(struct bfad_ioim_s *dio)
{
struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
return (scsi_bufflen(cmnd));
return scsi_bufflen(cmnd);
}
/**
@ -129,7 +129,7 @@ bfa_cb_ioim_get_sgaddr(struct bfad_ioim_s *dio, int sgeid)
sge = (struct scatterlist *)scsi_sglist(cmnd) + sgeid;
addr = (u64) sg_dma_address(sge);
return (*(union bfi_addr_u *) &addr);
return *((union bfi_addr_u *) &addr);
}
static inline u32
@ -197,7 +197,7 @@ bfa_cb_ioim_get_cdblen(struct bfad_ioim_s *dio)
{
struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
return (cmnd->cmd_len);
return cmnd->cmd_len;
}

2
drivers/scsi/bfa/bfa_cee.c
View file

@ -228,7 +228,7 @@ bfa_cee_reset_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
u32
bfa_cee_meminfo(void)
{
return (bfa_cee_attr_meminfo() + bfa_cee_stats_meminfo());
return bfa_cee_attr_meminfo() + bfa_cee_stats_meminfo();
}
/**

4
drivers/scsi/bfa/bfa_csdebug.c
View file

@ -47,12 +47,12 @@ bfa_q_is_on_q_func(struct list_head *q, struct list_head *qe)
tqe = bfa_q_next(q);
while (tqe != q) {
if (tqe == qe)
return (1);
return 1;
tqe = bfa_q_next(tqe);
if (tqe == NULL)
break;
}
return (0);
return 0;
}

4
drivers/scsi/bfa/bfa_fcpim.c
View file

@ -131,7 +131,7 @@ bfa_fcpim_path_tov_get(struct bfa_s *bfa)
{
struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
return (fcpim->path_tov / 1000);
return fcpim->path_tov / 1000;
}
bfa_status_t
@ -169,7 +169,7 @@ bfa_fcpim_qdepth_get(struct bfa_s *bfa)
{
struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
return (fcpim->q_depth);
return fcpim->q_depth;
}

4
drivers/scsi/bfa/bfa_fcpim_priv.h
View file

@ -35,7 +35,7 @@
#define BFA_FCPIM_PATHTOV_MAX (90 * 1000) /* in millisecs */
#define bfa_fcpim_stats(__fcpim, __stats) \
(__fcpim)->stats.__stats ++
((__fcpim)->stats.__stats++)
struct bfa_fcpim_mod_s {
struct bfa_s *bfa;
@ -143,7 +143,7 @@ struct bfa_itnim_s {
struct bfa_itnim_hal_stats_s stats;
};
#define bfa_itnim_is_online(_itnim) (_itnim)->is_online
#define bfa_itnim_is_online(_itnim) ((_itnim)->is_online)
#define BFA_FCPIM_MOD(_hal) (&(_hal)->modules.fcpim_mod)
#define BFA_IOIM_FROM_TAG(_fcpim, _iotag) \
(&fcpim->ioim_arr[_iotag])

59
drivers/scsi/bfa/bfa_fcport.c
View file

@ -388,32 +388,29 @@ bfa_pport_sm_linkup(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
if (BFA_PORT_IS_DISABLED(pport->bfa)) {
if (BFA_PORT_IS_DISABLED(pport->bfa))
bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
} else {
else
bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
}
break;
case BFA_PPORT_SM_STOP:
bfa_sm_set_state(pport, bfa_pport_sm_stopped);
bfa_pport_reset_linkinfo(pport);
if (BFA_PORT_IS_DISABLED(pport->bfa)) {
if (BFA_PORT_IS_DISABLED(pport->bfa))
bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
} else {
else
bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
}
break;
case BFA_PPORT_SM_HWFAIL:
bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
bfa_pport_reset_linkinfo(pport);
bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
if (BFA_PORT_IS_DISABLED(pport->bfa)) {
if (BFA_PORT_IS_DISABLED(pport->bfa))
bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
} else {
else
bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
}
break;
default:
@ -999,10 +996,10 @@ bfa_pport_enable(struct bfa_s *bfa)
struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
if (pport->diag_busy)
return (BFA_STATUS_DIAG_BUSY);
return BFA_STATUS_DIAG_BUSY;
else if (bfa_sm_cmp_state
(BFA_PORT_MOD(bfa), bfa_pport_sm_disabling_qwait))
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_ENABLE);
return BFA_STATUS_OK;
@ -1032,7 +1029,7 @@ bfa_pport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
pport->cfg.speed = speed;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
/**
@ -1068,7 +1065,7 @@ bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
}
pport->cfg.topology = topology;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
/**
@ -1094,7 +1091,7 @@ bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
pport->cfg.cfg_hardalpa = BFA_TRUE;
pport->cfg.hardalpa = alpa;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_status_t
@ -1106,7 +1103,7 @@ bfa_pport_clr_hardalpa(struct bfa_s *bfa)
bfa_trc(bfa, pport->cfg.hardalpa);
pport->cfg.cfg_hardalpa = BFA_FALSE;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_boolean_t
@ -1138,16 +1135,16 @@ bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
* with in range
*/
if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
return (BFA_STATUS_INVLD_DFSZ);
return BFA_STATUS_INVLD_DFSZ;
/*
* power of 2, if not the max frame size of 2112
*/
if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
return (BFA_STATUS_INVLD_DFSZ);
return BFA_STATUS_INVLD_DFSZ;
pport->cfg.maxfrsize = maxfrsize;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
u16
@ -1415,7 +1412,7 @@ bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
if (port->stats_busy) {
bfa_trc(bfa, port->stats_busy);
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
}
port->stats_busy = BFA_TRUE;
@ -1427,7 +1424,7 @@ bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
bfa_timer_start(bfa, &port->timer, bfa_port_stats_timeout, port,
BFA_PORT_STATS_TOV);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_status_t
@ -1437,7 +1434,7 @@ bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
if (port->stats_busy) {
bfa_trc(bfa, port->stats_busy);
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
}
port->stats_busy = BFA_TRUE;
@ -1448,7 +1445,7 @@ bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
BFA_PORT_STATS_TOV);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_status_t
@ -1515,7 +1512,7 @@ bfa_pport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
/*
* QoS stats is embedded in port stats
*/
return (bfa_pport_get_stats(bfa, stats, cbfn, cbarg));
return bfa_pport_get_stats(bfa, stats, cbfn, cbarg);
}
bfa_status_t
@ -1525,7 +1522,7 @@ bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
if (port->stats_busy) {
bfa_trc(bfa, port->stats_busy);
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
}
port->stats_busy = BFA_TRUE;
@ -1536,7 +1533,7 @@ bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
BFA_PORT_STATS_TOV);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
/**
@ -1545,7 +1542,7 @@ bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
bfa_status_t
bfa_pport_trunk_disable(struct bfa_s *bfa)
{
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_boolean_t
@ -1562,8 +1559,8 @@ bfa_pport_is_disabled(struct bfa_s *bfa)
{
struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
return (bfa_sm_to_state(hal_pport_sm_table, port->sm) ==
BFA_PPORT_ST_DISABLED);
return bfa_sm_to_state(hal_pport_sm_table, port->sm) ==
BFA_PPORT_ST_DISABLED;
}
@ -1572,7 +1569,7 @@ bfa_pport_is_ratelim(struct bfa_s *bfa)
{
struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
return (pport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE);
return pport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
}
@ -1620,7 +1617,7 @@ bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
pport->cfg.trl_def_speed = speed;
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
/**
@ -1632,7 +1629,7 @@ bfa_pport_get_ratelim_speed(struct bfa_s *bfa)
struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
bfa_trc(bfa, pport->cfg.trl_def_speed);
return (pport->cfg.trl_def_speed);
return pport->cfg.trl_def_speed;
}

11
drivers/scsi/bfa/bfa_fcs_lport.c
View file

@ -568,11 +568,10 @@ bfa_fcs_port_offline_actions(struct bfa_fcs_port_s *port)
__port_action[port->fabric->fab_type].offline(port);
if (bfa_fcs_fabric_is_online(port->fabric) == BFA_TRUE) {
if (bfa_fcs_fabric_is_online(port->fabric) == BFA_TRUE)
bfa_fcs_port_aen_post(port, BFA_LPORT_AEN_DISCONNECT);
} else {
else
bfa_fcs_port_aen_post(port, BFA_LPORT_AEN_OFFLINE);
}
bfa_fcb_port_offline(port->fcs->bfad, port->port_cfg.roles,
port->fabric->vf_drv,
(port->vport == NULL) ? NULL : port->vport->vport_drv);
@ -777,7 +776,7 @@ bfa_fcs_port_get_rport_by_pwwn(struct bfa_fcs_port_s *port, wwn_t pwwn)
}
bfa_trc(port->fcs, pwwn);
return (NULL);
return NULL;
}
/**
@ -796,7 +795,7 @@ bfa_fcs_port_get_rport_by_nwwn(struct bfa_fcs_port_s *port, wwn_t nwwn)
}
bfa_trc(port->fcs, nwwn);
return (NULL);
return NULL;
}
/**
@ -870,7 +869,7 @@ bfa_fcs_port_lip(struct bfa_fcs_port_s *port)
bfa_boolean_t
bfa_fcs_port_is_online(struct bfa_fcs_port_s *port)
{
return (bfa_sm_cmp_state(port, bfa_fcs_port_sm_online));
return bfa_sm_cmp_state(port, bfa_fcs_port_sm_online);
}
/**

8
drivers/scsi/bfa/bfa_fcxp.c
View file

@ -199,7 +199,7 @@ bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
if (fcxp)
list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
return (fcxp);
return fcxp;
}
static void
@ -503,7 +503,7 @@ bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
if (fcxp == NULL)
return (NULL);
return NULL;
bfa_trc(bfa, fcxp->fcxp_tag);
@ -568,7 +568,7 @@ bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
}
}
return (fcxp);
return fcxp;
}
/**
@ -709,7 +709,7 @@ bfa_status_t
bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
{
bfa_assert(0);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
void

2
drivers/scsi/bfa/bfa_intr.c
View file

@ -59,7 +59,7 @@ bfa_intx(struct bfa_s *bfa)
qintr = intr & __HFN_INT_RME_MASK;
bfa_reg_write(bfa->iocfc.bfa_regs.intr_status, qintr);
for (queue = 0; queue < BFI_IOC_MAX_CQS_ASIC; queue ++) {
for (queue = 0; queue < BFI_IOC_MAX_CQS_ASIC; queue++) {
if (intr & (__HFN_INT_RME_Q0 << queue))
bfa_msix_rspq(bfa, queue & (BFI_IOC_MAX_CQS - 1));
}

18
drivers/scsi/bfa/bfa_intr_priv.h
View file

@ -26,9 +26,9 @@ void bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m);
void bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func);
#define bfa_reqq_pi(__bfa, __reqq) (__bfa)->iocfc.req_cq_pi[__reqq]
#define bfa_reqq_pi(__bfa, __reqq) ((__bfa)->iocfc.req_cq_pi[__reqq])
#define bfa_reqq_ci(__bfa, __reqq) \
*(u32 *)((__bfa)->iocfc.req_cq_shadow_ci[__reqq].kva)
(*(u32 *)((__bfa)->iocfc.req_cq_shadow_ci[__reqq].kva))
#define bfa_reqq_full(__bfa, __reqq) \
(((bfa_reqq_pi(__bfa, __reqq) + 1) & \
@ -50,14 +50,16 @@ void bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func);
} while (0)
#define bfa_rspq_pi(__bfa, __rspq) \
*(u32 *)((__bfa)->iocfc.rsp_cq_shadow_pi[__rspq].kva)
(*(u32 *)((__bfa)->iocfc.rsp_cq_shadow_pi[__rspq].kva))
#define bfa_rspq_ci(__bfa, __rspq) (__bfa)->iocfc.rsp_cq_ci[__rspq]
#define bfa_rspq_ci(__bfa, __rspq) ((__bfa)->iocfc.rsp_cq_ci[__rspq])
#define bfa_rspq_elem(__bfa, __rspq, __ci) \
&((struct bfi_msg_s *)((__bfa)->iocfc.rsp_cq_ba[__rspq].kva))[__ci]
(&((struct bfi_msg_s *)((__bfa)->iocfc.rsp_cq_ba[__rspq].kva))[__ci])
#define CQ_INCR(__index, __size) \
(__index)++; (__index) &= ((__size) - 1)
#define CQ_INCR(__index, __size) do { \
(__index)++; \
(__index) &= ((__size) - 1); \
} while (0)
/**
* Queue element to wait for room in request queue. FIFO order is
@ -94,7 +96,7 @@ bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
wqe->cbarg = cbarg;
}
#define bfa_reqq(__bfa, __reqq) &(__bfa)->reqq_waitq[__reqq]
#define bfa_reqq(__bfa, __reqq) (&(__bfa)->reqq_waitq[__reqq])
/**
* static inline void

10
drivers/scsi/bfa/bfa_ioc.c
View file

@ -51,7 +51,7 @@ BFA_TRC_FILE(HAL, IOC);
(sizeof(struct bfa_trc_mod_s) - \
BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
#define BFA_DBG_FWTRC_OFF(_fn) (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
#define bfa_ioc_stats(_ioc, _stats) (_ioc)->stats._stats ++
#define bfa_ioc_stats(_ioc, _stats) ((_ioc)->stats._stats++)
#define BFA_FLASH_CHUNK_NO(off) (off / BFI_FLASH_CHUNK_SZ_WORDS)
#define BFA_FLASH_OFFSET_IN_CHUNK(off) (off % BFI_FLASH_CHUNK_SZ_WORDS)
@ -1953,8 +1953,8 @@ bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
bfa_boolean_t
bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
{
return (bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling)
|| bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled));
return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling)
|| bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
}
/**
@ -1963,9 +1963,9 @@ bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
bfa_boolean_t
bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
{
return (bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset)
return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset)
|| bfa_fsm_cmp_state(ioc, bfa_ioc_sm_fwcheck)
|| bfa_fsm_cmp_state(ioc, bfa_ioc_sm_mismatch));
|| bfa_fsm_cmp_state(ioc, bfa_ioc_sm_mismatch);
}
#define bfa_ioc_state_disabled(__sm) \

12
drivers/scsi/bfa/bfa_ioc.h
View file

@ -179,16 +179,16 @@ struct bfa_ioc_s {
struct bfa_ioc_mbox_mod_s mbox_mod;
};
#define bfa_ioc_pcifn(__ioc) (__ioc)->pcidev.pci_func
#define bfa_ioc_devid(__ioc) (__ioc)->pcidev.device_id
#define bfa_ioc_bar0(__ioc) (__ioc)->pcidev.pci_bar_kva
#define bfa_ioc_pcifn(__ioc) ((__ioc)->pcidev.pci_func)
#define bfa_ioc_devid(__ioc) ((__ioc)->pcidev.device_id)
#define bfa_ioc_bar0(__ioc) ((__ioc)->pcidev.pci_bar_kva)
#define bfa_ioc_portid(__ioc) ((__ioc)->port_id)
#define bfa_ioc_fetch_stats(__ioc, __stats) \
((__stats)->drv_stats) = (__ioc)->stats
(((__stats)->drv_stats) = (__ioc)->stats)
#define bfa_ioc_clr_stats(__ioc) \
bfa_os_memset(&(__ioc)->stats, 0, sizeof((__ioc)->stats))
#define bfa_ioc_maxfrsize(__ioc) (__ioc)->attr->maxfrsize
#define bfa_ioc_rx_bbcredit(__ioc) (__ioc)->attr->rx_bbcredit
#define bfa_ioc_maxfrsize(__ioc) ((__ioc)->attr->maxfrsize)
#define bfa_ioc_rx_bbcredit(__ioc) ((__ioc)->attr->rx_bbcredit)
#define bfa_ioc_speed_sup(__ioc) \
BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop)

8
drivers/scsi/bfa/bfa_iocfc.c
View file

@ -794,7 +794,7 @@ bfa_iocfc_get_stats(struct bfa_s *bfa, struct bfa_iocfc_stats_s *stats,
if (iocfc->stats_busy) {
bfa_trc(bfa, iocfc->stats_busy);
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
}
iocfc->stats_busy = BFA_TRUE;
@ -804,7 +804,7 @@ bfa_iocfc_get_stats(struct bfa_s *bfa, struct bfa_iocfc_stats_s *stats,
bfa_iocfc_stats_query(bfa);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
bfa_status_t
@ -814,7 +814,7 @@ bfa_iocfc_clear_stats(struct bfa_s *bfa, bfa_cb_ioc_t cbfn, void *cbarg)
if (iocfc->stats_busy) {
bfa_trc(bfa, iocfc->stats_busy);
return (BFA_STATUS_DEVBUSY);
return BFA_STATUS_DEVBUSY;
}
iocfc->stats_busy = BFA_TRUE;
@ -822,7 +822,7 @@ bfa_iocfc_clear_stats(struct bfa_s *bfa, bfa_cb_ioc_t cbfn, void *cbarg)
iocfc->stats_cbarg = cbarg;
bfa_iocfc_stats_clear(bfa);
return (BFA_STATUS_OK);
return BFA_STATUS_OK;
}
/**

8
drivers/scsi/bfa/bfa_iocfc.h
View file

@ -107,13 +107,13 @@ struct bfa_iocfc_s {
#define bfa_lpuid(__bfa) bfa_ioc_portid(&(__bfa)->ioc)
#define bfa_msix_init(__bfa, __nvecs) \
(__bfa)->iocfc.hwif.hw_msix_init(__bfa, __nvecs)
((__bfa)->iocfc.hwif.hw_msix_init(__bfa, __nvecs))
#define bfa_msix_install(__bfa) \
(__bfa)->iocfc.hwif.hw_msix_install(__bfa)
((__bfa)->iocfc.hwif.hw_msix_install(__bfa))
#define bfa_msix_uninstall(__bfa) \
(__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa)
((__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa))
#define bfa_isr_mode_set(__bfa, __msix) \
(__bfa)->iocfc.hwif.hw_isr_mode_set(__bfa, __msix)
((__bfa)->iocfc.hwif.hw_isr_mode_set(__bfa, __msix))
#define bfa_msix_getvecs(__bfa, __vecmap, __nvecs, __maxvec) \
(__bfa)->iocfc.hwif.hw_msix_getvecs(__bfa, __vecmap, __nvecs, __maxvec)

4
drivers/scsi/bfa/bfa_ioim.c
View file

@ -105,13 +105,13 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
list_del(&ioim->qe);
list_add_tail(&ioim->qe,
&ioim->fcpim->ioim_comp_q);
&ioim->fcpim->ioim_comp_q);
bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
__bfa_cb_ioim_pathtov, ioim);
} else {
list_del(&ioim->qe);
list_add_tail(&ioim->qe,
&ioim->itnim->pending_q);
&ioim->itnim->pending_q);
}
break;
}

6
drivers/scsi/bfa/bfa_itnim.c
View file

@ -1029,7 +1029,7 @@ bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
bfa_stats(itnim, creates);
bfa_sm_send_event(itnim, BFA_ITNIM_SM_CREATE);
return (itnim);
return itnim;
}
void
@ -1061,7 +1061,7 @@ bfa_itnim_offline(struct bfa_itnim_s *itnim)
bfa_boolean_t
bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
{
return (
return
itnim->fcpim->path_tov && itnim->iotov_active &&
(bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwcreate) ||
bfa_sm_cmp_state(itnim, bfa_itnim_sm_sler) ||
@ -1069,7 +1069,7 @@ bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwdelete) ||
bfa_sm_cmp_state(itnim, bfa_itnim_sm_offline) ||
bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable))
);
;
}
void

4
drivers/scsi/bfa/bfa_log.c
View file

@ -231,9 +231,9 @@ bfa_log_get_level(struct bfa_log_mod_s *log_mod, int mod_id)
return BFA_LOG_INVALID;
if (log_mod)
return (log_mod->log_level[mod_id]);
return log_mod->log_level[mod_id];
else
return (bfa_log_info[mod_id].level);
return bfa_log_info[mod_id].level;
}
enum bfa_log_severity

4
drivers/scsi/bfa/bfa_port_priv.h
View file

@ -59,8 +59,8 @@ struct bfa_pport_s {
u8 *stats_kva;
u64 stats_pa;
union bfa_pport_stats_u *stats; /* pport stats */
u32 mypid : 24;
u32 rsvd_b : 8;
u32 mypid:24;
u32 rsvd_b:8;
struct bfa_timer_s timer; /* timer */
union bfa_pport_stats_u *stats_ret;
/* driver stats location */

6
drivers/scsi/bfa/bfa_rport.c
View file

@ -677,7 +677,7 @@ bfa_rport_alloc(struct bfa_rport_mod_s *mod)
if (rport)
list_add_tail(&rport->qe, &mod->rp_active_q);
return (rport);
return rport;
}
static void
@ -834,7 +834,7 @@ bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
if (rp == NULL)
return (NULL);
return NULL;
rp->bfa = bfa;
rp->rport_drv = rport_drv;
@ -843,7 +843,7 @@ bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
bfa_assert(bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
return (rp);
return rp;
}
void

9
drivers/scsi/bfa/bfa_tskim.c
View file

@ -23,13 +23,14 @@ BFA_TRC_FILE(HAL, TSKIM);
/**
* task management completion handling
*/
#define bfa_tskim_qcomp(__tskim, __cbfn) do { \
bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, __cbfn, (__tskim)); \
#define bfa_tskim_qcomp(__tskim, __cbfn) do { \
bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, \
__cbfn, (__tskim)); \
bfa_tskim_notify_comp(__tskim); \
} while (0)
#define bfa_tskim_notify_comp(__tskim) do { \
if ((__tskim)->notify) \
#define bfa_tskim_notify_comp(__tskim) do { \
if ((__tskim)->notify) \
bfa_itnim_tskdone((__tskim)->itnim); \
} while (0)

2
drivers/scsi/bfa/bfa_uf.c
View file

@ -185,7 +185,7 @@ bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
struct bfa_uf_s *uf;
bfa_q_deq(&uf_mod->uf_free_q, &uf);
return (uf);
return uf;
}
static void

6
drivers/scsi/bfa/bfad.c
View file

@ -188,8 +188,8 @@ static struct bfad_port_s *
bfad_get_drv_port(struct bfad_s *bfad, struct bfad_vf_s *vf_drv,
struct bfad_vport_s *vp_drv)
{
return ((vp_drv) ? (&(vp_drv)->drv_port)
: ((vf_drv) ? (&(vf_drv)->base_port) : (&(bfad)->pport)));
return (vp_drv) ? (&(vp_drv)->drv_port)
: ((vf_drv) ? (&(vf_drv)->base_port) : (&(bfad)->pport));
}
struct bfad_port_s *
@ -716,7 +716,7 @@ bfad_drv_init(struct bfad_s *bfad)
if ((bfad->bfad_flags & BFAD_MSIX_ON)
&& bfad_install_msix_handler(bfad)) {
printk(KERN_WARNING "%s: install_msix failed, bfad%d\n",
__FUNCTION__, bfad->inst_no);
__func__, bfad->inst_no);
}
bfad_init_timer(bfad);

8
drivers/scsi/bfa/bfad_fwimg.c
View file

@ -63,10 +63,10 @@ bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
memcpy(*bfi_image, fw->data, fw->size);
*bfi_image_size = fw->size/sizeof(u32);
return(*bfi_image);
return *bfi_image;
error:
return(NULL);
return NULL;
}
u32 *
@ -76,12 +76,12 @@ bfad_get_firmware_buf(struct pci_dev *pdev)
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);
return bfi_image_ct;
} 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);
return bfi_image_cb;
}
}

2
drivers/scsi/bfa/bfad_im.c
View file

@ -1050,7 +1050,7 @@ bfad_im_itnim_work_handler(struct work_struct *work)
} else {
printk(KERN_WARNING
"%s: itnim %llx is already in online state\n",
__FUNCTION__,
__func__,
bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim));
}

2
drivers/scsi/bfa/bfad_im_compat.h
View file

@ -31,7 +31,7 @@ u32 *bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
static inline u32 *
bfad_load_fwimg(struct pci_dev *pdev)
{
return(bfad_get_firmware_buf(pdev));
return bfad_get_firmware_buf(pdev);
}
static inline void

3
drivers/scsi/bfa/bfad_intr.c
View file

@ -23,13 +23,12 @@ BFA_TRC_FILE(LDRV, INTR);
/**
* bfa_isr BFA driver interrupt functions
*/
irqreturn_t bfad_intx(int irq, void *dev_id);
static int msix_disable;
module_param(msix_disable, int, S_IRUGO | S_IWUSR);
/**
* Line based interrupt handler.
*/
irqreturn_t
static irqreturn_t
bfad_intx(int irq, void *dev_id)
{
struct bfad_s *bfad = dev_id;

18
drivers/scsi/bfa/fabric.c
View file

@ -36,12 +36,12 @@ BFA_TRC_FILE(FCS, FABRIC);
#define BFA_FCS_FABRIC_RETRY_DELAY (2000) /* Milliseconds */
#define BFA_FCS_FABRIC_CLEANUP_DELAY (10000) /* Milliseconds */
#define bfa_fcs_fabric_set_opertype(__fabric) do { \
if (bfa_pport_get_topology((__fabric)->fcs->bfa) \
== BFA_PPORT_TOPOLOGY_P2P) \
(__fabric)->oper_type = BFA_PPORT_TYPE_NPORT; \
else \
(__fabric)->oper_type = BFA_PPORT_TYPE_NLPORT; \
#define bfa_fcs_fabric_set_opertype(__fabric) do { \
if (bfa_pport_get_topology((__fabric)->fcs->bfa) \
== BFA_PPORT_TOPOLOGY_P2P) \
(__fabric)->oper_type = BFA_PPORT_TYPE_NPORT; \
else \
(__fabric)->oper_type = BFA_PPORT_TYPE_NLPORT; \
} while (0)
/*
@ -887,7 +887,7 @@ bfa_fcs_fabric_modsusp(struct bfa_fcs_s *fcs)
bfa_boolean_t
bfa_fcs_fabric_is_loopback(struct bfa_fcs_fabric_s *fabric)
{
return (bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_loopback));
return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_loopback);
}
enum bfa_pport_type
@ -974,7 +974,7 @@ bfa_fcs_fabric_port_delete_comp(struct bfa_fcs_fabric_s *fabric)
int
bfa_fcs_fabric_is_online(struct bfa_fcs_fabric_s *fabric)
{
return (bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_online));
return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_online);
}
@ -1015,7 +1015,7 @@ bfa_fcs_fabric_vport_lookup(struct bfa_fcs_fabric_s *fabric, wwn_t pwwn)
u16
bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric)
{
return (fabric->num_vports);
return fabric->num_vports;
}
/**

190
drivers/scsi/bfa/fcbuild.c
View file

@ -188,14 +188,14 @@ fc_els_rsp_parse(struct fchs_s *fchs, int len)
switch (els_cmd->els_code) {
case FC_ELS_LS_RJT:
if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY)
return (FC_PARSE_BUSY);
return FC_PARSE_BUSY;
else
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
case FC_ELS_ACC:
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
static void
@ -228,7 +228,7 @@ fc_plogi_x_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
bfa_os_memcpy(&plogi->port_name, &port_name, sizeof(wwn_t));
bfa_os_memcpy(&plogi->node_name, &node_name, sizeof(wwn_t));
return (sizeof(struct fc_logi_s));
return sizeof(struct fc_logi_s);
}
u16
@ -267,7 +267,7 @@ fc_flogi_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
flogi->csp.npiv_supp = 1; /* @todo. field name is not correct */
vvl_info[0] = bfa_os_htonl(FLOGI_VVL_BRCD);
return (sizeof(struct fc_logi_s));
return sizeof(struct fc_logi_s);
}
u16
@ -287,7 +287,7 @@ fc_flogi_acc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
flogi->csp.bbcred = bfa_os_htons(local_bb_credits);
return (sizeof(struct fc_logi_s));
return sizeof(struct fc_logi_s);
}
u16
@ -306,7 +306,7 @@ fc_fdisc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
flogi->port_name = port_name;
flogi->node_name = node_name;
return (sizeof(struct fc_logi_s));
return sizeof(struct fc_logi_s);
}
u16
@ -338,26 +338,26 @@ fc_plogi_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name)
case FC_ELS_LS_RJT:
ls_rjt = (struct fc_ls_rjt_s *) (fchs + 1);
if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY)
return (FC_PARSE_BUSY);
return FC_PARSE_BUSY;
else
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
case FC_ELS_ACC:
plogi = (struct fc_logi_s *) (fchs + 1);
if (len < sizeof(struct fc_logi_s))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!wwn_is_equal(plogi->port_name, port_name))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!plogi->class3.class_valid)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (bfa_os_ntohs(plogi->class3.rxsz) < (FC_MIN_PDUSZ))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return (FC_PARSE_OK);
return FC_PARSE_OK;
default:
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
}
}
@ -372,7 +372,7 @@ fc_plogi_parse(struct fchs_s *fchs)
if ((bfa_os_ntohs(plogi->class3.rxsz) < FC_MIN_PDUSZ)
|| (bfa_os_ntohs(plogi->class3.rxsz) > FC_MAX_PDUSZ)
|| (plogi->class3.rxsz == 0))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return FC_PARSE_OK;
}
@ -393,7 +393,7 @@ fc_prli_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
prli->parampage.servparams.task_retry_id = 0;
prli->parampage.servparams.confirm = 1;
return (sizeof(struct fc_prli_s));
return sizeof(struct fc_prli_s);
}
u16
@ -414,41 +414,41 @@ fc_prli_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
prli->parampage.rspcode = FC_PRLI_ACC_XQTD;
return (sizeof(struct fc_prli_s));
return sizeof(struct fc_prli_s);
}
enum fc_parse_status
fc_prli_rsp_parse(struct fc_prli_s *prli, int len)
{
if (len < sizeof(struct fc_prli_s))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (prli->command != FC_ELS_ACC)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if ((prli->parampage.rspcode != FC_PRLI_ACC_XQTD)
&& (prli->parampage.rspcode != FC_PRLI_ACC_PREDEF_IMG))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (prli->parampage.servparams.target != 1)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
enum fc_parse_status
fc_prli_parse(struct fc_prli_s *prli)
{
if (prli->parampage.type != FC_TYPE_FCP)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!prli->parampage.imagepair)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!prli->parampage.servparams.initiator)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
u16
@ -462,7 +462,7 @@ fc_logo_build(struct fchs_s *fchs, struct fc_logo_s *logo, u32 d_id,
logo->nport_id = (s_id);
logo->orig_port_name = port_name;
return (sizeof(struct fc_logo_s));
return sizeof(struct fc_logo_s);
}
static u16
@ -484,7 +484,7 @@ fc_adisc_x_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
adisc->orig_node_name = node_name;
adisc->nport_id = (s_id);
return (sizeof(struct fc_adisc_s));
return sizeof(struct fc_adisc_s);
}
u16
@ -511,15 +511,15 @@ fc_adisc_rsp_parse(struct fc_adisc_s *adisc, int len, wwn_t port_name,
{
if (len < sizeof(struct fc_adisc_s))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (adisc->els_cmd.els_code != FC_ELS_ACC)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!wwn_is_equal(adisc->orig_port_name, port_name))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
enum fc_parse_status
@ -529,14 +529,14 @@ fc_adisc_parse(struct fchs_s *fchs, void *pld, u32 host_dap,
struct fc_adisc_s *adisc = (struct fc_adisc_s *) pld;
if (adisc->els_cmd.els_code != FC_ELS_ACC)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if ((adisc->nport_id == (host_dap))
&& wwn_is_equal(adisc->orig_port_name, port_name)
&& wwn_is_equal(adisc->orig_node_name, node_name))
return (FC_PARSE_OK);
return FC_PARSE_OK;
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
}
enum fc_parse_status
@ -550,13 +550,13 @@ fc_pdisc_parse(struct fchs_s *fchs, wwn_t node_name, wwn_t port_name)
if ((bfa_os_ntohs(pdisc->class3.rxsz) <
(FC_MIN_PDUSZ - sizeof(struct fchs_s)))
|| (pdisc->class3.rxsz == 0))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!wwn_is_equal(pdisc->port_name, port_name))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
if (!wwn_is_equal(pdisc->node_name, node_name))
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
return FC_PARSE_OK;
}
@ -570,7 +570,7 @@ fc_abts_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
fchs->s_id = (s_id);
fchs->ox_id = bfa_os_htons(ox_id);
return (sizeof(struct fchs_s));
return sizeof(struct fchs_s);
}
enum fc_parse_status
@ -578,9 +578,9 @@ fc_abts_rsp_parse(struct fchs_s *fchs, int len)
{
if ((fchs->cat_info == FC_CAT_BA_ACC)
|| (fchs->cat_info == FC_CAT_BA_RJT))
return (FC_PARSE_OK);
return FC_PARSE_OK;
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
}
u16
@ -597,7 +597,7 @@ fc_rrq_build(struct fchs_s *fchs, struct fc_rrq_s *rrq, u32 d_id,
rrq->ox_id = bfa_os_htons(rrq_oxid);
rrq->rx_id = FC_RXID_ANY;
return (sizeof(struct fc_rrq_s));
return sizeof(struct fc_rrq_s);
}
u16
@ -611,7 +611,7 @@ fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
memset(acc, 0, sizeof(struct fc_els_cmd_s));
acc->els_code = FC_ELS_ACC;
return (sizeof(struct fc_els_cmd_s));
return sizeof(struct fc_els_cmd_s);
}
u16
@ -627,7 +627,7 @@ fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt, u32 d_id,
ls_rjt->reason_code_expl = reason_code_expl;
ls_rjt->vendor_unique = 0x00;
return (sizeof(struct fc_ls_rjt_s));
return sizeof(struct fc_ls_rjt_s);
}
u16
@ -643,7 +643,7 @@ fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id,
ba_acc->ox_id = fchs->ox_id;
ba_acc->rx_id = fchs->rx_id;
return (sizeof(struct fc_ba_acc_s));
return sizeof(struct fc_ba_acc_s);
}
u16
@ -654,7 +654,7 @@ fc_ls_acc_build(struct fchs_s *fchs, struct fc_els_cmd_s *els_cmd,
memset(els_cmd, 0, sizeof(struct fc_els_cmd_s));
els_cmd->els_code = FC_ELS_ACC;
return (sizeof(struct fc_els_cmd_s));
return sizeof(struct fc_els_cmd_s);
}
int
@ -696,7 +696,7 @@ fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc,
tprlo_acc->tprlo_acc_params[page].orig_process_assc = 0;
tprlo_acc->tprlo_acc_params[page].resp_process_assc = 0;
}
return (bfa_os_ntohs(tprlo_acc->payload_len));
return bfa_os_ntohs(tprlo_acc->payload_len);
}
u16
@ -721,7 +721,7 @@ fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc,
prlo_acc->prlo_acc_params[page].resp_process_assc = 0;
}
return (bfa_os_ntohs(prlo_acc->payload_len));
return bfa_os_ntohs(prlo_acc->payload_len);
}
u16
@ -735,7 +735,7 @@ fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid, u32 d_id,
rnid->els_cmd.els_code = FC_ELS_RNID;
rnid->node_id_data_format = data_format;
return (sizeof(struct fc_rnid_cmd_s));
return sizeof(struct fc_rnid_cmd_s);
}
u16
@ -759,10 +759,10 @@ fc_rnid_acc_build(struct fchs_s *fchs, struct fc_rnid_acc_s *rnid_acc,
rnid_acc->specific_id_data_length =
sizeof(struct fc_rnid_general_topology_data_s);
bfa_os_assign(rnid_acc->gen_topology_data, *gen_topo_data);
return (sizeof(struct fc_rnid_acc_s));
return sizeof(struct fc_rnid_acc_s);
} else {
return (sizeof(struct fc_rnid_acc_s) -
sizeof(struct fc_rnid_general_topology_data_s));
return sizeof(struct fc_rnid_acc_s) -
sizeof(struct fc_rnid_general_topology_data_s);
}
}
@ -776,7 +776,7 @@ fc_rpsc_build(struct fchs_s *fchs, struct fc_rpsc_cmd_s *rpsc, u32 d_id,
memset(rpsc, 0, sizeof(struct fc_rpsc_cmd_s));
rpsc->els_cmd.els_code = FC_ELS_RPSC;
return (sizeof(struct fc_rpsc_cmd_s));
return sizeof(struct fc_rpsc_cmd_s);
}
u16
@ -797,8 +797,8 @@ fc_rpsc2_build(struct fchs_s *fchs, struct fc_rpsc2_cmd_s *rpsc2,
for (i = 0; i < npids; i++)
rpsc2->pid_list[i].pid = pid_list[i];
return (sizeof(struct fc_rpsc2_cmd_s) + ((npids - 1) *
(sizeof(u32))));
return sizeof(struct fc_rpsc2_cmd_s) + ((npids - 1) *
(sizeof(u32)));
}
u16
@ -819,7 +819,7 @@ fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc,
rpsc_acc->speed_info[0].port_op_speed =
bfa_os_htons(oper_speed->port_op_speed);
return (sizeof(struct fc_rpsc_acc_s));
return sizeof(struct fc_rpsc_acc_s);
}
@ -856,7 +856,7 @@ fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
pdisc->port_name = port_name;
pdisc->node_name = node_name;
return (sizeof(struct fc_logi_s));
return sizeof(struct fc_logi_s);
}
u16
@ -865,21 +865,21 @@ fc_pdisc_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name)
struct fc_logi_s *pdisc = (struct fc_logi_s *) (fchs + 1);
if (len < sizeof(struct fc_logi_s))
return (FC_PARSE_LEN_INVAL);
return FC_PARSE_LEN_INVAL;
if (pdisc->els_cmd.els_code != FC_ELS_ACC)
return (FC_PARSE_ACC_INVAL);
return FC_PARSE_ACC_INVAL;
if (!wwn_is_equal(pdisc->port_name, port_name))
return (FC_PARSE_PWWN_NOT_EQUAL);
return FC_PARSE_PWWN_NOT_EQUAL;
if (!pdisc->class3.class_valid)
return (FC_PARSE_NWWN_NOT_EQUAL);
return FC_PARSE_NWWN_NOT_EQUAL;
if (bfa_os_ntohs(pdisc->class3.rxsz) < (FC_MIN_PDUSZ))
return (FC_PARSE_RXSZ_INVAL);
return FC_PARSE_RXSZ_INVAL;
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
u16
@ -903,7 +903,7 @@ fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
prlo->prlo_params[page].resp_process_assc = 0;
}
return (bfa_os_ntohs(prlo->payload_len));
return bfa_os_ntohs(prlo->payload_len);
}
u16
@ -916,7 +916,7 @@ fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
len = len;
if (prlo->command != FC_ELS_ACC)
return (FC_PARSE_FAILURE);
return FC_PARSE_FAILURE;
num_pages = ((bfa_os_ntohs(prlo->payload_len)) - 4) / 16;
@ -936,7 +936,7 @@ fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
if (prlo->prlo_acc_params[page].resp_process_assc != 0)
return FC_PARSE_FAILURE;
}
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
@ -968,7 +968,7 @@ fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
}
}
return (bfa_os_ntohs(tprlo->payload_len));
return bfa_os_ntohs(tprlo->payload_len);
}
u16
@ -981,23 +981,23 @@ fc_tprlo_rsp_parse(struct fchs_s *fchs, int len)
len = len;
if (tprlo->command != FC_ELS_ACC)
return (FC_PARSE_ACC_INVAL);
return FC_PARSE_ACC_INVAL;
num_pages = (bfa_os_ntohs(tprlo->payload_len) - 4) / 16;
for (page = 0; page < num_pages; page++) {
if (tprlo->tprlo_acc_params[page].type != FC_TYPE_FCP)
return (FC_PARSE_NOT_FCP);
return FC_PARSE_NOT_FCP;
if (tprlo->tprlo_acc_params[page].opa_valid != 0)
return (FC_PARSE_OPAFLAG_INVAL);
return FC_PARSE_OPAFLAG_INVAL;
if (tprlo->tprlo_acc_params[page].rpa_valid != 0)
return (FC_PARSE_RPAFLAG_INVAL);
return FC_PARSE_RPAFLAG_INVAL;
if (tprlo->tprlo_acc_params[page].orig_process_assc != 0)
return (FC_PARSE_OPA_INVAL);
return FC_PARSE_OPA_INVAL;
if (tprlo->tprlo_acc_params[page].resp_process_assc != 0)
return (FC_PARSE_RPA_INVAL);
return FC_PARSE_RPA_INVAL;
}
return (FC_PARSE_OK);
return FC_PARSE_OK;
}
enum fc_parse_status
@ -1024,7 +1024,7 @@ fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
fchs->cat_info = FC_CAT_BA_RJT;
ba_rjt->reason_code = reason_code;
ba_rjt->reason_expl = reason_expl;
return (sizeof(struct fc_ba_rjt_s));
return sizeof(struct fc_ba_rjt_s);
}
static void
@ -1073,7 +1073,7 @@ fc_gidpn_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
bfa_os_memset(gidpn, 0, sizeof(struct fcgs_gidpn_req_s));
gidpn->port_name = port_name;
return (sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1090,7 +1090,7 @@ fc_gpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
bfa_os_memset(gpnid, 0, sizeof(fcgs_gpnid_req_t));
gpnid->dap = port_id;
return (sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s));
return sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s);
}
u16
@ -1107,7 +1107,7 @@ fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
bfa_os_memset(gnnid, 0, sizeof(fcgs_gnnid_req_t));
gnnid->dap = port_id;
return (sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s));
return sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s);
}
u16
@ -1137,7 +1137,7 @@ fc_scr_build(struct fchs_s *fchs, struct fc_scr_s *scr, u8 set_br_reg,
if (set_br_reg)
scr->vu_reg_func = FC_VU_SCR_REG_FUNC_FABRIC_NAME_CHANGE;
return (sizeof(struct fc_scr_s));
return sizeof(struct fc_scr_s);
}
u16
@ -1157,7 +1157,7 @@ fc_rscn_build(struct fchs_s *fchs, struct fc_rscn_pl_s *rscn, u32 s_id,
rscn->event[0].format = FC_RSCN_FORMAT_PORTID;
rscn->event[0].portid = s_id;
return (sizeof(struct fc_rscn_pl_s));
return sizeof(struct fc_rscn_pl_s);
}
u16
@ -1188,7 +1188,7 @@ fc_rftid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
rftid->fc4_type[index] |= bfa_os_htonl(type_value);
}
return (sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1210,7 +1210,7 @@ fc_rftid_build_sol(struct fchs_s *fchs, void *pyld, u32 s_id,
bfa_os_memcpy((void *)rftid->fc4_type, (void *)fc4_bitmap,
(bitmap_size < 32 ? bitmap_size : 32));
return (sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1231,7 +1231,7 @@ fc_rffid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
rffid->fc4ftr_bits = fc4_ftrs;
rffid->fc4_type = fc4_type;
return (sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1253,7 +1253,7 @@ fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
rspnid->spn_len = (u8) strlen((char *)name);
strncpy((char *)rspnid->spn, (char *)name, rspnid->spn_len);
return (sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1275,7 +1275,7 @@ fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id,
gidft->domain_id = 0;
gidft->area_id = 0;
return (sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1294,7 +1294,7 @@ fc_rpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
rpnid->port_id = port_id;
rpnid->port_name = port_name;
return (sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1313,7 +1313,7 @@ fc_rnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
rnnid->port_id = port_id;
rnnid->node_name = node_name;
return (sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1332,7 +1332,7 @@ fc_rcsid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
rcsid->port_id = port_id;
rcsid->cos = cos;
return (sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1351,7 +1351,7 @@ fc_rptid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
rptid->port_id = port_id;
rptid->port_type = port_type;
return (sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s));
return sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s);
}
u16
@ -1368,7 +1368,7 @@ fc_ganxt_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id)
bfa_os_memset(ganxt, 0, sizeof(struct fcgs_ganxt_req_s));
ganxt->port_id = port_id;
return (sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s));
return sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s);
}
/*
@ -1385,7 +1385,7 @@ fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id,
fc_gs_fchdr_build(fchs, d_id, s_id, 0);
fc_gs_fdmi_cthdr_build(cthdr, s_id, cmd_code);
return (sizeof(struct ct_hdr_s));
return sizeof(struct ct_hdr_s);
}
/*
@ -1425,7 +1425,7 @@ fc_gmal_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
bfa_os_memset(gmal, 0, sizeof(fcgs_gmal_req_t));
gmal->wwn = wwn;
return (sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t));
return sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t);
}
/*
@ -1445,5 +1445,5 @@ fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
bfa_os_memset(gfn, 0, sizeof(fcgs_gfn_req_t));
gfn->wwn = wwn;
return (sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t));
return sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t);
}

6
drivers/scsi/bfa/fcbuild.h
View file

@ -32,8 +32,8 @@
* Utility Macros/functions
*/
#define fcif_sof_set(_ifhdr, _sof) (_ifhdr)->sof = FC_ ## _sof
#define fcif_eof_set(_ifhdr, _eof) (_ifhdr)->eof = FC_ ## _eof
#define fcif_sof_set(_ifhdr, _sof) ((_ifhdr)->sof = FC_ ## _sof)
#define fcif_eof_set(_ifhdr, _eof) ((_ifhdr)->eof = FC_ ## _eof)
#define wwn_is_equal(_wwn1, _wwn2) \
(memcmp(&(_wwn1), &(_wwn2), sizeof(wwn_t)) == 0)
@ -49,7 +49,7 @@
static inline u32
fc_get_ctresp_pyld_len(u32 resp_len)
{
return (resp_len - sizeof(struct ct_hdr_s));
return resp_len - sizeof(struct ct_hdr_s);
}
/*

7
drivers/scsi/bfa/fcpim.c
View file

@ -286,11 +286,10 @@ bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline);
bfa_fcb_itnim_offline(itnim->itnim_drv);
bfa_itnim_offline(itnim->bfa_itnim);
if (bfa_fcs_port_is_online(itnim->rport->port) == BFA_TRUE) {
if (bfa_fcs_port_is_online(itnim->rport->port) == BFA_TRUE)
bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_DISCONNECT);
} else {
else
bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_OFFLINE);
}
break;
case BFA_FCS_ITNIM_SM_DELETE:
@ -732,7 +731,7 @@ bfa_fcs_itnim_lookup(struct bfa_fcs_port_s *port, wwn_t rpwwn)
return NULL;
bfa_assert(rport->itnim != NULL);
return (rport->itnim);
return rport->itnim;
}
bfa_status_t

2
drivers/scsi/bfa/fcs.h
View file

@ -23,7 +23,7 @@
#ifndef __FCS_H__
#define __FCS_H__
#define __fcs_min_cfg(__fcs) (__fcs)->min_cfg
#define __fcs_min_cfg(__fcs) ((__fcs)->min_cfg)
void bfa_fcs_modexit_comp(struct bfa_fcs_s *fcs);

8
drivers/scsi/bfa/fdmi.c
View file

@ -72,9 +72,9 @@ static u16 bfa_fcs_port_fdmi_build_rpa_pyld(
struct bfa_fcs_port_fdmi_s *fdmi, u8 *pyld);
static u16 bfa_fcs_port_fdmi_build_portattr_block(
struct bfa_fcs_port_fdmi_s *fdmi, u8 *pyld);
void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
struct bfa_fcs_fdmi_hba_attr_s *hba_attr);
void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
struct bfa_fcs_fdmi_port_attr_s *port_attr);
/**
* fcs_fdmi_sm FCS FDMI state machine
@ -1091,7 +1091,7 @@ bfa_fcs_port_fdmi_timeout(void *arg)
bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT);
}
void
static void
bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
struct bfa_fcs_fdmi_hba_attr_s *hba_attr)
{
@ -1145,7 +1145,7 @@ bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
}
void
static void
bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
struct bfa_fcs_fdmi_port_attr_s *port_attr)
{

2
drivers/scsi/bfa/include/aen/bfa_aen.h
View file

@ -54,7 +54,7 @@ bfa_aen_get_max_cfg_entry(void)
static inline s32
bfa_aen_get_meminfo(void)
{
return (sizeof(struct bfa_aen_entry_s) * bfa_aen_get_max_cfg_entry());
return sizeof(struct bfa_aen_entry_s) * bfa_aen_get_max_cfg_entry();
}
static inline s32

10
drivers/scsi/bfa/include/bfa.h
View file

@ -76,11 +76,11 @@ struct bfa_meminfo_s {
struct bfa_mem_elem_s meminfo[BFA_MEM_TYPE_MAX];
};
#define bfa_meminfo_kva(_m) \
(_m)->meminfo[BFA_MEM_TYPE_KVA - 1].kva_curp
((_m)->meminfo[BFA_MEM_TYPE_KVA - 1].kva_curp)
#define bfa_meminfo_dma_virt(_m) \
(_m)->meminfo[BFA_MEM_TYPE_DMA - 1].kva_curp
((_m)->meminfo[BFA_MEM_TYPE_DMA - 1].kva_curp)
#define bfa_meminfo_dma_phys(_m) \
(_m)->meminfo[BFA_MEM_TYPE_DMA - 1].dma_curp
((_m)->meminfo[BFA_MEM_TYPE_DMA - 1].dma_curp)
/**
* Generic Scatter Gather Element used by driver
@ -100,7 +100,7 @@ struct bfa_sge_s {
/*
* bfa stats interfaces
*/
#define bfa_stats(_mod, _stats) (_mod)->stats._stats ++
#define bfa_stats(_mod, _stats) ((_mod)->stats._stats++)
#define bfa_ioc_get_stats(__bfa, __ioc_stats) \
bfa_ioc_fetch_stats(&(__bfa)->ioc, __ioc_stats)
@ -136,7 +136,7 @@ void bfa_isr_enable(struct bfa_s *bfa);
void bfa_isr_disable(struct bfa_s *bfa);
void bfa_msix_getvecs(struct bfa_s *bfa, u32 *msix_vecs_bmap,
u32 *num_vecs, u32 *max_vec_bit);
#define bfa_msix(__bfa, __vec) (__bfa)->msix.handler[__vec](__bfa, __vec)
#define bfa_msix(__bfa, __vec) ((__bfa)->msix.handler[__vec](__bfa, __vec))
void bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q);
void bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q);

8
drivers/scsi/bfa/include/bfa_svc.h
View file

@ -34,10 +34,10 @@ struct bfa_fcxp_s;
*/
struct bfa_rport_info_s {
u16 max_frmsz; /* max rcv pdu size */
u32 pid : 24, /* remote port ID */
lp_tag : 8;
u32 local_pid : 24, /* local port ID */
cisc : 8; /* CIRO supported */
u32 pid:24, /* remote port ID */
lp_tag:8;
u32 local_pid:24, /* local port ID */
cisc:8; /* CIRO supported */
u8 fc_class; /* supported FC classes. enum fc_cos */
u8 vf_en; /* virtual fabric enable */
u16 vf_id; /* virtual fabric ID */

12
drivers/scsi/bfa/include/bfi/bfi.h
View file

@ -93,13 +93,13 @@ union bfi_addr_u {
*/
struct bfi_sge_s {
#ifdef __BIGENDIAN
u32 flags : 2,
rsvd : 2,
sg_len : 28;
u32 flags:2,
rsvd:2,
sg_len:28;
#else
u32 sg_len : 28,
rsvd : 2,
flags : 2;
u32 sg_len:28,
rsvd:2,
flags:2;
#endif
union bfi_addr_u sga;
};

2
drivers/scsi/bfa/include/bfi/bfi_ioc.h
View file

@ -142,7 +142,7 @@ enum {
BFI_ADAPTER_UNSUPP = 0x400000, /* unknown adapter type */
};
#define BFI_ADAPTER_GETP(__prop,__adap_prop) \
#define BFI_ADAPTER_GETP(__prop, __adap_prop) \
(((__adap_prop) & BFI_ADAPTER_ ## __prop ## _MK) >> \
BFI_ADAPTER_ ## __prop ## _SH)
#define BFI_ADAPTER_SETP(__prop, __val) \

4
drivers/scsi/bfa/include/bfi/bfi_lps.h
View file

@ -55,8 +55,8 @@ struct bfi_lps_login_rsp_s {
u16 bb_credit;
u8 f_port;
u8 npiv_en;
u32 lp_pid : 24;
u32 auth_req : 8;
u32 lp_pid:24;
u32 auth_req:8;
mac_t lp_mac;
mac_t fcf_mac;
u8 ext_status;

8
drivers/scsi/bfa/include/bfi/bfi_rport.h
View file

@ -38,10 +38,10 @@ struct bfi_rport_create_req_s {
struct bfi_mhdr_s mh; /* common msg header */
u16 bfa_handle; /* host rport handle */
u16 max_frmsz; /* max rcv pdu size */
u32 pid : 24, /* remote port ID */
lp_tag : 8; /* local port tag */
u32 local_pid : 24, /* local port ID */
cisc : 8;
u32 pid:24, /* remote port ID */
lp_tag:8; /* local port tag */
u32 local_pid:24, /* local port ID */
cisc:8;
u8 fc_class; /* supported FC classes */
u8 vf_en; /* virtual fabric enable */
u16 vf_id; /* virtual fabric ID */

6
drivers/scsi/bfa/include/cs/bfa_checksum.h
View file

@ -31,7 +31,7 @@ bfa_checksum_u32(u32 *buf, int sz)
for (i = 0; i < m; i++)
sum ^= buf[i];
return (sum);
return sum;
}
static inline u16
@ -43,7 +43,7 @@ bfa_checksum_u16(u16 *buf, int sz)
for (i = 0; i < m; i++)
sum ^= buf[i];
return (sum);
return sum;
}
static inline u8
@ -55,6 +55,6 @@ bfa_checksum_u8(u8 *buf, int sz)
for (i = 0; i < sz; i++)
sum ^= buf[i];
return (sum);
return sum;
}
#endif

6
drivers/scsi/bfa/include/cs/bfa_sm.h
View file

@ -24,8 +24,8 @@
typedef void (*bfa_sm_t)(void *sm, int event);
#define bfa_sm_set_state(_sm, _state) (_sm)->sm = (bfa_sm_t)(_state)
#define bfa_sm_send_event(_sm, _event) (_sm)->sm((_sm), (_event))
#define bfa_sm_set_state(_sm, _state) ((_sm)->sm = (bfa_sm_t)(_state))
#define bfa_sm_send_event(_sm, _event) ((_sm)->sm((_sm), (_event)))
#define bfa_sm_get_state(_sm) ((_sm)->sm)
#define bfa_sm_cmp_state(_sm, _state) ((_sm)->sm == (bfa_sm_t)(_state))
@ -62,7 +62,7 @@ typedef void (*bfa_fsm_t)(void *fsm, int event);
} while (0)
#define bfa_fsm_send_event(_fsm, _event) \
(_fsm)->fsm((_fsm), (_event))
((_fsm)->fsm((_fsm), (_event)))
#define bfa_fsm_cmp_state(_fsm, _state) \
((_fsm)->fsm == (bfa_fsm_t)(_state))

2
drivers/scsi/bfa/include/cs/bfa_trc.h
View file

@ -24,7 +24,7 @@
#endif
#ifndef BFA_TRC_TS
#define BFA_TRC_TS(_trcm) ((_trcm)->ticks ++)
#define BFA_TRC_TS(_trcm) ((_trcm)->ticks++)
#endif
struct bfa_trc_s {

2
drivers/scsi/bfa/include/fcs/bfa_fcs_fabric.h
View file

@ -75,7 +75,7 @@ struct bfa_fcs_fabric_s {
*/
};
#define bfa_fcs_fabric_npiv_capable(__f) (__f)->is_npiv
#define bfa_fcs_fabric_npiv_capable(__f) ((__f)->is_npiv)
#define bfa_fcs_fabric_is_switched(__f) \
((__f)->fab_type == BFA_FCS_FABRIC_SWITCHED)

17
drivers/scsi/bfa/include/fcs/bfa_fcs_lport.h
View file

@ -125,12 +125,12 @@ union bfa_fcs_port_topo_u {
struct bfa_fcs_port_s {
struct list_head qe; /* used by port/vport */
bfa_sm_t sm; /* state machine */
struct bfa_fcs_fabric_s *fabric; /* parent fabric */
struct bfa_port_cfg_s port_cfg; /* port configuration */
struct bfa_fcs_fabric_s *fabric;/* parent fabric */
struct bfa_port_cfg_s port_cfg;/* port configuration */
struct bfa_timer_s link_timer; /* timer for link offline */
u32 pid : 24; /* FC address */
u8 lp_tag; /* lport tag */
u16 num_rports; /* Num of r-ports */
u32 pid:24; /* FC address */
u8 lp_tag; /* lport tag */
u16 num_rports; /* Num of r-ports */
struct list_head rport_q; /* queue of discovered r-ports */
struct bfa_fcs_s *fcs; /* FCS instance */
union bfa_fcs_port_topo_u port_topo; /* fabric/loop/n2n details */
@ -188,13 +188,14 @@ bfa_fcs_port_get_drvport(struct bfa_fcs_port_s *port)
}
#define bfa_fcs_port_get_opertype(_lport) (_lport)->fabric->oper_type
#define bfa_fcs_port_get_opertype(_lport) ((_lport)->fabric->oper_type)
#define bfa_fcs_port_get_fabric_name(_lport) (_lport)->fabric->fabric_name
#define bfa_fcs_port_get_fabric_name(_lport) ((_lport)->fabric->fabric_name)
#define bfa_fcs_port_get_fabric_ipaddr(_lport) (_lport)->fabric->fabric_ip_addr
#define bfa_fcs_port_get_fabric_ipaddr(_lport) \
((_lport)->fabric->fabric_ip_addr)
/**
* bfa fcs port public functions

10
drivers/scsi/bfa/include/protocol/ct.h
View file

@ -193,11 +193,11 @@ struct fcgs_rftid_req_s {
#define FC_GS_FCP_FC4_FEATURE_TARGET 0x01
struct fcgs_rffid_req_s{
u32 rsvd :8;
u32 dap :24; /* port identifier */
u32 rsvd1 :16;
u32 fc4ftr_bits :8; /* fc4 feature bits */
u32 fc4_type :8; /* corresponding FC4 Type */
u32 rsvd:8;
u32 dap:24; /* port identifier */
u32 rsvd1:16;
u32 fc4ftr_bits:8; /* fc4 feature bits */
u32 fc4_type:8; /* corresponding FC4 Type */
};
/**

22
drivers/scsi/bfa/include/protocol/fc.h
View file

@ -486,14 +486,14 @@ struct fc_rsi_s {
* see FC-PH-X table 113 & 115 for explanation also FCP table 8
*/
struct fc_prli_params_s{
u32 reserved: 16;
u32 reserved:16;
#ifdef __BIGENDIAN
u32 reserved1: 5;
u32 rec_support : 1;
u32 task_retry_id : 1;
u32 retry : 1;
u32 reserved1:5;
u32 rec_support:1;
u32 task_retry_id:1;
u32 retry:1;
u32 confirm : 1;
u32 confirm:1;
u32 doverlay:1;
u32 initiator:1;
u32 target:1;
@ -502,10 +502,10 @@ struct fc_prli_params_s{
u32 rxrdisab:1;
u32 wxrdisab:1;
#else
u32 retry : 1;
u32 task_retry_id : 1;
u32 rec_support : 1;
u32 reserved1: 5;
u32 retry:1;
u32 task_retry_id:1;
u32 rec_support:1;
u32 reserved1:5;
u32 wxrdisab:1;
u32 rxrdisab:1;
@ -514,7 +514,7 @@ struct fc_prli_params_s{
u32 target:1;
u32 initiator:1;
u32 doverlay:1;
u32 confirm : 1;
u32 confirm:1;
#endif
};

231
drivers/scsi/bfa/loop.c
View file

@ -58,49 +58,16 @@ static const u8 port_loop_alpa_map[] = {
/*
* Local Functions
*/
bfa_status_t bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port,
u8 alpa);
static bfa_status_t bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port,
u8 alpa);
void bfa_fcs_port_loop_plogi_response(void *fcsarg,
struct bfa_fcxp_s *fcxp,
void *cbarg,
bfa_status_t req_status,
u32 rsp_len,
u32 resid_len,
struct fchs_s *rsp_fchs);
bfa_status_t bfa_fcs_port_loop_send_adisc(struct bfa_fcs_port_s *port,
u8 alpa);
void bfa_fcs_port_loop_adisc_response(void *fcsarg,
struct bfa_fcxp_s *fcxp,
void *cbarg,
bfa_status_t req_status,
u32 rsp_len,
u32 resid_len,
struct fchs_s *rsp_fchs);
bfa_status_t bfa_fcs_port_loop_send_plogi_acc(struct bfa_fcs_port_s *port,
u8 alpa);
void bfa_fcs_port_loop_plogi_acc_response(void *fcsarg,
struct bfa_fcxp_s *fcxp,
void *cbarg,
bfa_status_t req_status,
u32 rsp_len,
u32 resid_len,
struct fchs_s *rsp_fchs);
bfa_status_t bfa_fcs_port_loop_send_adisc_acc(struct bfa_fcs_port_s *port,
u8 alpa);
void bfa_fcs_port_loop_adisc_acc_response(void *fcsarg,
struct bfa_fcxp_s *fcxp,
void *cbarg,
bfa_status_t req_status,
u32 rsp_len,
u32 resid_len,
struct fchs_s *rsp_fchs);
static void bfa_fcs_port_loop_plogi_response(void *fcsarg,
struct bfa_fcxp_s *fcxp,
void *cbarg,
bfa_status_t req_status,
u32 rsp_len,
u32 resid_len,
struct fchs_s *rsp_fchs);
/**
* Called by port to initializar in provate LOOP topology.
*/
@ -179,7 +146,7 @@ bfa_fcs_port_loop_lip(struct bfa_fcs_port_s *port)
/**
* Local Functions.
*/
bfa_status_t
static bfa_status_t
bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
{
struct fchs_s fchs;
@ -208,7 +175,7 @@ bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
/**
* Called by fcxp to notify the Plogi response
*/
void
static void
bfa_fcs_port_loop_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
void *cbarg, bfa_status_t req_status,
u32 rsp_len, u32 resid_len,
@ -244,179 +211,3 @@ bfa_fcs_port_loop_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
bfa_assert(0);
}
}
bfa_status_t
bfa_fcs_port_loop_send_plogi_acc(struct bfa_fcs_port_s *port, u8 alpa)
{
struct fchs_s fchs;
struct bfa_fcxp_s *fcxp;
int len;
bfa_trc(port->fcs, alpa);
fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
NULL);
bfa_assert(fcxp);
len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
bfa_fcs_port_get_fcid(port), 0,
port->port_cfg.pwwn, port->port_cfg.nwwn,
bfa_pport_get_maxfrsize(port->fcs->bfa));
bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
FC_CLASS_3, len, &fchs,
bfa_fcs_port_loop_plogi_acc_response,
(void *)port, FC_MAX_PDUSZ, 0); /* No response
* expected
*/
return BFA_STATUS_OK;
}
/*
* Plogi Acc Response
* We donot do any processing here.
*/
void
bfa_fcs_port_loop_plogi_acc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
void *cbarg, bfa_status_t req_status,
u32 rsp_len, u32 resid_len,
struct fchs_s *rsp_fchs)
{
struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
bfa_trc(port->fcs, port->pid);
/*
* Sanity Checks
*/
if (req_status != BFA_STATUS_OK) {
bfa_trc(port->fcs, req_status);
return;
}
}
bfa_status_t
bfa_fcs_port_loop_send_adisc(struct bfa_fcs_port_s *port, u8 alpa)
{
struct fchs_s fchs;
struct bfa_fcxp_s *fcxp;
int len;
bfa_trc(port->fcs, alpa);
fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
NULL);
bfa_assert(fcxp);
len = fc_adisc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
bfa_fcs_port_get_fcid(port), 0,
port->port_cfg.pwwn, port->port_cfg.nwwn);
bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
FC_CLASS_3, len, &fchs,
bfa_fcs_port_loop_adisc_response, (void *)port,
FC_MAX_PDUSZ, FC_RA_TOV);
return BFA_STATUS_OK;
}
/**
* Called by fcxp to notify the ADISC response
*/
void
bfa_fcs_port_loop_adisc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
void *cbarg, bfa_status_t req_status,
u32 rsp_len, u32 resid_len,
struct fchs_s *rsp_fchs)
{
struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
struct bfa_fcs_rport_s *rport;
struct fc_adisc_s *adisc_resp;
struct fc_els_cmd_s *els_cmd;
u32 pid = rsp_fchs->s_id;
bfa_trc(port->fcs, req_status);
/*
* Sanity Checks
*/
if (req_status != BFA_STATUS_OK) {
/*
* TBD : we may need to retry certain requests
*/
bfa_fcxp_free(fcxp);
return;
}
els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
adisc_resp = (struct fc_adisc_s *) els_cmd;
if (els_cmd->els_code == FC_ELS_ACC) {
} else {
bfa_trc(port->fcs, adisc_resp->els_cmd.els_code);
/*
* TBD: we may need to check for reject codes and retry
*/
rport = bfa_fcs_port_get_rport_by_pid(port, pid);
if (rport) {
list_del(&rport->qe);
bfa_fcs_rport_delete(rport);
}
}
return;
}
bfa_status_t
bfa_fcs_port_loop_send_adisc_acc(struct bfa_fcs_port_s *port, u8 alpa)
{
struct fchs_s fchs;
struct bfa_fcxp_s *fcxp;
int len;
bfa_trc(port->fcs, alpa);
fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
NULL);
bfa_assert(fcxp);
len = fc_adisc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
bfa_fcs_port_get_fcid(port), 0,
port->port_cfg.pwwn, port->port_cfg.nwwn);
bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
FC_CLASS_3, len, &fchs,
bfa_fcs_port_loop_adisc_acc_response,
(void *)port, FC_MAX_PDUSZ, 0); /* no reponse
* expected
*/
return BFA_STATUS_OK;
}
/*
* Adisc Acc Response
* We donot do any processing here.
*/
void
bfa_fcs_port_loop_adisc_acc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
void *cbarg, bfa_status_t req_status,
u32 rsp_len, u32 resid_len,
struct fchs_s *rsp_fchs)
{
struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
bfa_trc(port->fcs, port->pid);
/*
* Sanity Checks
*/
if (req_status != BFA_STATUS_OK) {
bfa_trc(port->fcs, req_status);
return;
}
}

15
drivers/scsi/bfa/lport_api.c
View file

@ -43,7 +43,7 @@ bfa_fcs_cfg_base_port(struct bfa_fcs_s *fcs, struct bfa_port_cfg_s *port_cfg)
struct bfa_fcs_port_s *
bfa_fcs_get_base_port(struct bfa_fcs_s *fcs)
{
return (&fcs->fabric.bport);
return &fcs->fabric.bport;
}
wwn_t
@ -88,11 +88,10 @@ bfa_fcs_port_get_rport(struct bfa_fcs_port_s *port, wwn_t wwn, int index,
}
bfa_trc(fcs, i);
if (rport) {
if (rport)
return rport->pwwn;
} else {
else
return (wwn_t) 0;
}
}
void
@ -198,17 +197,17 @@ bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn)
vf = bfa_fcs_vf_lookup(fcs, vf_id);
if (vf == NULL) {
bfa_trc(fcs, vf_id);
return (NULL);
return NULL;
}
if (!lpwwn || (vf->bport.port_cfg.pwwn == lpwwn))
return (&vf->bport);
return &vf->bport;
vport = bfa_fcs_fabric_vport_lookup(vf, lpwwn);
if (vport)
return (&vport->lport);
return &vport->lport;
return (NULL);
return NULL;
}
/*

5
drivers/scsi/bfa/ns.c
View file

@ -932,11 +932,10 @@ bfa_fcs_port_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
}
ns->fcxp = fcxp;
if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port))
fc4_ftrs = FC_GS_FCP_FC4_FEATURE_INITIATOR;
} else if (BFA_FCS_VPORT_IS_TARGET_MODE(ns->port)) {
else if (BFA_FCS_VPORT_IS_TARGET_MODE(ns->port))
fc4_ftrs = FC_GS_FCP_FC4_FEATURE_TARGET;
}
len = fc_rffid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
bfa_fcs_port_get_fcid(port), 0, FC_TYPE_FCP,

2
drivers/scsi/bfa/plog.c
View file

@ -180,5 +180,5 @@ bfa_plog_disable(struct bfa_plog_s *plog)
bfa_boolean_t
bfa_plog_get_setting(struct bfa_plog_s *plog)
{
return((bfa_boolean_t)plog->plog_enabled);
return (bfa_boolean_t)plog->plog_enabled;
}

28
drivers/scsi/bfa/rport_ftrs.c
View file

@ -79,7 +79,7 @@ bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
bfa_trc(rport->fcs, event);
switch (event) {
case RPFSM_EVENT_RPORT_ONLINE :
case RPFSM_EVENT_RPORT_ONLINE:
if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
rpf->rpsc_retries = 0;
@ -87,7 +87,7 @@ bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
break;
};
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
break;
default:
@ -107,7 +107,7 @@ bfa_fcs_rpf_sm_rpsc_sending(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc);
break;
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rpf->fcxp_wqe);
rpf->rpsc_retries = 0;
@ -130,11 +130,10 @@ bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
case RPFSM_EVENT_RPSC_COMP:
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_online);
/* Update speed info in f/w via BFA */
if (rpf->rpsc_speed != BFA_PPORT_SPEED_UNKNOWN) {
if (rpf->rpsc_speed != BFA_PPORT_SPEED_UNKNOWN)
bfa_rport_speed(rport->bfa_rport, rpf->rpsc_speed);
} else if (rpf->assigned_speed != BFA_PPORT_SPEED_UNKNOWN) {
else if (rpf->assigned_speed != BFA_PPORT_SPEED_UNKNOWN)
bfa_rport_speed(rport->bfa_rport, rpf->assigned_speed);
}
break;
case RPFSM_EVENT_RPSC_FAIL:
@ -154,7 +153,7 @@ bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
}
break;
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
bfa_fcxp_discard(rpf->fcxp);
rpf->rpsc_retries = 0;
@ -174,13 +173,13 @@ bfa_fcs_rpf_sm_rpsc_retry(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
bfa_trc(rport->fcs, event);
switch (event) {
case RPFSM_EVENT_TIMEOUT :
case RPFSM_EVENT_TIMEOUT:
/* re-send the RPSC */
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
bfa_fcs_rpf_send_rpsc2(rpf, NULL);
break;
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
bfa_timer_stop(&rpf->timer);
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
rpf->rpsc_retries = 0;
@ -201,7 +200,7 @@ bfa_fcs_rpf_sm_online(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
bfa_trc(rport->fcs, event);
switch (event) {
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
rpf->rpsc_retries = 0;
break;
@ -221,12 +220,12 @@ bfa_fcs_rpf_sm_offline(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
bfa_trc(rport->fcs, event);
switch (event) {
case RPFSM_EVENT_RPORT_ONLINE :
case RPFSM_EVENT_RPORT_ONLINE:
bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
bfa_fcs_rpf_send_rpsc2(rpf, NULL);
break;
case RPFSM_EVENT_RPORT_OFFLINE :
case RPFSM_EVENT_RPORT_OFFLINE:
break;
default:
@ -366,10 +365,9 @@ bfa_fcs_rpf_rpsc2_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
bfa_trc(rport->fcs, ls_rjt->reason_code);
bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
rport->stats.rpsc_rejects++;
if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP) {
if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP)
bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_FAIL);
} else {
else
bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_ERROR);
}
}
}

2
drivers/scsi/bfa/vfapi.c
View file

@ -189,7 +189,7 @@ bfa_fcs_vf_lookup(struct bfa_fcs_s *fcs, u16 vf_id)
{
bfa_trc(fcs, vf_id);
if (vf_id == FC_VF_ID_NULL)
return (&fcs->fabric);
return &fcs->fabric;
/**
* @todo vf support

20
drivers/scsi/bfa/vport.c
View file

@ -31,13 +31,13 @@
BFA_TRC_FILE(FCS, VPORT);
#define __vport_fcs(__vp) (__vp)->lport.fcs
#define __vport_pwwn(__vp) (__vp)->lport.port_cfg.pwwn
#define __vport_nwwn(__vp) (__vp)->lport.port_cfg.nwwn
#define __vport_bfa(__vp) (__vp)->lport.fcs->bfa
#define __vport_fcid(__vp) (__vp)->lport.pid
#define __vport_fabric(__vp) (__vp)->lport.fabric
#define __vport_vfid(__vp) (__vp)->lport.fabric->vf_id
#define __vport_fcs(__vp) ((__vp)->lport.fcs)
#define __vport_pwwn(__vp) ((__vp)->lport.port_cfg.pwwn)
#define __vport_nwwn(__vp) ((__vp)->lport.port_cfg.nwwn)
#define __vport_bfa(__vp) ((__vp)->lport.fcs->bfa)
#define __vport_fcid(__vp) ((__vp)->lport.pid)
#define __vport_fabric(__vp) ((__vp)->lport.fabric)
#define __vport_vfid(__vp) ((__vp)->lport.fabric->vf_id)
#define BFA_FCS_VPORT_MAX_RETRIES 5
/*
@ -641,9 +641,9 @@ bfa_fcs_vport_get_max(struct bfa_fcs_s *fcs)
bfa_get_attr(fcs->bfa, &ioc_attr);
if (ioc_attr.pci_attr.device_id == BFA_PCI_DEVICE_ID_CT)
return (BFA_FCS_MAX_VPORTS_SUPP_CT);
return BFA_FCS_MAX_VPORTS_SUPP_CT;
else
return (BFA_FCS_MAX_VPORTS_SUPP_CB);
return BFA_FCS_MAX_VPORTS_SUPP_CB;
}
@ -675,7 +675,7 @@ bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
struct bfad_vport_s *vport_drv)
{
if (vport_cfg->pwwn == 0)
return (BFA_STATUS_INVALID_WWN);
return BFA_STATUS_INVALID_WWN;
if (bfa_fcs_port_get_pwwn(&fcs->fabric.bport) == vport_cfg->pwwn)
return BFA_STATUS_VPORT_WWN_BP;