[SCSI] bfa: cleanup driver

We have flattened the BFA hierarchy and also reduced the number of
source and header files we used to have earlier.

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

1 files changed, 145 insertions, 96 deletions

diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index 0818eb07ef88..d8843720eac1 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
+ * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
  * All rights reserved
  * www.brocade.com
  *
@@ -19,15 +19,8 @@
  *  bfa_attr.c Linux driver configuration interface module.
  */
 
-#include <linux/slab.h>
 #include "bfad_drv.h"
 #include "bfad_im.h"
-#include "bfad_trcmod.h"
-#include "bfad_attr.h"
-
-/**
- *  FC_transport_template FC transport template
- */
 
 /**
  * FC transport template entry, get SCSI target port ID.
@@ -42,7 +35,7 @@ bfad_im_get_starget_port_id(struct scsi_target *starget)
         u32        fc_id = -1;
         unsigned long   flags;
 
-        shost = bfad_os_starget_to_shost(starget);
+        shost = dev_to_shost(starget->dev.parent);
         im_port = (struct bfad_im_port_s *) shost->hostdata[0];
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
@@ -68,7 +61,7 @@ bfad_im_get_starget_node_name(struct scsi_target *starget)
         u64             node_name = 0;
         unsigned long   flags;
 
-        shost = bfad_os_starget_to_shost(starget);
+        shost = dev_to_shost(starget->dev.parent);
         im_port = (struct bfad_im_port_s *) shost->hostdata[0];
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
@@ -94,7 +87,7 @@ bfad_im_get_starget_port_name(struct scsi_target *starget)
         u64             port_name = 0;
         unsigned long   flags;
 
-        shost = bfad_os_starget_to_shost(starget);
+        shost = dev_to_shost(starget->dev.parent);
         im_port = (struct bfad_im_port_s *) shost->hostdata[0];
         bfad = im_port->bfad;
         spin_lock_irqsave(&bfad->bfad_lock, flags);
@@ -118,17 +111,7 @@ bfad_im_get_host_port_id(struct Scsi_Host *shost)
         struct bfad_port_s    *port = im_port->port;
 
         fc_host_port_id(shost) =
-                        bfa_os_hton3b(bfa_fcs_port_get_fcid(port->fcs_port));
-}
-
-
-
-
-
-struct Scsi_Host *
-bfad_os_starget_to_shost(struct scsi_target *starget)
-{
-        return dev_to_shost(starget->dev.parent);
+                        bfa_os_hton3b(bfa_fcs_lport_get_fcid(port->fcs_port));
 }
 
 /**
@@ -140,21 +123,21 @@ bfad_im_get_host_port_type(struct Scsi_Host *shost)
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_pport_attr_s attr;
+        struct bfa_lport_attr_s port_attr;
 
-        bfa_fcport_get_attr(&bfad->bfa, &attr);
+        bfa_fcs_lport_get_attr(&bfad->bfa_fcs.fabric.bport, &port_attr);
 
-        switch (attr.port_type) {
-        case BFA_PPORT_TYPE_NPORT:
+        switch (port_attr.port_type) {
+        case BFA_PORT_TYPE_NPORT:
                 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
                 break;
-        case BFA_PPORT_TYPE_NLPORT:
+        case BFA_PORT_TYPE_NLPORT:
                 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
                 break;
-        case BFA_PPORT_TYPE_P2P:
+        case BFA_PORT_TYPE_P2P:
                 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
                 break;
-        case BFA_PPORT_TYPE_LPORT:
+        case BFA_PORT_TYPE_LPORT:
                 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
                 break;
         default:
@@ -172,25 +155,28 @@ bfad_im_get_host_port_state(struct Scsi_Host *shost)
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_pport_attr_s attr;
+        struct bfa_port_attr_s attr;
 
         bfa_fcport_get_attr(&bfad->bfa, &attr);
 
         switch (attr.port_state) {
-        case BFA_PPORT_ST_LINKDOWN:
+        case BFA_PORT_ST_LINKDOWN:
                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
                 break;
-        case BFA_PPORT_ST_LINKUP:
+        case BFA_PORT_ST_LINKUP:
                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
                 break;
-        case BFA_PPORT_ST_UNINIT:
-        case BFA_PPORT_ST_ENABLING_QWAIT:
-        case BFA_PPORT_ST_ENABLING:
-        case BFA_PPORT_ST_DISABLING_QWAIT:
-        case BFA_PPORT_ST_DISABLING:
-        case BFA_PPORT_ST_DISABLED:
-        case BFA_PPORT_ST_STOPPED:
-        case BFA_PPORT_ST_IOCDOWN:
+        case BFA_PORT_ST_DISABLED:
+        case BFA_PORT_ST_STOPPED:
+        case BFA_PORT_ST_IOCDOWN:
+        case BFA_PORT_ST_IOCDIS:
+                fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+                break;
+        case BFA_PORT_ST_UNINIT:
+        case BFA_PORT_ST_ENABLING_QWAIT:
+        case BFA_PORT_ST_ENABLING:
+        case BFA_PORT_ST_DISABLING_QWAIT:
+        case BFA_PORT_ST_DISABLING:
         default:
                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
                 break;
@@ -210,13 +196,9 @@ bfad_im_get_host_active_fc4s(struct Scsi_Host *shost)
         memset(fc_host_active_fc4s(shost), 0,
                sizeof(fc_host_active_fc4s(shost)));
 
-        if (port->supported_fc4s &
-                (BFA_PORT_ROLE_FCP_IM | BFA_PORT_ROLE_FCP_TM))
+        if (port->supported_fc4s & BFA_LPORT_ROLE_FCP_IM)
                 fc_host_active_fc4s(shost)[2] = 1;
 
-        if (port->supported_fc4s & BFA_PORT_ROLE_FCP_IPFC)
-                fc_host_active_fc4s(shost)[3] = 0x20;
-
         fc_host_active_fc4s(shost)[7] = 1;
 }
 
@@ -229,29 +211,29 @@ bfad_im_get_host_speed(struct Scsi_Host *shost)
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_pport_attr_s attr;
-        unsigned long   flags;
+        struct bfa_port_attr_s attr;
 
-        spin_lock_irqsave(shost->host_lock, flags);
         bfa_fcport_get_attr(&bfad->bfa, &attr);
         switch (attr.speed) {
-        case BFA_PPORT_SPEED_8GBPS:
+        case BFA_PORT_SPEED_10GBPS:
+                fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
+                break;
+        case BFA_PORT_SPEED_8GBPS:
                 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
                 break;
-        case BFA_PPORT_SPEED_4GBPS:
+        case BFA_PORT_SPEED_4GBPS:
                 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
                 break;
-        case BFA_PPORT_SPEED_2GBPS:
+        case BFA_PORT_SPEED_2GBPS:
                 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
                 break;
-        case BFA_PPORT_SPEED_1GBPS:
+        case BFA_PORT_SPEED_1GBPS:
                 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
                 break;
         default:
                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                 break;
         }
-        spin_unlock_irqrestore(shost->host_lock, flags);
 }
 
 /**
@@ -265,7 +247,7 @@ bfad_im_get_host_fabric_name(struct Scsi_Host *shost)
         struct bfad_port_s    *port = im_port->port;
         wwn_t           fabric_nwwn = 0;
 
-        fabric_nwwn = bfa_fcs_port_get_fabric_name(port->fcs_port);
+        fabric_nwwn = bfa_fcs_lport_get_fabric_name(port->fcs_port);
 
         fc_host_fabric_name(shost) = bfa_os_htonll(fabric_nwwn);
 
@@ -281,23 +263,44 @@ bfad_im_get_stats(struct Scsi_Host *shost)
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
         struct bfad_hal_comp fcomp;
+        union bfa_port_stats_u *fcstats;
         struct fc_host_statistics *hstats;
         bfa_status_t    rc;
         unsigned long   flags;
 
+        fcstats = kzalloc(sizeof(union bfa_port_stats_u), GFP_KERNEL);
+        if (fcstats == NULL)
+                return NULL;
+
         hstats = &bfad->link_stats;
         init_completion(&fcomp.comp);
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         memset(hstats, 0, sizeof(struct fc_host_statistics));
-        rc =  bfa_port_get_stats(BFA_FCPORT(&bfad->bfa),
-                                     (union bfa_pport_stats_u *) hstats,
-                                     bfad_hcb_comp, &fcomp);
+        rc = bfa_port_get_stats(BFA_FCPORT(&bfad->bfa),
+                                fcstats, bfad_hcb_comp, &fcomp);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         if (rc != BFA_STATUS_OK)
                 return NULL;
 
         wait_for_completion(&fcomp.comp);
 
+        /* Fill the fc_host_statistics structure */
+        hstats->seconds_since_last_reset = fcstats->fc.secs_reset;
+        hstats->tx_frames = fcstats->fc.tx_frames;
+        hstats->tx_words  = fcstats->fc.tx_words;
+        hstats->rx_frames = fcstats->fc.rx_frames;
+        hstats->rx_words  = fcstats->fc.rx_words;
+        hstats->lip_count = fcstats->fc.lip_count;
+        hstats->nos_count = fcstats->fc.nos_count;
+        hstats->error_frames = fcstats->fc.error_frames;
+        hstats->dumped_frames = fcstats->fc.dropped_frames;
+        hstats->link_failure_count = fcstats->fc.link_failures;
+        hstats->loss_of_sync_count = fcstats->fc.loss_of_syncs;
+        hstats->loss_of_signal_count = fcstats->fc.loss_of_signals;
+        hstats->prim_seq_protocol_err_count = fcstats->fc.primseq_errs;
+        hstats->invalid_crc_count = fcstats->fc.invalid_crcs;
+
+        kfree(fcstats);
         return hstats;
 }
 
@@ -317,7 +320,7 @@ bfad_im_reset_stats(struct Scsi_Host *shost)
         init_completion(&fcomp.comp);
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         rc = bfa_port_clear_stats(BFA_FCPORT(&bfad->bfa), bfad_hcb_comp,
-                &fcomp);
+                                        &fcomp);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
         if (rc != BFA_STATUS_OK)
@@ -372,8 +375,8 @@ bfad_im_vport_create(struct fc_vport *fc_vport, bool disable)
         struct bfad_im_port_s *im_port =
                 (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s *bfad = im_port->bfad;
-        struct bfa_port_cfg_s port_cfg;
-        struct bfad_pcfg_s *pcfg;
+        struct bfa_lport_cfg_s port_cfg;
+        struct bfad_vport_s *vp;
         int status = 0, rc;
         unsigned long flags;
 
@@ -382,12 +385,14 @@ bfad_im_vport_create(struct fc_vport *fc_vport, bool disable)
         u64_to_wwn(fc_vport->port_name, (u8 *)&port_cfg.pwwn);
         if (strlen(vname) > 0)
                 strcpy((char *)&port_cfg.sym_name, vname);
-        port_cfg.roles = BFA_PORT_ROLE_FCP_IM;
+        port_cfg.roles = BFA_LPORT_ROLE_FCP_IM;
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        list_for_each_entry(pcfg, &bfad->pbc_pcfg_list, list_entry) {
-                if (port_cfg.pwwn == pcfg->port_cfg.pwwn) {
-                        port_cfg.preboot_vp = pcfg->port_cfg.preboot_vp;
+        list_for_each_entry(vp, &bfad->pbc_vport_list, list_entry) {
+                if (port_cfg.pwwn ==
+                                vp->fcs_vport.lport.port_cfg.pwwn) {
+                        port_cfg.preboot_vp =
+                                vp->fcs_vport.lport.port_cfg.preboot_vp;
                         break;
                 }
         }
@@ -638,7 +643,7 @@ bfad_im_serial_num_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
         char serial_num[BFA_ADAPTER_SERIAL_NUM_LEN];
 
         bfa_get_adapter_serial_num(&bfad->bfa, serial_num);
@@ -652,7 +657,7 @@ bfad_im_model_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
         char model[BFA_ADAPTER_MODEL_NAME_LEN];
 
         bfa_get_adapter_model(&bfad->bfa, model);
@@ -666,10 +671,54 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
+        char model[BFA_ADAPTER_MODEL_NAME_LEN];
         char model_descr[BFA_ADAPTER_MODEL_DESCR_LEN];
 
-        bfa_get_adapter_model(&bfad->bfa, model_descr);
+        bfa_get_adapter_model(&bfad->bfa, model);
+        if (!strcmp(model, "Brocade-425"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 4Gbps PCIe dual port FC HBA");
+        else if (!strcmp(model, "Brocade-825"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 8Gbps PCIe dual port FC HBA");
+        else if (!strcmp(model, "Brocade-42B"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "HP 4Gbps PCIe dual port FC HBA");
+        else if (!strcmp(model, "Brocade-82B"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "HP 8Gbps PCIe dual port FC HBA");
+        else if (!strcmp(model, "Brocade-1010"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 10Gbps single port CNA");
+        else if (!strcmp(model, "Brocade-1020"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 10Gbps dual port CNA");
+        else if (!strcmp(model, "Brocade-1007"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 10Gbps CNA");
+        else if (!strcmp(model, "Brocade-415"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 4Gbps PCIe single port FC HBA");
+        else if (!strcmp(model, "Brocade-815"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 8Gbps PCIe single port FC HBA");
+        else if (!strcmp(model, "Brocade-41B"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "HP 4Gbps PCIe single port FC HBA");
+        else if (!strcmp(model, "Brocade-81B"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "HP 8Gbps PCIe single port FC HBA");
+        else if (!strcmp(model, "Brocade-804"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "HP Bladesystem C-class 8Gbps FC HBA");
+        else if (!strcmp(model, "Brocade-902"))
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Brocade 10Gbps CNA");
+        else
+                snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
+                        "Invalid Model");
+
         return snprintf(buf, PAGE_SIZE, "%s\n", model_descr);
 }
 
@@ -683,7 +732,7 @@ bfad_im_node_name_show(struct device *dev, struct device_attribute *attr,
         struct bfad_port_s    *port = im_port->port;
         u64        nwwn;
 
-        nwwn = bfa_fcs_port_get_nwwn(port->fcs_port);
+        nwwn = bfa_fcs_lport_get_nwwn(port->fcs_port);
         return snprintf(buf, PAGE_SIZE, "0x%llx\n", bfa_os_htonll(nwwn));
 }
 
@@ -694,14 +743,14 @@ bfad_im_symbolic_name_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
-        char model[BFA_ADAPTER_MODEL_NAME_LEN];
-        char fw_ver[BFA_VERSION_LEN];
+        struct bfad_s *bfad = im_port->bfad;
+        struct bfa_lport_attr_s port_attr;
+        char symname[BFA_SYMNAME_MAXLEN];
 
-        bfa_get_adapter_model(&bfad->bfa, model);
-        bfa_get_adapter_fw_ver(&bfad->bfa, fw_ver);
-        return snprintf(buf, PAGE_SIZE, "Brocade %s FV%s DV%s\n",
-                model, fw_ver, BFAD_DRIVER_VERSION);
+        bfa_fcs_lport_get_attr(&bfad->bfa_fcs.fabric.bport, &port_attr);
+        strncpy(symname, port_attr.port_cfg.sym_name.symname,
+                        BFA_SYMNAME_MAXLEN);
+        return snprintf(buf, PAGE_SIZE, "%s\n", symname);
 }
 
 static ssize_t
@@ -711,7 +760,7 @@ bfad_im_hw_version_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
         char hw_ver[BFA_VERSION_LEN];
 
         bfa_get_pci_chip_rev(&bfad->bfa, hw_ver);
@@ -732,7 +781,7 @@ bfad_im_optionrom_version_show(struct device *dev,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
         char optrom_ver[BFA_VERSION_LEN];
 
         bfa_get_adapter_optrom_ver(&bfad->bfa, optrom_ver);
@@ -746,7 +795,7 @@ bfad_im_fw_version_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
         char fw_ver[BFA_VERSION_LEN];
 
         bfa_get_adapter_fw_ver(&bfad->bfa, fw_ver);
@@ -760,10 +809,10 @@ bfad_im_num_of_ports_show(struct device *dev, struct device_attribute *attr,
         struct Scsi_Host *shost = class_to_shost(dev);
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfad_s         *bfad = im_port->bfad;
+        struct bfad_s *bfad = im_port->bfad;
 
         return snprintf(buf, PAGE_SIZE, "%d\n",
-                bfa_get_nports(&bfad->bfa));
+                        bfa_get_nports(&bfad->bfa));
 }
 
 static ssize_t
@@ -788,10 +837,10 @@ bfad_im_num_of_discovered_ports_show(struct device *dev,
 
         rports = kzalloc(sizeof(wwn_t) * nrports , GFP_ATOMIC);
         if (rports == NULL)
-                return -ENOMEM;
+                return snprintf(buf, PAGE_SIZE, "Failed\n");
 
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        bfa_fcs_port_get_rports(port->fcs_port, rports, &nrports);
+        bfa_fcs_lport_get_rports(port->fcs_port, rports, &nrports);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         kfree(rports);
 
@@ -837,19 +886,19 @@ struct device_attribute *bfad_im_host_attrs[] = {
 };
 
 struct device_attribute *bfad_im_vport_attrs[] = {
-    &dev_attr_serial_number,
-    &dev_attr_model,
-    &dev_attr_model_description,
-    &dev_attr_node_name,
-    &dev_attr_symbolic_name,
-    &dev_attr_hardware_version,
-    &dev_attr_driver_version,
-    &dev_attr_option_rom_version,
-    &dev_attr_firmware_version,
-    &dev_attr_number_of_ports,
-    &dev_attr_driver_name,
-    &dev_attr_number_of_discovered_ports,
-    NULL,
+        &dev_attr_serial_number,
+        &dev_attr_model,
+        &dev_attr_model_description,
+        &dev_attr_node_name,
+        &dev_attr_symbolic_name,
+        &dev_attr_hardware_version,
+        &dev_attr_driver_version,
+        &dev_attr_option_rom_version,
+        &dev_attr_firmware_version,
+        &dev_attr_number_of_ports,
+        &dev_attr_driver_name,
+        &dev_attr_number_of_discovered_ports,
+        NULL,
 };