[SCSI] bfa: Extend BSG interface.

- Added support to collect driver/fw stats.
- Added support to perform adapter/ioc enable, disable operations.

Signed-off-by: Krishna Gudipati <kgudipat@brocade.com>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>

diff --git a/drivers/scsi/bfa/bfa.h b/drivers/scsi/bfa/bfa.h
index 67742dca675fb0504c3750cca545fb153c1b57cc..c7cfc585c656555e94b0100da030af1dd0ac7baf 100644 (file)
--- a/drivers/scsi/bfa/bfa.h
+++ b/drivers/scsi/bfa/bfa.h
@@ -249,6 +249,7 @@ struct bfa_iocfc_s {
        struct bfa_cb_qe_s      init_hcb_qe;
        struct bfa_cb_qe_s      stop_hcb_qe;
        struct bfa_cb_qe_s      dis_hcb_qe;
+       struct bfa_cb_qe_s      en_hcb_qe;
        struct bfa_cb_qe_s      stats_hcb_qe;
        bfa_boolean_t           cfgdone;
 

diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 602dc3508ed81289142768380dc8dbfcc709725b..21343c26721dd6b98e6d3beae72fc81a6141e170 100644 (file)
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -125,6 +125,7 @@ enum {
        BFA_IOCFC_ACT_INIT      = 1,
        BFA_IOCFC_ACT_STOP      = 2,
        BFA_IOCFC_ACT_DISABLE   = 3,
+       BFA_IOCFC_ACT_ENABLE    = 4,
 };
 
 #define DEF_CFG_NUM_FABRICS            1
@@ -677,6 +678,16 @@ bfa_iocfc_stop_cb(void *bfa_arg, bfa_boolean_t compl)
                bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
 }
 
+static void
+bfa_iocfc_enable_cb(void *bfa_arg, bfa_boolean_t compl)
+{
+       struct bfa_s    *bfa = bfa_arg;
+       struct bfad_s *bfad = bfa->bfad;
+
+       if (compl)
+               complete(&bfad->enable_comp);
+}
+
 static void
 bfa_iocfc_disable_cb(void *bfa_arg, bfa_boolean_t compl)
 {
@@ -760,8 +771,12 @@ bfa_iocfc_cfgrsp(struct bfa_s *bfa)
 
        if (iocfc->action == BFA_IOCFC_ACT_INIT)
                bfa_cb_queue(bfa, &iocfc->init_hcb_qe, bfa_iocfc_init_cb, bfa);
-       else
+       else {
+               if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
+                       bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
+                                       bfa_iocfc_enable_cb, bfa);
                bfa_iocfc_start_submod(bfa);
+       }
 }
 void
 bfa_iocfc_reset_queues(struct bfa_s *bfa)
@@ -970,6 +985,9 @@ bfa_iocfc_enable_cbfn(void *bfa_arg, enum bfa_status status)
                if (bfa->iocfc.action == BFA_IOCFC_ACT_INIT)
                        bfa_cb_queue(bfa, &bfa->iocfc.init_hcb_qe,
                                     bfa_iocfc_init_cb, bfa);
+               else if (bfa->iocfc.action == BFA_IOCFC_ACT_ENABLE)
+                       bfa_cb_queue(bfa, &bfa->iocfc.en_hcb_qe,
+                                       bfa_iocfc_enable_cb, bfa);
                return;
        }
 
@@ -1236,6 +1254,7 @@ bfa_iocfc_enable(struct bfa_s *bfa)
 {
        bfa_plog_str(bfa->plog, BFA_PL_MID_HAL, BFA_PL_EID_MISC, 0,
                     "IOC Enable");
+       bfa->iocfc.action = BFA_IOCFC_ACT_ENABLE;
        bfa_ioc_enable(&bfa->ioc);
 }
 

diff --git a/drivers/scsi/bfa/bfa_defs_fcs.h b/drivers/scsi/bfa/bfa_defs_fcs.h
index 5e95976d81b880533acdfa0103fc26a15e2dc3eb..3bbc583f65cfeee82a9c2e6aace0b4a7490a025f 100644 (file)
--- a/drivers/scsi/bfa/bfa_defs_fcs.h
+++ b/drivers/scsi/bfa/bfa_defs_fcs.h
@@ -93,9 +93,11 @@ struct bfa_lport_cfg_s {
        wwn_t          pwwn;       /*  port wwn */
        wwn_t          nwwn;       /*  node wwn */
        struct bfa_lport_symname_s  sym_name;   /*  vm port symbolic name */
-       bfa_boolean_t       preboot_vp;  /*  vport created from PBC */
-       enum bfa_lport_role     roles;      /*  FCS port roles */
-       u8           tag[16];   /*  opaque tag from application */
+       enum bfa_lport_role roles;      /* FCS port roles */
+       u32     rsvd;
+       bfa_boolean_t   preboot_vp;  /*  vport created from PBC */
+       u8      tag[16];        /* opaque tag from application */
+       u8      padding[4];
 };
 
 /*

diff --git a/drivers/scsi/bfa/bfa_defs_svc.h b/drivers/scsi/bfa/bfa_defs_svc.h
index 7f3584380a42dd5cd214a74e70aa2ab641ddde31..95a17ef631f04fdab2a08e190ef0ffd5ef475062 100644 (file)
--- a/drivers/scsi/bfa/bfa_defs_svc.h
+++ b/drivers/scsi/bfa/bfa_defs_svc.h
@@ -65,8 +65,12 @@ struct bfa_iocfc_drvcfg_s {
        u16         ioc_recover;        /*  IOC recovery mode             */
        u16         min_cfg;    /*  minimum configuration         */
        u16        path_tov;    /*  device path timeout   */
+       u16             num_tio_reqs;   /*!< number of TM IO reqs       */
+       u8              port_mode;
+       u8              rsvd_a;
        bfa_boolean_t   delay_comp; /*  delay completion of
                                                        failed inflight IOs */
+       u16             num_ttsk_reqs;   /* TM task management requests */
        u32             rsvd;
 };
 
@@ -81,7 +85,7 @@ struct bfa_iocfc_cfg_s {
 /*
  * IOC firmware IO stats
  */
-struct bfa_fw_io_stats_s {
+struct bfa_fw_ioim_stats_s {
        u32     host_abort;             /*  IO aborted by host driver*/
        u32     host_cleanup;           /*  IO clean up by host driver */
 
@@ -151,6 +155,54 @@ struct bfa_fw_io_stats_s {
                                                 */
 };
 
+struct bfa_fw_tio_stats_s {
+       u32     tio_conf_proc;  /* TIO CONF processed */
+       u32     tio_conf_drop;      /* TIO CONF dropped */
+       u32     tio_cleanup_req;    /* TIO cleanup requested */
+       u32     tio_cleanup_comp;   /* TIO cleanup completed */
+       u32     tio_abort_rsp;      /* TIO abort response */
+       u32     tio_abort_rsp_comp; /* TIO abort rsp completed */
+       u32     tio_abts_req;       /* TIO ABTS requested */
+       u32     tio_abts_ack;       /* TIO ABTS ack-ed */
+       u32     tio_abts_ack_nocomp; /* TIO ABTS ack-ed but not completed */
+       u32     tio_abts_tmo;       /* TIO ABTS timeout */
+       u32     tio_snsdata_dma;    /* TIO sense data DMA */
+       u32     tio_rxwchan_wait; /* TIO waiting for RX wait channel */
+       u32     tio_rxwchan_avail; /* TIO RX wait channel available */
+       u32     tio_hit_bls;        /* TIO IOH BLS event */
+       u32     tio_uf_recv;        /* TIO received UF */
+       u32     tio_rd_invalid_sm; /* TIO read reqst in wrong state machine */
+       u32     tio_wr_invalid_sm;/* TIO write reqst in wrong state machine */
+
+       u32     ds_rxwchan_wait; /* DS waiting for RX wait channel */
+       u32     ds_rxwchan_avail; /* DS RX wait channel available */
+       u32     ds_unaligned_rd;    /* DS unaligned read */
+       u32     ds_rdcomp_invalid_sm; /* DS read completed in wrong state machine */
+       u32     ds_wrcomp_invalid_sm; /* DS write completed in wrong state machine */
+       u32     ds_flush_req;       /* DS flush requested */
+       u32     ds_flush_comp;      /* DS flush completed */
+       u32     ds_xfrdy_exp;       /* DS XFER_RDY expired */
+       u32     ds_seq_cnt_err;     /* DS seq cnt error */
+       u32     ds_seq_len_err;     /* DS seq len error */
+       u32     ds_data_oor;        /* DS data out of order */
+       u32     ds_hit_bls;     /* DS hit BLS */
+       u32     ds_edtov_timer_exp; /* DS edtov expired */
+       u32     ds_cpu_owned;       /* DS cpu owned */
+       u32     ds_hit_class2;      /* DS hit class2 */
+       u32     ds_length_err;      /* DS length error */
+       u32     ds_ro_ooo_err;      /* DS relative offset out-of-order error */
+       u32     ds_rectov_timer_exp;    /* DS rectov expired */
+       u32     ds_unexp_fr_err;    /* DS unexp frame error */
+};
+
+/*
+ * IOC firmware IO stats
+ */
+struct bfa_fw_io_stats_s {
+       struct bfa_fw_ioim_stats_s      ioim_stats;
+       struct bfa_fw_tio_stats_s       tio_stats;
+};
+
 /*
  * IOC port firmware stats
  */
@@ -204,6 +256,7 @@ struct bfa_fw_port_lksm_stats_s {
     u32    nos_tx;             /*  No. of times NOS tx started         */
     u32    hwsm_lrr_rx;        /*  No. of times LRR rx-ed by HWSM      */
     u32    hwsm_lr_rx;         /*  No. of times LR rx-ed by HWSM      */
+       u32     bbsc_lr;        /* LKSM LR tx for credit recovery       */
 };
 
 struct bfa_fw_port_snsm_stats_s {

diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index 27eab36f89a56614ef58920b5ab91734810299bf..a4e7951c6063c083d4127abb920f876aa774d14e 100644 (file)
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -365,6 +365,78 @@ bfa_fcpim_path_tov_get(struct bfa_s *bfa)
        return fcpim->path_tov / 1000;
 }
 
+#define bfa_fcpim_add_iostats(__l, __r, __stats)       \
+       (__l->__stats += __r->__stats)
+
+void
+bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *lstats,
+               struct bfa_itnim_iostats_s *rstats)
+{
+       bfa_fcpim_add_iostats(lstats, rstats, total_ios);
+       bfa_fcpim_add_iostats(lstats, rstats, qresumes);
+       bfa_fcpim_add_iostats(lstats, rstats, no_iotags);
+       bfa_fcpim_add_iostats(lstats, rstats, io_aborts);
+       bfa_fcpim_add_iostats(lstats, rstats, no_tskims);
+       bfa_fcpim_add_iostats(lstats, rstats, iocomp_ok);
+       bfa_fcpim_add_iostats(lstats, rstats, iocomp_underrun);
+       bfa_fcpim_add_iostats(lstats, rstats, iocomp_overrun);
+       bfa_fcpim_add_iostats(lstats, rstats, iocomp_aborted);
+       bfa_fcpim_add_iostats(lstats, rstats, iocomp_timedout);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_nexus_abort);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_proto_err);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_dif_err);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_sqer_needed);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_res_free);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_hostabrts);
+       bfa_fcpim_add_iostats(lstats, rstats, iocom_utags);
+       bfa_fcpim_add_iostats(lstats, rstats, io_cleanups);
+       bfa_fcpim_add_iostats(lstats, rstats, io_tmaborts);
+       bfa_fcpim_add_iostats(lstats, rstats, onlines);
+       bfa_fcpim_add_iostats(lstats, rstats, offlines);
+       bfa_fcpim_add_iostats(lstats, rstats, creates);
+       bfa_fcpim_add_iostats(lstats, rstats, deletes);
+       bfa_fcpim_add_iostats(lstats, rstats, create_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, delete_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, sler_events);
+       bfa_fcpim_add_iostats(lstats, rstats, fw_create);
+       bfa_fcpim_add_iostats(lstats, rstats, fw_delete);
+       bfa_fcpim_add_iostats(lstats, rstats, ioc_disabled);
+       bfa_fcpim_add_iostats(lstats, rstats, cleanup_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_cmnds);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_fw_rsps);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_success);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_failures);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_io_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_qresumes);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_iocdowns);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_cleanups);
+       bfa_fcpim_add_iostats(lstats, rstats, tm_cleanup_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, io_comps);
+       bfa_fcpim_add_iostats(lstats, rstats, input_reqs);
+       bfa_fcpim_add_iostats(lstats, rstats, output_reqs);
+       bfa_fcpim_add_iostats(lstats, rstats, rd_throughput);
+       bfa_fcpim_add_iostats(lstats, rstats, wr_throughput);
+}
+
+bfa_status_t
+bfa_fcpim_port_iostats(struct bfa_s *bfa,
+               struct bfa_itnim_iostats_s *stats, u8 lp_tag)
+{
+       struct bfa_fcpim_s *fcpim = BFA_FCPIM(bfa);
+       struct list_head *qe, *qen;
+       struct bfa_itnim_s *itnim;
+
+       /* accumulate IO stats from itnim */
+       memset(stats, 0, sizeof(struct bfa_itnim_iostats_s));
+       list_for_each_safe(qe, qen, &fcpim->itnim_q) {
+               itnim = (struct bfa_itnim_s *) qe;
+               if (itnim->rport->rport_info.lp_tag != lp_tag)
+                       continue;
+               bfa_fcpim_add_stats(stats, &(itnim->stats));
+       }
+       return BFA_STATUS_OK;
+}
+
 u16
 bfa_fcpim_qdepth_get(struct bfa_s *bfa)
 {

diff --git a/drivers/scsi/bfa/bfa_fcpim.h b/drivers/scsi/bfa/bfa_fcpim.h
index ccb7c6ebebf980ab8a66456421f0099b503bc3a5..57b695ad4ee52389fde2297055e93be2d6147f75 100644 (file)
--- a/drivers/scsi/bfa/bfa_fcpim.h
+++ b/drivers/scsi/bfa/bfa_fcpim.h
@@ -293,6 +293,10 @@ bfa_boolean_t   bfa_itnim_hold_io(struct bfa_itnim_s *itnim);
 void   bfa_fcpim_path_tov_set(struct bfa_s *bfa, u16 path_tov);
 u16    bfa_fcpim_path_tov_get(struct bfa_s *bfa);
 u16    bfa_fcpim_qdepth_get(struct bfa_s *bfa);
+bfa_status_t bfa_fcpim_port_iostats(struct bfa_s *bfa,
+                       struct bfa_itnim_iostats_s *stats, u8 lp_tag);
+void bfa_fcpim_add_stats(struct bfa_itnim_iostats_s *fcpim_stats,
+                       struct bfa_itnim_iostats_s *itnim_stats);
 
 #define bfa_fcpim_ioredirect_enabled(__bfa)                            \
        (((struct bfa_fcpim_s *)(BFA_FCPIM(__bfa)))->ioredirect)

diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index e32cb19e32c36d8e185ecc2d613b5550dffa41c2..a5f1faf335a76ed222508b9a4077d6829524a2ed 100644 (file)
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -452,6 +452,8 @@ bfa_fcs_rport_get_halrport(struct bfa_fcs_rport_s *rport)
 /*
  * bfa fcs rport API functions
  */
+void bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
+                       struct bfa_rport_attr_s *attr);
 struct bfa_fcs_rport_s *bfa_fcs_rport_lookup(struct bfa_fcs_lport_s *port,
                                             wwn_t rpwwn);
 struct bfa_fcs_rport_s *bfa_fcs_rport_lookup_by_nwwn(

diff --git a/drivers/scsi/bfa/bfa_fcs_rport.c b/drivers/scsi/bfa/bfa_fcs_rport.c
index a42949d045eb389e97b60793c8f77201e828ea0d..2c514458a6b44d74ef36833c70fa2cb4faacc016 100644 (file)
--- a/drivers/scsi/bfa/bfa_fcs_rport.c
+++ b/drivers/scsi/bfa/bfa_fcs_rport.c
@@ -2536,7 +2536,45 @@ bfa_fcs_rport_prlo(struct bfa_fcs_rport_s *rport, __be16 ox_id)
        bfa_sm_send_event(rport, RPSM_EVENT_PRLO_RCVD);
 }
 
-
+void
+bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
+               struct bfa_rport_attr_s *rport_attr)
+{
+       struct bfa_rport_qos_attr_s qos_attr;
+       struct bfa_fcs_lport_s *port = rport->port;
+       bfa_port_speed_t rport_speed = rport->rpf.rpsc_speed;
+
+       memset(rport_attr, 0, sizeof(struct bfa_rport_attr_s));
+       memset(&qos_attr, 0, sizeof(struct bfa_rport_qos_attr_s));
+
+       rport_attr->pid = rport->pid;
+       rport_attr->pwwn = rport->pwwn;
+       rport_attr->nwwn = rport->nwwn;
+       rport_attr->cos_supported = rport->fc_cos;
+       rport_attr->df_sz = rport->maxfrsize;
+       rport_attr->state = bfa_fcs_rport_get_state(rport);
+       rport_attr->fc_cos = rport->fc_cos;
+       rport_attr->cisc = rport->cisc;
+       rport_attr->scsi_function = rport->scsi_function;
+       rport_attr->curr_speed  = rport->rpf.rpsc_speed;
+       rport_attr->assigned_speed  = rport->rpf.assigned_speed;
+
+       qos_attr.qos_priority = rport->bfa_rport->qos_attr.qos_priority;
+       qos_attr.qos_flow_id =
+               cpu_to_be32(rport->bfa_rport->qos_attr.qos_flow_id);
+       rport_attr->qos_attr = qos_attr;
+
+       rport_attr->trl_enforced = BFA_FALSE;
+       if (bfa_fcport_is_ratelim(port->fcs->bfa) &&
+           (rport->scsi_function == BFA_RPORT_TARGET)) {
+               if (rport_speed == BFA_PORT_SPEED_UNKNOWN)
+                       rport_speed =
+                               bfa_fcport_get_ratelim_speed(rport->fcs->bfa);
+
+               if (rport_speed < bfa_fcs_lport_get_rport_max_speed(port))
+                       rport_attr->trl_enforced = BFA_TRUE;
+       }
+}
 
 /*
  * Remote port implementation.

diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 9ec8f04b16c08306955cea1df5d790f1375a720d..5ae591b062b37fa646dc06798edc4bd0942b5911 100644 (file)
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -46,6 +46,55 @@ bfad_im_bsg_put_kobject(struct fc_bsg_job *job)
        spin_unlock_irqrestore(shost->host_lock, flags);
 }
 
+int
+bfad_iocmd_ioc_enable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       int     rc = 0;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       /* If IOC is not in disabled state - return */
+       if (!bfa_ioc_is_disabled(&bfad->bfa.ioc)) {
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_IOC_FAILURE;
+               return rc;
+       }
+
+       init_completion(&bfad->enable_comp);
+       bfa_iocfc_enable(&bfad->bfa);
+       iocmd->status = BFA_STATUS_OK;
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       wait_for_completion(&bfad->enable_comp);
+
+       return rc;
+}
+
+int
+bfad_iocmd_ioc_disable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       int     rc = 0;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       if (bfad->disable_active) {
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               return EBUSY;
+       }
+
+       bfad->disable_active = BFA_TRUE;
+       init_completion(&bfad->disable_comp);
+       bfa_iocfc_disable(&bfad->bfa);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       wait_for_completion(&bfad->disable_comp);
+       bfad->disable_active = BFA_FALSE;
+       iocmd->status = BFA_STATUS_OK;
+
+       return rc;
+}
+
 static int
 bfad_iocmd_ioc_get_info(struct bfad_s *bfad, void *cmd)
 {
@@ -112,6 +161,113 @@ bfad_iocmd_ioc_get_attr(struct bfad_s *bfad, void *cmd)
        return 0;
 }
 
+int
+bfad_iocmd_ioc_get_stats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_ioc_stats_s *iocmd = (struct bfa_bsg_ioc_stats_s *)cmd;
+
+       bfa_ioc_get_stats(&bfad->bfa, &iocmd->ioc_stats);
+       iocmd->status = BFA_STATUS_OK;
+       return 0;
+}
+
+int
+bfad_iocmd_ioc_get_fwstats(struct bfad_s *bfad, void *cmd,
+                       unsigned int payload_len)
+{
+       struct bfa_bsg_ioc_fwstats_s *iocmd =
+                       (struct bfa_bsg_ioc_fwstats_s *)cmd;
+       void    *iocmd_bufptr;
+       unsigned long   flags;
+
+       if (bfad_chk_iocmd_sz(payload_len,
+                       sizeof(struct bfa_bsg_ioc_fwstats_s),
+                       sizeof(struct bfa_fw_stats_s)) != BFA_STATUS_OK) {
+               iocmd->status = BFA_STATUS_VERSION_FAIL;
+               goto out;
+       }
+
+       iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_ioc_fwstats_s);
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_ioc_fw_stats_get(&bfad->bfa.ioc, iocmd_bufptr);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       if (iocmd->status != BFA_STATUS_OK) {
+               bfa_trc(bfad, iocmd->status);
+               goto out;
+       }
+out:
+       bfa_trc(bfad, 0x6666);
+       return 0;
+}
+
+int
+bfad_iocmd_iocfc_get_attr(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_iocfc_attr_s *iocmd = (struct bfa_bsg_iocfc_attr_s *)cmd;
+
+       iocmd->status = BFA_STATUS_OK;
+       bfa_iocfc_get_attr(&bfad->bfa, &iocmd->iocfc_attr);
+
+       return 0;
+}
+
+int
+bfad_iocmd_iocfc_set_intr(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_iocfc_intr_s *iocmd = (struct bfa_bsg_iocfc_intr_s *)cmd;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_iocfc_israttr_set(&bfad->bfa, &iocmd->attr);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       return 0;
+}
+
+int
+bfad_iocmd_port_enable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       struct bfad_hal_comp fcomp;
+       unsigned long flags;
+
+       init_completion(&fcomp.comp);
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_port_enable(&bfad->bfa.modules.port,
+                                       bfad_hcb_comp, &fcomp);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       if (iocmd->status != BFA_STATUS_OK) {
+               bfa_trc(bfad, iocmd->status);
+               return 0;
+       }
+       wait_for_completion(&fcomp.comp);
+       iocmd->status = fcomp.status;
+       return 0;
+}
+
+int
+bfad_iocmd_port_disable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       struct bfad_hal_comp fcomp;
+       unsigned long flags;
+
+       init_completion(&fcomp.comp);
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_port_disable(&bfad->bfa.modules.port,
+                               bfad_hcb_comp, &fcomp);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       if (iocmd->status != BFA_STATUS_OK) {
+               bfa_trc(bfad, iocmd->status);
+               return 0;
+       }
+       wait_for_completion(&fcomp.comp);
+       iocmd->status = fcomp.status;
+       return 0;
+}
+
 static int
 bfad_iocmd_port_get_attr(struct bfad_s *bfad, void *cmd)
 {
@@ -140,6 +296,40 @@ bfad_iocmd_port_get_attr(struct bfad_s *bfad, void *cmd)
        return 0;
 }
 
+int
+bfad_iocmd_port_get_stats(struct bfad_s *bfad, void *cmd,
+                       unsigned int payload_len)
+{
+       struct bfa_bsg_port_stats_s *iocmd = (struct bfa_bsg_port_stats_s *)cmd;
+       struct bfad_hal_comp fcomp;
+       void    *iocmd_bufptr;
+       unsigned long   flags;
+
+       if (bfad_chk_iocmd_sz(payload_len,
+                       sizeof(struct bfa_bsg_port_stats_s),
+                       sizeof(union bfa_port_stats_u)) != BFA_STATUS_OK) {
+               iocmd->status = BFA_STATUS_VERSION_FAIL;
+               return 0;
+       }
+
+       iocmd_bufptr = (char *)iocmd + sizeof(struct bfa_bsg_port_stats_s);
+
+       init_completion(&fcomp.comp);
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_port_get_stats(&bfad->bfa.modules.port,
+                               iocmd_bufptr, bfad_hcb_comp, &fcomp);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       if (iocmd->status != BFA_STATUS_OK) {
+               bfa_trc(bfad, iocmd->status);
+               goto out;
+       }
+
+       wait_for_completion(&fcomp.comp);
+       iocmd->status = fcomp.status;
+out:
+       return 0;
+}
+
 static int
 bfad_iocmd_lport_get_attr(struct bfad_s *bfad, void *cmd)
 {
@@ -163,6 +353,128 @@ out:
        return 0;
 }
 
+int
+bfad_iocmd_lport_get_stats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_bsg_lport_stats_s *iocmd =
+                       (struct bfa_bsg_lport_stats_s *)cmd;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->pwwn);
+       if (fcs_port == NULL) {
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               goto out;
+       }
+
+       bfa_fcs_lport_get_stats(fcs_port, &iocmd->port_stats);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+out:
+       return 0;
+}
+
+int
+bfad_iocmd_lport_get_iostats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_bsg_lport_iostats_s *iocmd =
+                       (struct bfa_bsg_lport_iostats_s *)cmd;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->pwwn);
+       if (fcs_port == NULL) {
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               goto out;
+       }
+
+       bfa_fcpim_port_iostats(&bfad->bfa, &iocmd->iostats,
+                       fcs_port->lp_tag);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+out:
+       return 0;
+}
+
+int
+bfad_iocmd_lport_get_rports(struct bfad_s *bfad, void *cmd,
+                       unsigned int payload_len)
+{
+       struct bfa_bsg_lport_get_rports_s *iocmd =
+                       (struct bfa_bsg_lport_get_rports_s *)cmd;
+       struct bfa_fcs_lport_s *fcs_port;
+       unsigned long   flags;
+       void    *iocmd_bufptr;
+
+       if (iocmd->nrports == 0)
+               return EINVAL;
+
+       if (bfad_chk_iocmd_sz(payload_len,
+                       sizeof(struct bfa_bsg_lport_get_rports_s),
+                       sizeof(wwn_t) * iocmd->nrports) != BFA_STATUS_OK) {
+               iocmd->status = BFA_STATUS_VERSION_FAIL;
+               return 0;
+       }
+
+       iocmd_bufptr = (char *)iocmd +
+                       sizeof(struct bfa_bsg_lport_get_rports_s);
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->pwwn);
+       if (fcs_port == NULL) {
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               bfa_trc(bfad, 0);
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               goto out;
+       }
+
+       bfa_fcs_lport_get_rports(fcs_port, (wwn_t *)iocmd_bufptr,
+                               &iocmd->nrports);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+out:
+       return 0;
+}
+
+int
+bfad_iocmd_rport_get_attr(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_rport_attr_s *iocmd = (struct bfa_bsg_rport_attr_s *)cmd;
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_fcs_rport_s *fcs_rport;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->pwwn);
+       if (fcs_port == NULL) {
+               bfa_trc(bfad, 0);
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               goto out;
+       }
+
+       fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
+       if (fcs_rport == NULL) {
+               bfa_trc(bfad, 0);
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+               goto out;
+       }
+
+       bfa_fcs_rport_get_attr(fcs_rport, &iocmd->attr);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+out:
+       return 0;
+}
+
 static int
 bfad_iocmd_rport_get_addr(struct bfad_s *bfad, void *cmd)
 {
@@ -212,6 +524,45 @@ out:
        return 0;
 }
 
+int
+bfad_iocmd_rport_get_stats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_rport_stats_s *iocmd =
+                       (struct bfa_bsg_rport_stats_s *)cmd;
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_fcs_rport_s *fcs_rport;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->pwwn);
+       if (fcs_port == NULL) {
+               bfa_trc(bfad, 0);
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               goto out;
+       }
+
+       fcs_rport = bfa_fcs_rport_lookup(fcs_port, iocmd->rpwwn);
+       if (fcs_rport == NULL) {
+               bfa_trc(bfad, 0);
+               spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+               iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+               goto out;
+       }
+
+       memcpy((void *)&iocmd->stats, (void *)&fcs_rport->stats,
+               sizeof(struct bfa_rport_stats_s));
+       memcpy((void *)&iocmd->stats.hal_stats,
+              (void *)&(bfa_fcs_rport_get_halrport(fcs_rport)->stats),
+              sizeof(struct bfa_rport_hal_stats_s));
+
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+out:
+       return 0;
+}
+
 static int
 bfad_iocmd_fabric_get_lports(struct bfad_s *bfad, void *cmd,
                        unsigned int payload_len)
@@ -254,6 +605,45 @@ out:
        return 0;
 }
 
+int
+bfad_iocmd_fcpim_get_modstats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_fcpim_modstats_s *iocmd =
+                       (struct bfa_bsg_fcpim_modstats_s *)cmd;
+       struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
+       struct list_head *qe, *qen;
+       struct bfa_itnim_s *itnim;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       /* accumulate IO stats from itnim */
+       memset((void *)&iocmd->modstats, 0, sizeof(struct bfa_itnim_iostats_s));
+       list_for_each_safe(qe, qen, &fcpim->itnim_q) {
+               itnim = (struct bfa_itnim_s *) qe;
+               bfa_fcpim_add_stats(&iocmd->modstats, &(itnim->stats));
+       }
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       iocmd->status = BFA_STATUS_OK;
+       return 0;
+}
+
+int
+bfad_iocmd_fcpim_get_del_itn_stats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_fcpim_del_itn_stats_s *iocmd =
+                       (struct bfa_bsg_fcpim_del_itn_stats_s *)cmd;
+       struct bfa_fcpim_s *fcpim = BFA_FCPIM(&bfad->bfa);
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       memcpy((void *)&iocmd->modstats, (void *)&fcpim->del_itn_stats,
+               sizeof(struct bfa_fcpim_del_itn_stats_s));
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       iocmd->status = BFA_STATUS_OK;
+       return 0;
+}
+
 static int
 bfad_iocmd_itnim_get_attr(struct bfad_s *bfad, void *cmd)
 {
@@ -273,6 +663,91 @@ bfad_iocmd_itnim_get_attr(struct bfad_s *bfad, void *cmd)
        return 0;
 }
 
+static int
+bfad_iocmd_itnim_get_iostats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_itnim_iostats_s *iocmd =
+                       (struct bfa_bsg_itnim_iostats_s *)cmd;
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_fcs_itnim_s *itnim;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->lpwwn);
+       if (!fcs_port) {
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               bfa_trc(bfad, 0);
+       } else {
+               itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
+               if (itnim == NULL)
+                       iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+               else {
+                       iocmd->status = BFA_STATUS_OK;
+                       memcpy((void *)&iocmd->iostats, (void *)
+                              &(bfa_fcs_itnim_get_halitn(itnim)->stats),
+                              sizeof(struct bfa_itnim_iostats_s));
+               }
+       }
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       return 0;
+}
+
+static int
+bfad_iocmd_itnim_get_itnstats(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_itnim_itnstats_s *iocmd =
+                       (struct bfa_bsg_itnim_itnstats_s *)cmd;
+       struct bfa_fcs_lport_s *fcs_port;
+       struct bfa_fcs_itnim_s *itnim;
+       unsigned long   flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       fcs_port = bfa_fcs_lookup_port(&bfad->bfa_fcs,
+                               iocmd->vf_id, iocmd->lpwwn);
+       if (!fcs_port) {
+               iocmd->status = BFA_STATUS_UNKNOWN_LWWN;
+               bfa_trc(bfad, 0);
+       } else {
+               itnim = bfa_fcs_itnim_lookup(fcs_port, iocmd->rpwwn);
+               if (itnim == NULL)
+                       iocmd->status = BFA_STATUS_UNKNOWN_RWWN;
+               else {
+                       iocmd->status = BFA_STATUS_OK;
+                       bfa_fcs_itnim_stats_get(fcs_port, iocmd->rpwwn,
+                                       &iocmd->itnstats);
+               }
+       }
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+       return 0;
+}
+
+int
+bfad_iocmd_fcport_enable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       unsigned long flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_fcport_enable(&bfad->bfa);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       return 0;
+}
+
+int
+bfad_iocmd_fcport_disable(struct bfad_s *bfad, void *cmd)
+{
+       struct bfa_bsg_gen_s *iocmd = (struct bfa_bsg_gen_s *)cmd;
+       unsigned long flags;
+
+       spin_lock_irqsave(&bfad->bfad_lock, flags);
+       iocmd->status = bfa_fcport_disable(&bfad->bfa);
+       spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+       return 0;
+}
+
 int
 bfad_iocmd_ioc_get_pcifn_cfg(struct bfad_s *bfad, void *cmd)
 {
@@ -511,27 +986,87 @@ bfad_iocmd_handler(struct bfad_s *bfad, unsigned int cmd, void *iocmd,
        int rc = EINVAL;
 
        switch (cmd) {
+       case IOCMD_IOC_ENABLE:
+               rc = bfad_iocmd_ioc_enable(bfad, iocmd);
+               break;
+       case IOCMD_IOC_DISABLE:
+               rc = bfad_iocmd_ioc_disable(bfad, iocmd);
+               break;
        case IOCMD_IOC_GET_INFO:
                rc = bfad_iocmd_ioc_get_info(bfad, iocmd);
                break;
        case IOCMD_IOC_GET_ATTR:
                rc = bfad_iocmd_ioc_get_attr(bfad, iocmd);
                break;
+       case IOCMD_IOC_GET_STATS:
+               rc = bfad_iocmd_ioc_get_stats(bfad, iocmd);
+               break;
+       case IOCMD_IOC_GET_FWSTATS:
+               rc = bfad_iocmd_ioc_get_fwstats(bfad, iocmd, payload_len);
+               break;
+       case IOCMD_IOCFC_GET_ATTR:
+               rc = bfad_iocmd_iocfc_get_attr(bfad, iocmd);
+               break;
+       case IOCMD_IOCFC_SET_INTR:
+               rc = bfad_iocmd_iocfc_set_intr(bfad, iocmd);
+               break;
+       case IOCMD_PORT_ENABLE:
+               rc = bfad_iocmd_port_enable(bfad, iocmd);
+               break;
+       case IOCMD_PORT_DISABLE:
+               rc = bfad_iocmd_port_disable(bfad, iocmd);
+               break;
        case IOCMD_PORT_GET_ATTR:
                rc = bfad_iocmd_port_get_attr(bfad, iocmd);
                break;
+       case IOCMD_PORT_GET_STATS:
+               rc = bfad_iocmd_port_get_stats(bfad, iocmd, payload_len);
+               break;
        case IOCMD_LPORT_GET_ATTR:
                rc = bfad_iocmd_lport_get_attr(bfad, iocmd);
                break;
+       case IOCMD_LPORT_GET_STATS:
+               rc = bfad_iocmd_lport_get_stats(bfad, iocmd);
+               break;
+       case IOCMD_LPORT_GET_IOSTATS:
+               rc = bfad_iocmd_lport_get_iostats(bfad, iocmd);
+               break;
+       case IOCMD_LPORT_GET_RPORTS:
+               rc = bfad_iocmd_lport_get_rports(bfad, iocmd, payload_len);
+               break;
+       case IOCMD_RPORT_GET_ATTR:
+               rc = bfad_iocmd_rport_get_attr(bfad, iocmd);
+               break;
        case IOCMD_RPORT_GET_ADDR:
                rc = bfad_iocmd_rport_get_addr(bfad, iocmd);
                break;
+       case IOCMD_RPORT_GET_STATS:
+               rc = bfad_iocmd_rport_get_stats(bfad, iocmd);
+               break;
        case IOCMD_FABRIC_GET_LPORTS:
                rc = bfad_iocmd_fabric_get_lports(bfad, iocmd, payload_len);
                break;
+       case IOCMD_FCPIM_MODSTATS:
+               rc = bfad_iocmd_fcpim_get_modstats(bfad, iocmd);
+               break;
+       case IOCMD_FCPIM_DEL_ITN_STATS:
+               rc = bfad_iocmd_fcpim_get_del_itn_stats(bfad, iocmd);
+               break;
        case IOCMD_ITNIM_GET_ATTR:
                rc = bfad_iocmd_itnim_get_attr(bfad, iocmd);
                break;
+       case IOCMD_ITNIM_GET_IOSTATS:
+               rc = bfad_iocmd_itnim_get_iostats(bfad, iocmd);
+               break;
+       case IOCMD_ITNIM_GET_ITNSTATS:
+               rc = bfad_iocmd_itnim_get_itnstats(bfad, iocmd);
+               break;
+       case IOCMD_FCPORT_ENABLE:
+               rc = bfad_iocmd_fcport_enable(bfad, iocmd);
+               break;
+       case IOCMD_FCPORT_DISABLE:
+               rc = bfad_iocmd_fcport_disable(bfad, iocmd);
+               break;
        case IOCMD_IOC_PCIFN_CFG:
                rc = bfad_iocmd_ioc_get_pcifn_cfg(bfad, iocmd);
                break;

diff --git a/drivers/scsi/bfa/bfad_bsg.h b/drivers/scsi/bfa/bfad_bsg.h
index 49f558fc2375a8d63969c5eaefe7ee8d1a3633bf..0abb2d2036a3cd41b4a192a3121ad5d7db5049d2 100644 (file)
--- a/drivers/scsi/bfa/bfad_bsg.h
+++ b/drivers/scsi/bfa/bfad_bsg.h
@@ -24,14 +24,34 @@
  * using FC_BSG_HST_VENDOR message code.
  */
 enum {
-       IOCMD_IOC_GET_ATTR = 0x1,
+       IOCMD_IOC_ENABLE = 0x1,
+       IOCMD_IOC_DISABLE,
+       IOCMD_IOC_GET_ATTR,
        IOCMD_IOC_GET_INFO,
+       IOCMD_IOC_GET_STATS,
+       IOCMD_IOC_GET_FWSTATS,
+       IOCMD_IOCFC_GET_ATTR,
+       IOCMD_IOCFC_SET_INTR,
+       IOCMD_PORT_ENABLE,
+       IOCMD_PORT_DISABLE,
        IOCMD_PORT_GET_ATTR,
+       IOCMD_PORT_GET_STATS,
        IOCMD_LPORT_GET_ATTR,
+       IOCMD_LPORT_GET_RPORTS,
+       IOCMD_LPORT_GET_STATS,
+       IOCMD_LPORT_GET_IOSTATS,
+       IOCMD_RPORT_GET_ATTR,
        IOCMD_RPORT_GET_ADDR,
+       IOCMD_RPORT_GET_STATS,
        IOCMD_FABRIC_GET_LPORTS,
+       IOCMD_FCPIM_MODSTATS,
+       IOCMD_FCPIM_DEL_ITN_STATS,
        IOCMD_ITNIM_GET_ATTR,
+       IOCMD_ITNIM_GET_IOSTATS,
+       IOCMD_ITNIM_GET_ITNSTATS,
        IOCMD_IOC_PCIFN_CFG,
+       IOCMD_FCPORT_ENABLE,
+       IOCMD_FCPORT_DISABLE,
        IOCMD_PCIFN_CREATE,
        IOCMD_PCIFN_DELETE,
        IOCMD_PCIFN_BW,
@@ -83,6 +103,36 @@ struct bfa_bsg_ioc_attr_s {
        struct bfa_ioc_attr_s  ioc_attr;
 };
 
+struct bfa_bsg_ioc_stats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             rsvd;
+       struct bfa_ioc_stats_s ioc_stats;
+};
+
+struct bfa_bsg_ioc_fwstats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             rsvd;
+       u32             buf_size;
+       u32             rsvd1;
+       u64             buf_ptr;
+};
+
+struct bfa_bsg_iocfc_attr_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             rsvd;
+       struct bfa_iocfc_attr_s iocfc_attr;
+};
+
+struct bfa_bsg_iocfc_intr_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             rsvd;
+       struct bfa_iocfc_intr_attr_s attr;
+};
+
 struct bfa_bsg_port_attr_s {
        bfa_status_t    status;
        u16             bfad_num;
@@ -90,6 +140,15 @@ struct bfa_bsg_port_attr_s {
        struct bfa_port_attr_s  attr;
 };
 
+struct bfa_bsg_port_stats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             rsvd;
+       u32             buf_size;
+       u32             rsvd1;
+       u64             buf_ptr;
+};
+
 struct bfa_bsg_lport_attr_s {
        bfa_status_t    status;
        u16             bfad_num;
@@ -98,6 +157,50 @@ struct bfa_bsg_lport_attr_s {
        struct bfa_lport_attr_s port_attr;
 };
 
+struct bfa_bsg_lport_stats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           pwwn;
+       struct bfa_lport_stats_s port_stats;
+};
+
+struct bfa_bsg_lport_iostats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           pwwn;
+       struct bfa_itnim_iostats_s iostats;
+};
+
+struct bfa_bsg_lport_get_rports_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           pwwn;
+       u64             rbuf_ptr;
+       u32             nrports;
+       u32             rsvd;
+};
+
+struct bfa_bsg_rport_attr_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           pwwn;
+       wwn_t           rpwwn;
+       struct bfa_rport_attr_s attr;
+};
+
+struct bfa_bsg_rport_stats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           pwwn;
+       wwn_t           rpwwn;
+       struct bfa_rport_stats_s stats;
+};
+
 struct bfa_bsg_rport_scsi_addr_s {
        bfa_status_t    status;
        u16             bfad_num;
@@ -119,6 +222,18 @@ struct bfa_bsg_fabric_get_lports_s {
        u32             rsvd;
 };
 
+struct bfa_bsg_fcpim_modstats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       struct bfa_itnim_iostats_s modstats;
+};
+
+struct bfa_bsg_fcpim_del_itn_stats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       struct bfa_fcpim_del_itn_stats_s modstats;
+};
+
 struct bfa_bsg_itnim_attr_s {
        bfa_status_t    status;
        u16             bfad_num;
@@ -128,6 +243,24 @@ struct bfa_bsg_itnim_attr_s {
        struct bfa_itnim_attr_s attr;
 };
 
+struct bfa_bsg_itnim_iostats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           lpwwn;
+       wwn_t           rpwwn;
+       struct bfa_itnim_iostats_s iostats;
+};
+
+struct bfa_bsg_itnim_itnstats_s {
+       bfa_status_t    status;
+       u16             bfad_num;
+       u16             vf_id;
+       wwn_t           lpwwn;
+       wwn_t           rpwwn;
+       struct bfa_itnim_stats_s itnstats;
+};
+
 struct bfa_bsg_pcifn_cfg_s {
        bfa_status_t            status;
        u16                     bfad_num;

diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index 35bf0a630a6880c81901f8073ba6041613ca8616..6363dd7e15b4e2c8f20a3a760fef30a34d76c947 100644 (file)
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -194,6 +194,7 @@ struct bfad_s {
        void __iomem   *pci_bar2_kva;
        struct completion comp;
        struct completion suspend;
+       struct completion enable_comp;
        struct completion disable_comp;
        bfa_boolean_t   disable_active;
        struct bfad_port_s     pport;   /* physical port of the BFAD */