AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity

[SCSI] bfa: Modified the portstats get/clear logic

Browse Source 
Modified the portstats get/clear logic for port physical/FCoE/QoS stats.
Added more stats to FC
Fixed some issues with FCoE stats collection.

Signed-off-by: Krishna Gudipati <kgudipat@brocade.com>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
This commit is contained in:
Krishna Gudipati 2010-03-05 19:38:07 -08:00 committed by James Bottomley
parent 0a4b1fc0b2
commit ca8b4327e4
7 changed files with 417 additions and 718 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

756
drivers/scsi/bfa/bfa_fcport.c
View File

@ -47,16 +47,10 @@ static void bfa_fcport_callback(struct bfa_fcport_s *fcport,
enum bfa_pport_linkstate event); enum bfa_pport_linkstate event);
static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, static void bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
enum bfa_pport_linkstate event); enum bfa_pport_linkstate event);
static void __bfa_cb_fcport_stats(void *cbarg, bfa_boolean_t complete);
static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete); static void __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
static void bfa_fcport_stats_timeout(void *cbarg); static void bfa_fcport_stats_get_timeout(void *cbarg);
static void bfa_fcport_stats_clr_timeout(void *cbarg); static void bfa_fcport_stats_clr_timeout(void *cbarg);
static void __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete);
static void __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete);
static void bfa_port_stats_timeout(void *cbarg);
static void bfa_port_stats_clr_timeout(void *cbarg);
/** /**
* bfa_pport_private * bfa_pport_private
*/ */
@ -303,7 +297,7 @@ static void
bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport, bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
enum bfa_fcport_sm_event event) enum bfa_fcport_sm_event event)
{ {
struct bfi_pport_event_s *pevent = fcport->event_arg.i2hmsg.event; struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
bfa_trc(fcport->bfa, event); bfa_trc(fcport->bfa, event);
switch (event) { switch (event) {
@ -819,8 +813,32 @@ __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION); bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
} }
#define PPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \ static void
BFA_CACHELINE_SZ)) bfa_fcport_callback(struct bfa_fcport_s *fcport, enum bfa_pport_linkstate event)
{
if (fcport->bfa->fcs) {
fcport->event_cbfn(fcport->event_cbarg, event);
return;
}
switch (event) {
case BFA_PPORT_LINKUP:
bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
break;
case BFA_PPORT_LINKDOWN:
bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
break;
default:
bfa_assert(0);
}
}
static void
bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_pport_linkstate event)
{
ln->ln_event = event;
bfa_cb_queue(ln->fcport->bfa, &ln->ln_qe, __bfa_cb_fcport_event, ln);
}
#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \ #define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
BFA_CACHELINE_SZ)) BFA_CACHELINE_SZ))
@ -829,8 +847,7 @@ static void
bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len, bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
u32 *dm_len) u32 *dm_len)
{ {
*dm_len += PPORT_STATS_DMA_SZ; *dm_len += FCPORT_STATS_DMA_SZ;
*dm_len += PPORT_STATS_DMA_SZ;
} }
static void static void
@ -852,16 +869,7 @@ bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
fcport->stats_kva = dm_kva; fcport->stats_kva = dm_kva;
fcport->stats_pa = dm_pa; fcport->stats_pa = dm_pa;
fcport->stats = (union bfa_pport_stats_u *)dm_kva; fcport->stats = (union bfa_fcport_stats_u *)dm_kva;
dm_kva += PPORT_STATS_DMA_SZ;
dm_pa += PPORT_STATS_DMA_SZ;
/* FC port stats */
fcport->fcport_stats_kva = dm_kva;
fcport->fcport_stats_pa = dm_pa;
fcport->fcport_stats = (union bfa_fcport_stats_u *) dm_kva;
dm_kva += FCPORT_STATS_DMA_SZ; dm_kva += FCPORT_STATS_DMA_SZ;
dm_pa += FCPORT_STATS_DMA_SZ; dm_pa += FCPORT_STATS_DMA_SZ;
@ -957,7 +965,7 @@ bfa_fcport_iocdisable(struct bfa_s *bfa)
static void static void
bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport) bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
{ {
struct bfi_pport_event_s *pevent = fcport->event_arg.i2hmsg.event; struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
fcport->speed = pevent->link_state.speed; fcport->speed = pevent->link_state.speed;
fcport->topology = pevent->link_state.topology; fcport->topology = pevent->link_state.topology;
@ -989,7 +997,7 @@ bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
static bfa_boolean_t static bfa_boolean_t
bfa_fcport_send_enable(struct bfa_fcport_s *fcport) bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
{ {
struct bfi_pport_enable_req_s *m; struct bfi_fcport_enable_req_s *m;
/** /**
* Increment message tag before queue check, so that responses to old * Increment message tag before queue check, so that responses to old
@ -1007,15 +1015,14 @@ bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
return BFA_FALSE; return BFA_FALSE;
} }
bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_ENABLE_REQ, bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
bfa_lpuid(fcport->bfa)); bfa_lpuid(fcport->bfa));
m->nwwn = fcport->nwwn; m->nwwn = fcport->nwwn;
m->pwwn = fcport->pwwn; m->pwwn = fcport->pwwn;
m->port_cfg = fcport->cfg; m->port_cfg = fcport->cfg;
m->msgtag = fcport->msgtag; m->msgtag = fcport->msgtag;
m->port_cfg.maxfrsize = bfa_os_htons(fcport->cfg.maxfrsize); m->port_cfg.maxfrsize = bfa_os_htons(fcport->cfg.maxfrsize);
bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa); bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
bfa_dma_be_addr_set(m->fcport_stats_dma_addr, fcport->fcport_stats_pa);
bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo); bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi); bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
@ -1032,7 +1039,7 @@ bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
static bfa_boolean_t static bfa_boolean_t
bfa_fcport_send_disable(struct bfa_fcport_s *fcport) bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
{ {
bfi_pport_disable_req_t *m; struct bfi_fcport_req_s *m;
/** /**
* Increment message tag before queue check, so that responses to old * Increment message tag before queue check, so that responses to old
@ -1050,8 +1057,8 @@ bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
return BFA_FALSE; return BFA_FALSE;
} }
bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_DISABLE_REQ, bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
bfa_lpuid(fcport->bfa)); bfa_lpuid(fcport->bfa));
m->msgtag = fcport->msgtag; m->msgtag = fcport->msgtag;
/** /**
@ -1077,7 +1084,7 @@ bfa_fcport_send_txcredit(void *port_cbarg)
{ {
struct bfa_fcport_s *fcport = port_cbarg; struct bfa_fcport_s *fcport = port_cbarg;
struct bfi_pport_set_svc_params_req_s *m; struct bfi_fcport_set_svc_params_req_s *m;
/** /**
* check for room in queue to send request now * check for room in queue to send request now
@ -1088,8 +1095,8 @@ bfa_fcport_send_txcredit(void *port_cbarg)
return; return;
} }
bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_SET_SVC_PARAMS_REQ, bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
bfa_lpuid(fcport->bfa)); bfa_lpuid(fcport->bfa));
m->tx_bbcredit = bfa_os_htons((u16) fcport->cfg.tx_bbcredit); m->tx_bbcredit = bfa_os_htons((u16) fcport->cfg.tx_bbcredit);
/** /**
@ -1098,7 +1105,158 @@ bfa_fcport_send_txcredit(void *port_cbarg)
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT); bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
} }
static void
bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
struct bfa_qos_stats_s *s)
{
u32 *dip = (u32 *) d;
u32 *sip = (u32 *) s;
int i;
/* Now swap the 32 bit fields */
for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
dip[i] = bfa_os_ntohl(sip[i]);
}
static void
bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
struct bfa_fcoe_stats_s *s)
{
u32 *dip = (u32 *) d;
u32 *sip = (u32 *) s;
int i;
for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
i = i + 2) {
#ifdef __BIGENDIAN
dip[i] = bfa_os_ntohl(sip[i]);
dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
#else
dip[i] = bfa_os_ntohl(sip[i + 1]);
dip[i + 1] = bfa_os_ntohl(sip[i]);
#endif
}
}
static void
__bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
if (fcport->stats_status == BFA_STATUS_OK) {
/* Swap FC QoS or FCoE stats */
if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
bfa_fcport_qos_stats_swap(
&fcport->stats_ret->fcqos,
&fcport->stats->fcqos);
else
bfa_fcport_fcoe_stats_swap(
&fcport->stats_ret->fcoe,
&fcport->stats->fcoe);
}
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
bfa_fcport_stats_get_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
fcport);
}
static void
bfa_fcport_send_stats_get(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
struct bfi_fcport_req_s *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait,
bfa_fcport_send_stats_get, fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
bfa_fcport_stats_clr_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
__bfa_cb_fcport_stats_clr, fcport);
}
static void
bfa_fcport_send_stats_clear(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
struct bfi_fcport_req_s *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait,
bfa_fcport_send_stats_clear, fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
/** /**
* bfa_pport_public * bfa_pport_public
@ -1111,23 +1269,23 @@ void
bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg) bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
{ {
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
union bfi_pport_i2h_msg_u i2hmsg; union bfi_fcport_i2h_msg_u i2hmsg;
i2hmsg.msg = msg; i2hmsg.msg = msg;
fcport->event_arg.i2hmsg = i2hmsg; fcport->event_arg.i2hmsg = i2hmsg;
switch (msg->mhdr.msg_id) { switch (msg->mhdr.msg_id) {
case BFI_PPORT_I2H_ENABLE_RSP: case BFI_FCPORT_I2H_ENABLE_RSP:
if (fcport->msgtag == i2hmsg.enable_rsp->msgtag) if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP); bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
break; break;
case BFI_PPORT_I2H_DISABLE_RSP: case BFI_FCPORT_I2H_DISABLE_RSP:
if (fcport->msgtag == i2hmsg.enable_rsp->msgtag) if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP); bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
break; break;
case BFI_PPORT_I2H_EVENT: case BFI_FCPORT_I2H_EVENT:
switch (i2hmsg.event->link_state.linkstate) { switch (i2hmsg.event->link_state.linkstate) {
case BFA_PPORT_LINKUP: case BFA_PPORT_LINKUP:
bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP); bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
@ -1141,58 +1299,27 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
} }
break; break;
case BFI_PPORT_I2H_GET_STATS_RSP: case BFI_FCPORT_I2H_STATS_GET_RSP:
case BFI_PPORT_I2H_GET_QOS_STATS_RSP:
/*
* check for timer pop before processing the rsp
*/
if (fcport->stats_busy == BFA_FALSE
|| fcport->stats_status == BFA_STATUS_ETIMER)
break;
bfa_timer_stop(&fcport->timer);
fcport->stats_status = i2hmsg.getstats_rsp->status;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_port_stats,
fcport);
break;
case BFI_PPORT_I2H_CLEAR_STATS_RSP:
case BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP:
/*
* check for timer pop before processing the rsp
*/
if (fcport->stats_busy == BFA_FALSE
|| fcport->stats_status == BFA_STATUS_ETIMER)
break;
bfa_timer_stop(&fcport->timer);
fcport->stats_status = BFA_STATUS_OK;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
__bfa_cb_port_stats_clr, fcport);
break;
case BFI_FCPORT_I2H_GET_STATS_RSP:
/* /*
* check for timer pop before processing the rsp * check for timer pop before processing the rsp
*/ */
if (fcport->stats_busy == BFA_FALSE || if (fcport->stats_busy == BFA_FALSE ||
fcport->stats_status == BFA_STATUS_ETIMER) { fcport->stats_status == BFA_STATUS_ETIMER)
break; break;
}
bfa_timer_stop(&fcport->timer); bfa_timer_stop(&fcport->timer);
fcport->stats_status = i2hmsg.getstats_rsp->status; fcport->stats_status = i2hmsg.pstatsget_rsp->status;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
__bfa_cb_fcport_stats, fcport); __bfa_cb_fcport_stats_get, fcport);
break; break;
case BFI_FCPORT_I2H_CLEAR_STATS_RSP: case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
/* /*
* check for timer pop before processing the rsp * check for timer pop before processing the rsp
*/ */
if (fcport->stats_busy == BFA_FALSE || if (fcport->stats_busy == BFA_FALSE ||
fcport->stats_status == BFA_STATUS_ETIMER) { fcport->stats_status == BFA_STATUS_ETIMER)
break; break;
}
bfa_timer_stop(&fcport->timer); bfa_timer_stop(&fcport->timer);
fcport->stats_status = BFA_STATUS_OK; fcport->stats_status = BFA_STATUS_OK;
@ -1206,8 +1333,6 @@ bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
} }
} }
/** /**
* bfa_pport_api * bfa_pport_api
*/ */
@ -1472,329 +1597,13 @@ bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
attr->port_state = BFA_PPORT_ST_FWMISMATCH; attr->port_state = BFA_PPORT_ST_FWMISMATCH;
} }
static void #define BFA_FCPORT_STATS_TOV 1000
bfa_port_stats_query(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
bfi_pport_get_stats_req_t *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait, bfa_port_stats_query,
fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_GET_STATS_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
bfa_port_stats_clear(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
bfi_pport_clear_stats_req_t *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait, bfa_port_stats_clear,
fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_STATS_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
bfa_fcport_stats_query(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfi_pport_get_stats_req_t *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait,
bfa_fcport_stats_query, fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_FCPORT_H2I_GET_STATS_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
bfa_fcport_stats_clear(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfi_pport_clear_stats_req_t *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait,
bfa_fcport_stats_clear, fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_FCPORT_H2I_CLEAR_STATS_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
bfa_port_qos_stats_clear(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
bfi_pport_clear_qos_stats_req_t *msg;
msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
if (!msg) {
fcport->stats_qfull = BFA_TRUE;
bfa_reqq_winit(&fcport->stats_reqq_wait,
bfa_port_qos_stats_clear, fcport);
bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
&fcport->stats_reqq_wait);
return;
}
fcport->stats_qfull = BFA_FALSE;
bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_qos_stats_req_t));
bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ,
bfa_lpuid(fcport->bfa));
bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
}
static void
bfa_fcport_stats_swap(union bfa_fcport_stats_u *d, union bfa_fcport_stats_u *s)
{
u32 *dip = (u32 *) d;
u32 *sip = (u32 *) s;
int i;
/* Do 64 bit fields swap first */
for (i = 0; i < ((sizeof(union bfa_fcport_stats_u) -
sizeof(struct bfa_qos_stats_s))/sizeof(u32)); i = i + 2) {
#ifdef __BIGENDIAN
dip[i] = bfa_os_ntohl(sip[i]);
dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
#else
dip[i] = bfa_os_ntohl(sip[i + 1]);
dip[i + 1] = bfa_os_ntohl(sip[i]);
#endif
}
/* Now swap the 32 bit fields */
for (; i < (sizeof(union bfa_fcport_stats_u)/sizeof(u32)); ++i)
dip[i] = bfa_os_ntohl(sip[i]);
}
static void
bfa_port_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s)
{
u32 *dip = (u32 *) d;
u32 *sip = (u32 *) s;
int i;
/* Do 64 bit fields swap first */
for (i = 0; i < (sizeof(union bfa_pport_stats_u) / sizeof(u32));
i = i + 2) {
#ifdef __BIGENDIAN
dip[i] = bfa_os_ntohl(sip[i]);
dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
#else
dip[i] = bfa_os_ntohl(sip[i + 1]);
dip[i + 1] = bfa_os_ntohl(sip[i]);
#endif
}
}
static void
__bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
bfa_port_stats_clr_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
__bfa_cb_port_stats_clr, fcport);
}
static void
bfa_fcport_callback(struct bfa_fcport_s *fcport, enum bfa_pport_linkstate event)
{
if (fcport->bfa->fcs) {
fcport->event_cbfn(fcport->event_cbarg, event);
return;
}
switch (event) {
case BFA_PPORT_LINKUP:
bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
break;
case BFA_PPORT_LINKDOWN:
bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
break;
default:
bfa_assert(0);
}
}
static void
bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_pport_linkstate event)
{
ln->ln_event = event;
bfa_cb_queue(ln->fcport->bfa, &ln->ln_qe, __bfa_cb_fcport_event, ln);
}
static void
bfa_fcport_stats_clr_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_clr,
fcport);
}
static void
__bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
if (fcport->stats_status == BFA_STATUS_OK)
bfa_port_stats_swap(fcport->stats_ret, fcport->stats);
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
bfa_port_stats_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *)cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_port_stats, fcport);
}
static void
__bfa_cb_fcport_stats(void *cbarg, bfa_boolean_t complete)
{
struct bfa_fcport_s *fcport = cbarg;
if (complete) {
if (fcport->stats_status == BFA_STATUS_OK) {
bfa_fcport_stats_swap(fcport->fcport_stats_ret,
fcport->fcport_stats);
}
fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
} else {
fcport->stats_busy = BFA_FALSE;
fcport->stats_status = BFA_STATUS_OK;
}
}
static void
bfa_fcport_stats_timeout(void *cbarg)
{
struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
bfa_trc(fcport->bfa, fcport->stats_qfull);
if (fcport->stats_qfull) {
bfa_reqq_wcancel(&fcport->stats_reqq_wait);
fcport->stats_qfull = BFA_FALSE;
}
fcport->stats_status = BFA_STATUS_ETIMER;
bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats,
fcport);
}
#define BFA_PORT_STATS_TOV 1000
/** /**
* Fetch port attributes. * Fetch port attributes (FCQoS or FCoE).
*/ */
bfa_status_t bfa_status_t
bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats, bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg) bfa_cb_pport_t cbfn, void *cbarg)
{ {
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa); struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
@ -1804,71 +1613,21 @@ bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
return BFA_STATUS_DEVBUSY; return BFA_STATUS_DEVBUSY;
} }
fcport->stats_busy = BFA_TRUE; fcport->stats_busy = BFA_TRUE;
fcport->stats_ret = stats; fcport->stats_ret = stats;
fcport->stats_cbfn = cbfn; fcport->stats_cbfn = cbfn;
fcport->stats_cbarg = cbarg; fcport->stats_cbarg = cbarg;
bfa_port_stats_query(fcport); bfa_fcport_send_stats_get(fcport);
bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_timeout, fcport, bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
BFA_PORT_STATS_TOV); fcport, BFA_FCPORT_STATS_TOV);
return BFA_STATUS_OK;
}
bfa_status_t
bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
{
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
if (fcport->stats_busy) {
bfa_trc(bfa, fcport->stats_busy);
return BFA_STATUS_DEVBUSY;
}
fcport->stats_busy = BFA_TRUE;
fcport->stats_cbfn = cbfn;
fcport->stats_cbarg = cbarg;
bfa_port_stats_clear(fcport);
bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_clr_timeout,
fcport, BFA_PORT_STATS_TOV);
return BFA_STATUS_OK; return BFA_STATUS_OK;
} }
/** /**
* @brief * Reset port statistics (FCQoS or FCoE).
* Fetch FCPort statistics.
* Todo TBD: sharing timer,stats_busy and other resources of fcport for now -
* ideally we want to create seperate ones for fcport once bfa_fcport_s is
* decided.
*
*/ */
bfa_status_t
bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg)
{
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
if (fcport->stats_busy) {
bfa_trc(bfa, fcport->stats_busy);
return BFA_STATUS_DEVBUSY;
}
fcport->stats_busy = BFA_TRUE;
fcport->fcport_stats_ret = stats;
fcport->stats_cbfn = cbfn;
fcport->stats_cbarg = cbarg;
bfa_fcport_stats_query(fcport);
bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_timeout, fcport,
BFA_PORT_STATS_TOV);
return BFA_STATUS_OK;
}
bfa_status_t bfa_status_t
bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg) bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
{ {
@ -1883,14 +1642,63 @@ bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
fcport->stats_cbfn = cbfn; fcport->stats_cbfn = cbfn;
fcport->stats_cbarg = cbarg; fcport->stats_cbarg = cbarg;
bfa_fcport_stats_clear(fcport); bfa_fcport_send_stats_clear(fcport);
bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout, bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
fcport, BFA_PORT_STATS_TOV); fcport, BFA_FCPORT_STATS_TOV);
return BFA_STATUS_OK; return BFA_STATUS_OK;
} }
/**
* Fetch FCQoS port statistics
*/
bfa_status_t
bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg)
{
/* Meaningful only for FC mode */
bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
}
/**
* Reset FCoE port statistics
*/
bfa_status_t
bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
{
/* Meaningful only for FC mode */
bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
}
/**
* Fetch FCQoS port statistics
*/
bfa_status_t
bfa_fcport_get_fcoe_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg)
{
/* Meaningful only for FCoE mode */
bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
}
/**
* Reset FCoE port statistics
*/
bfa_status_t
bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
{
/* Meaningful only for FCoE mode */
bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
}
bfa_status_t bfa_status_t
bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap) bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
{ {
@ -1945,40 +1753,6 @@ bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
} }
} }
/**
* Fetch QoS Stats.
*/
bfa_status_t
bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg)
{
/*
* QoS stats is embedded in port stats
*/
return bfa_pport_get_stats(bfa, stats, cbfn, cbarg);
}
bfa_status_t
bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
{
struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
if (fcport->stats_busy) {
bfa_trc(bfa, fcport->stats_busy);
return BFA_STATUS_DEVBUSY;
}
fcport->stats_busy = BFA_TRUE;
fcport->stats_cbfn = cbfn;
fcport->stats_cbarg = cbarg;
bfa_port_qos_stats_clear(fcport);
bfa_timer_start(bfa, &fcport->timer, bfa_port_stats_clr_timeout,
fcport, BFA_PORT_STATS_TOV);
return BFA_STATUS_OK;
}
/** /**
* Fetch port attributes. * Fetch port attributes.
*/ */

41
drivers/scsi/bfa/bfa_port_priv.h
View File

@ -46,6 +46,8 @@ struct bfa_fcport_s {
enum bfa_pport_topology topology; /* current topology */ enum bfa_pport_topology topology; /* current topology */
u8 myalpa; /* my ALPA in LOOP topology */ u8 myalpa; /* my ALPA in LOOP topology */
u8 rsvd[3]; u8 rsvd[3];
u32 mypid:24;
u32 rsvd_b:8;
struct bfa_pport_cfg_s cfg; /* current port configuration */ struct bfa_pport_cfg_s cfg; /* current port configuration */
struct bfa_qos_attr_s qos_attr; /* QoS Attributes */ struct bfa_qos_attr_s qos_attr; /* QoS Attributes */
struct bfa_qos_vc_attr_s qos_vc_attr; /* VC info from ELP */ struct bfa_qos_vc_attr_s qos_vc_attr; /* VC info from ELP */
@ -59,40 +61,25 @@ struct bfa_fcport_s {
void (*event_cbfn) (void *cbarg, void (*event_cbfn) (void *cbarg,
bfa_pport_event_t event); bfa_pport_event_t event);
union { union {
union bfi_pport_i2h_msg_u i2hmsg; union bfi_fcport_i2h_msg_u i2hmsg;
} event_arg; } event_arg;
void *bfad; /* BFA driver handle */ void *bfad; /* BFA driver handle */
struct bfa_fcport_ln_s ln; /* Link Notification */ struct bfa_fcport_ln_s ln; /* Link Notification */
struct bfa_cb_qe_s hcb_qe; /* BFA callback queue elem */ struct bfa_cb_qe_s hcb_qe; /* BFA callback queue elem */
struct bfa_timer_s timer; /* timer */
u32 msgtag; /* fimrware msg tag for reply */ u32 msgtag; /* fimrware msg tag for reply */
u8 *stats_kva; u8 *stats_kva;
u64 stats_pa; u64 stats_pa;
union bfa_pport_stats_u *stats; /* pport stats */ union bfa_fcport_stats_u *stats;
u32 mypid:24; union bfa_fcport_stats_u *stats_ret; /* driver stats location */
u32 rsvd_b:8; bfa_status_t stats_status; /* stats/statsclr status */
struct bfa_timer_s timer; /* timer */ bfa_boolean_t stats_busy; /* outstanding stats/statsclr */
union bfa_pport_stats_u *stats_ret; bfa_boolean_t stats_qfull;
/* driver stats location */ bfa_cb_pport_t stats_cbfn; /* driver callback function */
bfa_status_t stats_status; void *stats_cbarg; /* *!< user callback arg */
/* stats/statsclr status */ bfa_boolean_t diag_busy; /* diag busy status */
bfa_boolean_t stats_busy; bfa_boolean_t beacon; /* port beacon status */
/* outstanding stats/statsclr */ bfa_boolean_t link_e2e_beacon; /* link beacon status */
bfa_boolean_t stats_qfull;
bfa_boolean_t diag_busy;
/* diag busy status */
bfa_boolean_t beacon;
/* port beacon status */
bfa_boolean_t link_e2e_beacon;
/* link beacon status */
bfa_cb_pport_t stats_cbfn;
/* driver callback function */
void *stats_cbarg;
/* *!< user callback arg */
/* FCport stats */
u8 *fcport_stats_kva;
u64 fcport_stats_pa;
union bfa_fcport_stats_u *fcport_stats;
union bfa_fcport_stats_u *fcport_stats_ret;
}; };
#define BFA_FCPORT_MOD(__bfa) (&(__bfa)->modules.fcport) #define BFA_FCPORT_MOD(__bfa) (&(__bfa)->modules.fcport)

5
drivers/scsi/bfa/bfad_attr.c
View File

@ -288,7 +288,7 @@ bfad_im_get_stats(struct Scsi_Host *shost)
init_completion(&fcomp.comp); init_completion(&fcomp.comp);
spin_lock_irqsave(&bfad->bfad_lock, flags); spin_lock_irqsave(&bfad->bfad_lock, flags);
memset(hstats, 0, sizeof(struct fc_host_statistics)); memset(hstats, 0, sizeof(struct fc_host_statistics));
rc = bfa_pport_get_stats(&bfad->bfa, rc = bfa_port_get_stats(BFA_FCPORT(&bfad->bfa),
(union bfa_pport_stats_u *) hstats, (union bfa_pport_stats_u *) hstats,
bfad_hcb_comp, &fcomp); bfad_hcb_comp, &fcomp);
spin_unlock_irqrestore(&bfad->bfad_lock, flags); spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@ -315,7 +315,8 @@ bfad_im_reset_stats(struct Scsi_Host *shost)
init_completion(&fcomp.comp); init_completion(&fcomp.comp);
spin_lock_irqsave(&bfad->bfad_lock, flags); spin_lock_irqsave(&bfad->bfad_lock, flags);
rc = bfa_pport_clear_stats(&bfad->bfa, bfad_hcb_comp, &fcomp); rc = bfa_port_clear_stats(BFA_FCPORT(&bfad->bfa), bfad_hcb_comp,
&fcomp);
spin_unlock_irqrestore(&bfad->bfad_lock, flags); spin_unlock_irqrestore(&bfad->bfad_lock, flags);
if (rc != BFA_STATUS_OK) if (rc != BFA_STATUS_OK)

24
drivers/scsi/bfa/include/bfa_svc.h
View File

@ -36,7 +36,7 @@ struct bfa_fcxp_s;
struct bfa_rport_info_s { struct bfa_rport_info_s {
u16 max_frmsz; /* max rcv pdu size */ u16 max_frmsz; /* max rcv pdu size */
u32 pid:24, /* remote port ID */ u32 pid:24, /* remote port ID */
lp_tag:8; lp_tag:8; /* tag */
u32 local_pid:24, /* local port ID */ u32 local_pid:24, /* local port ID */
cisc:8; /* CIRO supported */ cisc:8; /* CIRO supported */
u8 fc_class; /* supported FC classes. enum fc_cos */ u8 fc_class; /* supported FC classes. enum fc_cos */
@ -55,7 +55,7 @@ struct bfa_rport_s {
void *rport_drv; /* fcs/driver rport object */ void *rport_drv; /* fcs/driver rport object */
u16 fw_handle; /* firmware rport handle */ u16 fw_handle; /* firmware rport handle */
u16 rport_tag; /* BFA rport tag */ u16 rport_tag; /* BFA rport tag */
struct bfa_rport_info_s rport_info; /* rport info from *fcs/driver */ struct bfa_rport_info_s rport_info; /* rport info from fcs/driver */
struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */ struct bfa_reqq_wait_s reqq_wait; /* to wait for room in reqq */
struct bfa_cb_qe_s hcb_qe; /* BFA callback qelem */ struct bfa_cb_qe_s hcb_qe; /* BFA callback qelem */
struct bfa_rport_hal_stats_s stats; /* BFA rport statistics */ struct bfa_rport_hal_stats_s stats; /* BFA rport statistics */
@ -102,7 +102,7 @@ struct bfa_uf_buf_s {
struct bfa_uf_s { struct bfa_uf_s {
struct list_head qe; /* queue element */ struct list_head qe; /* queue element */
struct bfa_s *bfa; /* bfa instance */ struct bfa_s *bfa; /* bfa instance */
u16 uf_tag; /* identifying tag f/w messages */ u16 uf_tag; /* identifying tag fw msgs */
u16 vf_id; u16 vf_id;
u16 src_rport_handle; u16 src_rport_handle;
u16 rsvd; u16 rsvd;
@ -128,7 +128,7 @@ struct bfa_lps_s {
u8 reqq; /* lport request queue */ u8 reqq; /* lport request queue */
u8 alpa; /* ALPA for loop topologies */ u8 alpa; /* ALPA for loop topologies */
u32 lp_pid; /* lport port ID */ u32 lp_pid; /* lport port ID */
bfa_boolean_t fdisc; /* send FDISC instead of FLOGI*/ bfa_boolean_t fdisc; /* send FDISC instead of FLOGI */
bfa_boolean_t auth_en; /* enable authentication */ bfa_boolean_t auth_en; /* enable authentication */
bfa_boolean_t auth_req; /* authentication required */ bfa_boolean_t auth_req; /* authentication required */
bfa_boolean_t npiv_en; /* NPIV is allowed by peer */ bfa_boolean_t npiv_en; /* NPIV is allowed by peer */
@ -178,11 +178,6 @@ bfa_status_t bfa_fcport_trunk_disable(struct bfa_s *bfa);
bfa_boolean_t bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap); bfa_boolean_t bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap);
void bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr); void bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr);
wwn_t bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node); wwn_t bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node);
bfa_status_t bfa_pport_get_stats(struct bfa_s *bfa,
union bfa_pport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg);
bfa_status_t bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
void *cbarg);
void bfa_fcport_event_register(struct bfa_s *bfa, void bfa_fcport_event_register(struct bfa_s *bfa,
void (*event_cbfn) (void *cbarg, void (*event_cbfn) (void *cbarg,
bfa_pport_event_t event), void *event_cbarg); bfa_pport_event_t event), void *event_cbarg);
@ -198,14 +193,21 @@ void bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status);
void bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon, void bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
bfa_boolean_t link_e2e_beacon); bfa_boolean_t link_e2e_beacon);
void bfa_cb_pport_event(void *cbarg, bfa_pport_event_t event); void bfa_cb_pport_event(void *cbarg, bfa_pport_event_t event);
void bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr); void bfa_fcport_qos_get_attr(struct bfa_s *bfa,
struct bfa_qos_attr_s *qos_attr);
void bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa, void bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
struct bfa_qos_vc_attr_s *qos_vc_attr); struct bfa_qos_vc_attr_s *qos_vc_attr);
bfa_status_t bfa_fcport_get_qos_stats(struct bfa_s *bfa, bfa_status_t bfa_fcport_get_qos_stats(struct bfa_s *bfa,
union bfa_pport_stats_u *stats, union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg); bfa_cb_pport_t cbfn, void *cbarg);
bfa_status_t bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, bfa_status_t bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
void *cbarg); void *cbarg);
bfa_status_t bfa_fcport_get_fcoe_stats(struct bfa_s *bfa,
union bfa_fcport_stats_u *stats,
bfa_cb_pport_t cbfn, void *cbarg);
bfa_status_t bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
void *cbarg);
bfa_boolean_t bfa_fcport_is_ratelim(struct bfa_s *bfa); bfa_boolean_t bfa_fcport_is_ratelim(struct bfa_s *bfa);
bfa_boolean_t bfa_fcport_is_linkup(struct bfa_s *bfa); bfa_boolean_t bfa_fcport_is_linkup(struct bfa_s *bfa);
bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa, bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa,

4
drivers/scsi/bfa/include/bfi/bfi.h
View File

@ -143,8 +143,8 @@ enum bfi_mclass {
BFI_MC_IOC = 1, /* IO Controller (IOC) */ BFI_MC_IOC = 1, /* IO Controller (IOC) */
BFI_MC_DIAG = 2, /* Diagnostic Msgs */ BFI_MC_DIAG = 2, /* Diagnostic Msgs */
BFI_MC_FLASH = 3, /* Flash message class */ BFI_MC_FLASH = 3, /* Flash message class */
BFI_MC_CEE = 4, BFI_MC_CEE = 4, /* CEE */
BFI_MC_FC_PORT = 5, /* FC port */ BFI_MC_FCPORT = 5, /* FC port */
BFI_MC_IOCFC = 6, /* FC - IO Controller (IOC) */ BFI_MC_IOCFC = 6, /* FC - IO Controller (IOC) */
BFI_MC_LL = 7, /* Link Layer */ BFI_MC_LL = 7, /* Link Layer */
BFI_MC_UF = 8, /* Unsolicited frame receive */ BFI_MC_UF = 8, /* Unsolicited frame receive */

177
drivers/scsi/bfa/include/bfi/bfi_pport.h
View File

@ -22,168 +22,97 @@
#pragma pack(1) #pragma pack(1)
enum bfi_pport_h2i { enum bfi_fcport_h2i {
BFI_PPORT_H2I_ENABLE_REQ = (1), BFI_FCPORT_H2I_ENABLE_REQ = (1),
BFI_PPORT_H2I_DISABLE_REQ = (2), BFI_FCPORT_H2I_DISABLE_REQ = (2),
BFI_PPORT_H2I_GET_STATS_REQ = (3), BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ = (3),
BFI_PPORT_H2I_CLEAR_STATS_REQ = (4), BFI_FCPORT_H2I_STATS_GET_REQ = (4),
BFI_PPORT_H2I_SET_SVC_PARAMS_REQ = (5), BFI_FCPORT_H2I_STATS_CLEAR_REQ = (5),
BFI_PPORT_H2I_ENABLE_RX_VF_TAG_REQ = (6),
BFI_PPORT_H2I_ENABLE_TX_VF_TAG_REQ = (7),
BFI_PPORT_H2I_GET_QOS_STATS_REQ = (8),
BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ = (9),
BFI_FCPORT_H2I_GET_STATS_REQ = (10),
BFI_FCPORT_H2I_CLEAR_STATS_REQ = (11),
}; };
enum bfi_pport_i2h { enum bfi_fcport_i2h {
BFI_PPORT_I2H_ENABLE_RSP = BFA_I2HM(1), BFI_FCPORT_I2H_ENABLE_RSP = BFA_I2HM(1),
BFI_PPORT_I2H_DISABLE_RSP = BFA_I2HM(2), BFI_FCPORT_I2H_DISABLE_RSP = BFA_I2HM(2),
BFI_PPORT_I2H_GET_STATS_RSP = BFA_I2HM(3), BFI_FCPORT_I2H_SET_SVC_PARAMS_RSP = BFA_I2HM(3),
BFI_PPORT_I2H_CLEAR_STATS_RSP = BFA_I2HM(4), BFI_FCPORT_I2H_STATS_GET_RSP = BFA_I2HM(4),
BFI_PPORT_I2H_SET_SVC_PARAMS_RSP = BFA_I2HM(5), BFI_FCPORT_I2H_STATS_CLEAR_RSP = BFA_I2HM(5),
BFI_PPORT_I2H_ENABLE_RX_VF_TAG_RSP = BFA_I2HM(6), BFI_FCPORT_I2H_EVENT = BFA_I2HM(6),
BFI_PPORT_I2H_ENABLE_TX_VF_TAG_RSP = BFA_I2HM(7),
BFI_PPORT_I2H_EVENT = BFA_I2HM(8),
BFI_PPORT_I2H_GET_QOS_STATS_RSP = BFA_I2HM(9),
BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP = BFA_I2HM(10),
BFI_FCPORT_I2H_GET_STATS_RSP = BFA_I2HM(11),
BFI_FCPORT_I2H_CLEAR_STATS_RSP = BFA_I2HM(12),
}; };
/** /**
* Generic REQ type * Generic REQ type
*/ */
struct bfi_pport_generic_req_s { struct bfi_fcport_req_s {
struct bfi_mhdr_s mh; /* msg header */ struct bfi_mhdr_s mh; /* msg header */
u32 msgtag; /* msgtag for reply */ u32 msgtag; /* msgtag for reply */
}; };
/** /**
* Generic RSP type * Generic RSP type
*/ */
struct bfi_pport_generic_rsp_s { struct bfi_fcport_rsp_s {
struct bfi_mhdr_s mh; /* common msg header */ struct bfi_mhdr_s mh; /* common msg header */
u8 status; /* port enable status */ u8 status; /* port enable status */
u8 rsvd[3]; u8 rsvd[3];
u32 msgtag; /* msgtag for reply */ u32 msgtag; /* msgtag for reply */
}; };
/** /**
* BFI_PPORT_H2I_ENABLE_REQ * BFI_FCPORT_H2I_ENABLE_REQ
*/ */
struct bfi_pport_enable_req_s { struct bfi_fcport_enable_req_s {
struct bfi_mhdr_s mh; /* msg header */ struct bfi_mhdr_s mh; /* msg header */
u32 rsvd1; u32 rsvd1;
wwn_t nwwn; /* node wwn of physical port */ wwn_t nwwn; /* node wwn of physical port */
wwn_t pwwn; /* port wwn of physical port */ wwn_t pwwn; /* port wwn of physical port */
struct bfa_pport_cfg_s port_cfg; /* port configuration */ struct bfa_pport_cfg_s port_cfg; /* port configuration */
union bfi_addr_u stats_dma_addr; /* DMA address for stats */ union bfi_addr_u stats_dma_addr; /* DMA address for stats */
union bfi_addr_u fcport_stats_dma_addr;/*!< DMA address for stats */ u32 msgtag; /* msgtag for reply */
u32 msgtag; /* msgtag for reply */ u32 rsvd2;
u32 rsvd2;
}; };
/** /**
* BFI_PPORT_I2H_ENABLE_RSP * BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ
*/ */
#define bfi_pport_enable_rsp_t struct bfi_pport_generic_rsp_s struct bfi_fcport_set_svc_params_req_s {
/**
* BFI_PPORT_H2I_DISABLE_REQ
*/
#define bfi_pport_disable_req_t struct bfi_pport_generic_req_s
/**
* BFI_PPORT_I2H_DISABLE_RSP
*/
#define bfi_pport_disable_rsp_t struct bfi_pport_generic_rsp_s
/**
* BFI_PPORT_H2I_GET_STATS_REQ
*/
#define bfi_pport_get_stats_req_t struct bfi_pport_generic_req_s
/**
* BFI_PPORT_I2H_GET_STATS_RSP
*/
#define bfi_pport_get_stats_rsp_t struct bfi_pport_generic_rsp_s
/**
* BFI_PPORT_H2I_CLEAR_STATS_REQ
*/
#define bfi_pport_clear_stats_req_t struct bfi_pport_generic_req_s
/**
* BFI_PPORT_I2H_CLEAR_STATS_RSP
*/
#define bfi_pport_clear_stats_rsp_t struct bfi_pport_generic_rsp_s
/**
* BFI_PPORT_H2I_GET_QOS_STATS_REQ
*/
#define bfi_pport_get_qos_stats_req_t struct bfi_pport_generic_req_s
/**
* BFI_PPORT_H2I_GET_QOS_STATS_RSP
*/
#define bfi_pport_get_qos_stats_rsp_t struct bfi_pport_generic_rsp_s
/**
* BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ
*/
#define bfi_pport_clear_qos_stats_req_t struct bfi_pport_generic_req_s
/**
* BFI_PPORT_H2I_CLEAR_QOS_STATS_RSP
*/
#define bfi_pport_clear_qos_stats_rsp_t struct bfi_pport_generic_rsp_s
/**
* BFI_PPORT_H2I_SET_SVC_PARAMS_REQ
*/
struct bfi_pport_set_svc_params_req_s {
struct bfi_mhdr_s mh; /* msg header */ struct bfi_mhdr_s mh; /* msg header */
u16 tx_bbcredit; /* Tx credits */ u16 tx_bbcredit; /* Tx credits */
u16 rsvd; u16 rsvd;
}; };
/** /**
* BFI_PPORT_I2H_SET_SVC_PARAMS_RSP * BFI_FCPORT_I2H_EVENT
*/ */
struct bfi_fcport_event_s {
/**
* BFI_PPORT_I2H_EVENT
*/
struct bfi_pport_event_s {
struct bfi_mhdr_s mh; /* common msg header */ struct bfi_mhdr_s mh; /* common msg header */
struct bfa_pport_link_s link_state; struct bfa_pport_link_s link_state;
}; };
union bfi_pport_h2i_msg_u { /**
* fcport H2I message
*/
union bfi_fcport_h2i_msg_u {
struct bfi_mhdr_s *mhdr; struct bfi_mhdr_s *mhdr;
struct bfi_pport_enable_req_s *penable; struct bfi_fcport_enable_req_s *penable;
struct bfi_pport_generic_req_s *pdisable; struct bfi_fcport_req_s *pdisable;
struct bfi_pport_generic_req_s *pgetstats; struct bfi_fcport_set_svc_params_req_s *psetsvcparams;
struct bfi_pport_generic_req_s *pclearstats; struct bfi_fcport_req_s *pstatsget;
struct bfi_pport_set_svc_params_req_s *psetsvcparams; struct bfi_fcport_req_s *pstatsclear;
struct bfi_pport_get_qos_stats_req_s *pgetqosstats;
struct bfi_pport_generic_req_s *pclearqosstats;
}; };
union bfi_pport_i2h_msg_u { /**
* fcport I2H message
*/
union bfi_fcport_i2h_msg_u {
struct bfi_msg_s *msg; struct bfi_msg_s *msg;
struct bfi_pport_generic_rsp_s *enable_rsp; struct bfi_fcport_rsp_s *penable_rsp;
struct bfi_pport_disable_rsp_s *disable_rsp; struct bfi_fcport_rsp_s *pdisable_rsp;
struct bfi_pport_generic_rsp_s *getstats_rsp; struct bfi_fcport_rsp_s *psetsvcparams_rsp;
struct bfi_pport_clear_stats_rsp_s *clearstats_rsp; struct bfi_fcport_rsp_s *pstatsget_rsp;
struct bfi_pport_set_svc_params_rsp_s *setsvcparasm_rsp; struct bfi_fcport_rsp_s *pstatsclear_rsp;
struct bfi_pport_get_qos_stats_rsp_s *getqosstats_rsp; struct bfi_fcport_event_s *event;
struct bfi_pport_clear_qos_stats_rsp_s *clearqosstats_rsp;
struct bfi_pport_event_s *event;
}; };
#pragma pack() #pragma pack()
#endif /* __BFI_PPORT_H__ */ #endif /* __BFI_PPORT_H__ */

128
drivers/scsi/bfa/include/defs/bfa_defs_pport.h
View File

@ -240,73 +240,79 @@ struct bfa_pport_attr_s {
* FC Port statistics. * FC Port statistics.
*/ */
struct bfa_pport_fc_stats_s { struct bfa_pport_fc_stats_s {
u64 secs_reset; /* seconds since stats is reset */ u64 secs_reset; /* Seconds since stats is reset */
u64 tx_frames; /* transmitted frames */ u64 tx_frames; /* Tx frames */
u64 tx_words; /* transmitted words */ u64 tx_words; /* Tx words */
u64 rx_frames; /* received frames */ u64 tx_lip; /* TX LIP */
u64 rx_words; /* received words */ u64 tx_nos; /* Tx NOS */
u64 lip_count; /* LIPs seen */ u64 tx_ols; /* Tx OLS */
u64 nos_count; /* NOS count */ u64 tx_lr; /* Tx LR */
u64 error_frames; /* errored frames */ u64 tx_lrr; /* Tx LRR */
u64 dropped_frames; /* dropped frames */ u64 rx_frames; /* Rx frames */
u64 link_failures; /* link failure count */ u64 rx_words; /* Rx words */
u64 loss_of_syncs; /* loss of sync count */ u64 lip_count; /* Rx LIP */
u64 loss_of_signals;/* loss of signal count */ u64 nos_count; /* Rx NOS */
u64 primseq_errs; /* primitive sequence protocol */ u64 ols_count; /* Rx OLS */
u64 bad_os_count; /* invalid ordered set */ u64 lr_count; /* Rx LR */
u64 err_enc_out; /* Encoding error outside frame */ u64 lrr_count; /* Rx LRR */
u64 invalid_crcs; /* frames received with invalid CRC*/ u64 invalid_crcs; /* Rx CRC err frames */
u64 undersized_frm; /* undersized frames */ u64 invalid_crc_gd_eof; /* Rx CRC err good EOF frames */
u64 oversized_frm; /* oversized frames */ u64 undersized_frm; /* Rx undersized frames */
u64 bad_eof_frm; /* frames with bad EOF */ u64 oversized_frm; /* Rx oversized frames */
struct bfa_qos_stats_s qos_stats; /* QoS statistics */ u64 bad_eof_frm; /* Rx frames with bad EOF */
u64 error_frames; /* Errored frames */
u64 dropped_frames; /* Dropped frames */
u64 link_failures; /* Link Failure (LF) count */
u64 loss_of_syncs; /* Loss of sync count */
u64 loss_of_signals;/* Loss of signal count */
u64 primseq_errs; /* Primitive sequence protocol err. */
u64 bad_os_count; /* Invalid ordered sets */
u64 err_enc_out; /* Encoding err nonframe_8b10b */
u64 err_enc; /* Encoding err frame_8b10b */
}; };
/** /**
* Eth Port statistics. * Eth Port statistics.
*/ */
struct bfa_pport_eth_stats_s { struct bfa_pport_eth_stats_s {
u64 secs_reset; /* seconds since stats is reset */ u64 secs_reset; /* Seconds since stats is reset */
u64 frame_64; /* both rx and tx counter */ u64 frame_64; /* Frames 64 bytes */
u64 frame_65_127; /* both rx and tx counter */ u64 frame_65_127; /* Frames 65-127 bytes */
u64 frame_128_255; /* both rx and tx counter */ u64 frame_128_255; /* Frames 128-255 bytes */
u64 frame_256_511; /* both rx and tx counter */ u64 frame_256_511; /* Frames 256-511 bytes */
u64 frame_512_1023; /* both rx and tx counter */ u64 frame_512_1023; /* Frames 512-1023 bytes */
u64 frame_1024_1518; /* both rx and tx counter */ u64 frame_1024_1518; /* Frames 1024-1518 bytes */
u64 frame_1519_1522; /* both rx and tx counter */ u64 frame_1519_1522; /* Frames 1519-1522 bytes */
u64 tx_bytes; /* Tx bytes */
u64 tx_bytes; u64 tx_packets; /* Tx packets */
u64 tx_packets; u64 tx_mcast_packets; /* Tx multicast packets */
u64 tx_mcast_packets; u64 tx_bcast_packets; /* Tx broadcast packets */
u64 tx_bcast_packets; u64 tx_control_frame; /* Tx control frame */
u64 tx_control_frame; u64 tx_drop; /* Tx drops */
u64 tx_drop; u64 tx_jabber; /* Tx jabber */
u64 tx_jabber; u64 tx_fcs_error; /* Tx FCS error */
u64 tx_fcs_error; u64 tx_fragments; /* Tx fragments */
u64 tx_fragments; u64 rx_bytes; /* Rx bytes */
u64 rx_packets; /* Rx packets */
u64 rx_bytes; u64 rx_mcast_packets; /* Rx multicast packets */
u64 rx_packets; u64 rx_bcast_packets; /* Rx broadcast packets */
u64 rx_mcast_packets; u64 rx_control_frames; /* Rx control frames */
u64 rx_bcast_packets; u64 rx_unknown_opcode; /* Rx unknown opcode */
u64 rx_control_frames; u64 rx_drop; /* Rx drops */
u64 rx_unknown_opcode; u64 rx_jabber; /* Rx jabber */
u64 rx_drop; u64 rx_fcs_error; /* Rx FCS errors */
u64 rx_jabber; u64 rx_alignment_error; /* Rx alignment errors */
u64 rx_fcs_error; u64 rx_frame_length_error; /* Rx frame len errors */
u64 rx_alignment_error; u64 rx_code_error; /* Rx code errors */
u64 rx_frame_length_error; u64 rx_fragments; /* Rx fragments */
u64 rx_code_error; u64 rx_pause; /* Rx pause */
u64 rx_fragments; u64 rx_zero_pause; /* Rx zero pause */
u64 tx_pause; /* Tx pause */
u64 rx_pause; /* BPC */ u64 tx_zero_pause; /* Tx zero pause */
u64 rx_zero_pause; /* BPC Pause cancellation */ u64 rx_fcoe_pause; /* Rx fcoe pause */
u64 tx_pause; /* BPC */ u64 rx_fcoe_zero_pause; /* Rx FCoE zero pause */
u64 tx_zero_pause; /* BPC Pause cancellation */ u64 tx_fcoe_pause; /* Tx FCoE pause */
u64 rx_fcoe_pause; /* BPC */ u64 tx_fcoe_zero_pause; /* Tx FCoE zero pause */
u64 rx_fcoe_zero_pause; /* BPC Pause cancellation */
u64 tx_fcoe_pause; /* BPC */
u64 tx_fcoe_zero_pause; /* BPC Pause cancellation */
}; };
/** /**