drivers/scsi/bnx2fc/bnx2fc_fcoe.c

   1 /* bnx2fc_fcoe.c: QLogic Linux FCoE offload driver.
   2  * This file contains the code that interacts with libfc, libfcoe,
   3  * cnic modules to create FCoE instances, send/receive non-offloaded
   4  * FIP/FCoE packets, listen to link events etc.
   5  *
   6  * Copyright (c) 2008-2013 Broadcom Corporation
   7  * Copyright (c) 2014-2016 QLogic Corporation
   8  * Copyright (c) 2016-2017 Cavium Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation.
  13  *
  14  * Written by: Bhanu Prakash Gollapudi (bprakash@broadcom.com)
  15  */
  16
  17 #include "bnx2fc.h"
  18
  19 #include <linux/ethtool.h>
  20
  21 static struct list_head adapter_list;
  22 static struct list_head if_list;
  23 static u32 adapter_count;
  24 static DEFINE_MUTEX(bnx2fc_dev_lock);
  25 DEFINE_PER_CPU(struct bnx2fc_percpu_s, bnx2fc_percpu);
  26
  27 #define DRV_MODULE_NAME         "bnx2fc"
  28 #define DRV_MODULE_VERSION      BNX2FC_VERSION
  29 #define DRV_MODULE_RELDATE      "October 15, 2015"
  30
  31
  32 static char version[] =
  33                 "QLogic FCoE Driver " DRV_MODULE_NAME \
  34                 " v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
  35
  36
  37 MODULE_AUTHOR("Bhanu Prakash Gollapudi <bprakash@broadcom.com>");
  38 MODULE_DESCRIPTION("QLogic FCoE Driver");
  39 MODULE_LICENSE("GPL");
  40 MODULE_VERSION(DRV_MODULE_VERSION);
  41
  42 #define BNX2FC_MAX_QUEUE_DEPTH  256
  43 #define BNX2FC_MIN_QUEUE_DEPTH  32
  44 #define FCOE_WORD_TO_BYTE  4
  45
  46 static struct scsi_transport_template   *bnx2fc_transport_template;
  47 static struct scsi_transport_template   *bnx2fc_vport_xport_template;
  48
  49 struct workqueue_struct *bnx2fc_wq;
  50
  51 /* bnx2fc structure needs only one instance of the fcoe_percpu_s structure.
  52  * Here the io threads are per cpu but the l2 thread is just one
  53  */
  54 struct fcoe_percpu_s bnx2fc_global;
  55 static DEFINE_SPINLOCK(bnx2fc_global_lock);
  56
  57 static struct cnic_ulp_ops bnx2fc_cnic_cb;
  58 static struct libfc_function_template bnx2fc_libfc_fcn_templ;
  59 static struct scsi_host_template bnx2fc_shost_template;
  60 static struct fc_function_template bnx2fc_transport_function;
  61 static struct fcoe_sysfs_function_template bnx2fc_fcoe_sysfs_templ;
  62 static struct fc_function_template bnx2fc_vport_xport_function;
  63 static int bnx2fc_create(struct net_device *netdev, enum fip_mode fip_mode);
  64 static void __bnx2fc_destroy(struct bnx2fc_interface *interface);
  65 static int bnx2fc_destroy(struct net_device *net_device);
  66 static int bnx2fc_enable(struct net_device *netdev);
  67 static int bnx2fc_disable(struct net_device *netdev);
  68
  69 /* fcoe_syfs control interface handlers */
  70 static int bnx2fc_ctlr_alloc(struct net_device *netdev);
  71 static int bnx2fc_ctlr_enabled(struct fcoe_ctlr_device *cdev);
  72
  73 static void bnx2fc_recv_frame(struct sk_buff *skb);
  74
  75 static void bnx2fc_start_disc(struct bnx2fc_interface *interface);
  76 static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev);
  77 static int bnx2fc_lport_config(struct fc_lport *lport);
  78 static int bnx2fc_em_config(struct fc_lport *lport, struct bnx2fc_hba *hba);
  79 static int bnx2fc_bind_adapter_devices(struct bnx2fc_hba *hba);
  80 static void bnx2fc_unbind_adapter_devices(struct bnx2fc_hba *hba);
  81 static int bnx2fc_bind_pcidev(struct bnx2fc_hba *hba);
  82 static void bnx2fc_unbind_pcidev(struct bnx2fc_hba *hba);
  83 static struct fc_lport *bnx2fc_if_create(struct bnx2fc_interface *interface,
  84                                   struct device *parent, int npiv);
  85 static void bnx2fc_port_destroy(struct fcoe_port *port);
  86
  87 static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device *phys_dev);
  88 static struct bnx2fc_interface *bnx2fc_interface_lookup(struct net_device
  89                                                         *phys_dev);
  90 static inline void bnx2fc_interface_put(struct bnx2fc_interface *interface);
  91 static struct bnx2fc_hba *bnx2fc_find_hba_for_cnic(struct cnic_dev *cnic);
  92
  93 static int bnx2fc_fw_init(struct bnx2fc_hba *hba);
  94 static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba);
  95
  96 static void bnx2fc_port_shutdown(struct fc_lport *lport);
  97 static void bnx2fc_stop(struct bnx2fc_interface *interface);
  98 static int __init bnx2fc_mod_init(void);
  99 static void __exit bnx2fc_mod_exit(void);
 100
 101 unsigned int bnx2fc_debug_level;
 102 module_param_named(debug_logging, bnx2fc_debug_level, int, S_IRUGO|S_IWUSR);
 103 MODULE_PARM_DESC(debug_logging,
 104                 "Option to enable extended logging,\n"
 105                 "\t\tDefault is 0 - no logging.\n"
 106                 "\t\t0x01 - SCSI cmd error, cleanup.\n"
 107                 "\t\t0x02 - Session setup, cleanup, etc.\n"
 108                 "\t\t0x04 - lport events, link, mtu, etc.\n"
 109                 "\t\t0x08 - ELS logs.\n"
 110                 "\t\t0x10 - fcoe L2 fame related logs.\n"
 111                 "\t\t0xff - LOG all messages.");
 112
 113 static uint bnx2fc_devloss_tmo;
 114 module_param_named(devloss_tmo, bnx2fc_devloss_tmo, uint, S_IRUGO);
 115 MODULE_PARM_DESC(devloss_tmo, " Change devloss_tmo for the remote ports "
 116         "attached via bnx2fc.");
 117
 118 static uint bnx2fc_max_luns = BNX2FC_MAX_LUN;
 119 module_param_named(max_luns, bnx2fc_max_luns, uint, S_IRUGO);
 120 MODULE_PARM_DESC(max_luns, " Change the default max_lun per SCSI host. Default "
 121         "0xffff.");
 122
 123 static uint bnx2fc_queue_depth;
 124 module_param_named(queue_depth, bnx2fc_queue_depth, uint, S_IRUGO);
 125 MODULE_PARM_DESC(queue_depth, " Change the default queue depth of SCSI devices "
 126         "attached via bnx2fc.");
 127
 128 static uint bnx2fc_log_fka;
 129 module_param_named(log_fka, bnx2fc_log_fka, uint, S_IRUGO|S_IWUSR);
 130 MODULE_PARM_DESC(log_fka, " Print message to kernel log when fcoe is "
 131         "initiating a FIP keep alive when debug logging is enabled.");
 132
 133 static inline struct net_device *bnx2fc_netdev(const struct fc_lport *lport)
 134 {
 135         return ((struct bnx2fc_interface *)
 136                 ((struct fcoe_port *)lport_priv(lport))->priv)->netdev;
 137 }
 138
 139 static void bnx2fc_fcf_get_vlan_id(struct fcoe_fcf_device *fcf_dev)
 140 {
 141         struct fcoe_ctlr_device *ctlr_dev =
 142                 fcoe_fcf_dev_to_ctlr_dev(fcf_dev);
 143         struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr_dev);
 144         struct bnx2fc_interface *fcoe = fcoe_ctlr_priv(ctlr);
 145
 146         fcf_dev->vlan_id = fcoe->vlan_id;
 147 }
 148
 149 static void bnx2fc_clean_rx_queue(struct fc_lport *lp)
 150 {
 151         struct fcoe_percpu_s *bg;
 152         struct fcoe_rcv_info *fr;
 153         struct sk_buff_head *list;
 154         struct sk_buff *skb, *next;
 155
 156         bg = &bnx2fc_global;
 157         spin_lock_bh(&bg->fcoe_rx_list.lock);
 158         list = &bg->fcoe_rx_list;
 159         skb_queue_walk_safe(list, skb, next) {
 160                 fr = fcoe_dev_from_skb(skb);
 161                 if (fr->fr_dev == lp) {
 162                         __skb_unlink(skb, list);
 163                         kfree_skb(skb);
 164                 }
 165         }
 166         spin_unlock_bh(&bg->fcoe_rx_list.lock);
 167 }
 168
 169 int bnx2fc_get_paged_crc_eof(struct sk_buff *skb, int tlen)
 170 {
 171         int rc;
 172         spin_lock(&bnx2fc_global_lock);
 173         rc = fcoe_get_paged_crc_eof(skb, tlen, &bnx2fc_global);
 174         spin_unlock(&bnx2fc_global_lock);
 175
 176         return rc;
 177 }
 178
 179 static void bnx2fc_abort_io(struct fc_lport *lport)
 180 {
 181         /*
 182          * This function is no-op for bnx2fc, but we do
 183          * not want to leave it as NULL either, as libfc
 184          * can call the default function which is
 185          * fc_fcp_abort_io.
 186          */
 187 }
 188
 189 static void bnx2fc_cleanup(struct fc_lport *lport)
 190 {
 191         struct fcoe_port *port = lport_priv(lport);
 192         struct bnx2fc_interface *interface = port->priv;
 193         struct bnx2fc_hba *hba = interface->hba;
 194         struct bnx2fc_rport *tgt;
 195         int i;
 196
 197         BNX2FC_MISC_DBG("Entered %s\n", __func__);
 198         mutex_lock(&hba->hba_mutex);
 199         spin_lock_bh(&hba->hba_lock);
 200         for (i = 0; i < BNX2FC_NUM_MAX_SESS; i++) {
 201                 tgt = hba->tgt_ofld_list[i];
 202                 if (tgt) {
 203                         /* Cleanup IOs belonging to requested vport */
 204                         if (tgt->port == port) {
 205                                 spin_unlock_bh(&hba->hba_lock);
 206                                 BNX2FC_TGT_DBG(tgt, "flush/cleanup\n");
 207                                 bnx2fc_flush_active_ios(tgt);
 208                                 spin_lock_bh(&hba->hba_lock);
 209                         }
 210                 }
 211         }
 212         spin_unlock_bh(&hba->hba_lock);
 213         mutex_unlock(&hba->hba_mutex);
 214 }
 215
 216 static int bnx2fc_xmit_l2_frame(struct bnx2fc_rport *tgt,
 217                              struct fc_frame *fp)
 218 {
 219         struct fc_rport_priv *rdata = tgt->rdata;
 220         struct fc_frame_header *fh;
 221         int rc = 0;
 222
 223         fh = fc_frame_header_get(fp);
 224         BNX2FC_TGT_DBG(tgt, "Xmit L2 frame rport = 0x%x, oxid = 0x%x, "
 225                         "r_ctl = 0x%x\n", rdata->ids.port_id,
 226                         ntohs(fh->fh_ox_id), fh->fh_r_ctl);
 227         if ((fh->fh_type == FC_TYPE_ELS) &&
 228             (fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
 229
 230                 switch (fc_frame_payload_op(fp)) {
 231                 case ELS_ADISC:
 232                         rc = bnx2fc_send_adisc(tgt, fp);
 233                         break;
 234                 case ELS_LOGO:
 235                         rc = bnx2fc_send_logo(tgt, fp);
 236                         break;
 237                 case ELS_RLS:
 238                         rc = bnx2fc_send_rls(tgt, fp);
 239                         break;
 240                 default:
 241                         break;
 242                 }
 243         } else if ((fh->fh_type ==  FC_TYPE_BLS) &&
 244             (fh->fh_r_ctl == FC_RCTL_BA_ABTS))
 245                 BNX2FC_TGT_DBG(tgt, "ABTS frame\n");
 246         else {
 247                 BNX2FC_TGT_DBG(tgt, "Send L2 frame type 0x%x "
 248                                 "rctl 0x%x thru non-offload path\n",
 249                                 fh->fh_type, fh->fh_r_ctl);
 250                 return -ENODEV;
 251         }
 252         if (rc)
 253                 return -ENOMEM;
 254         else
 255                 return 0;
 256 }
 257
 258 /**
 259  * bnx2fc_xmit - bnx2fc's FCoE frame transmit function
 260  *
 261  * @lport:      the associated local port
 262  * @fp: the fc_frame to be transmitted
 263  */
 264 static int bnx2fc_xmit(struct fc_lport *lport, struct fc_frame *fp)
 265 {
 266         struct ethhdr           *eh;
 267         struct fcoe_crc_eof     *cp;
 268         struct sk_buff          *skb;
 269         struct fc_frame_header  *fh;
 270         struct bnx2fc_interface *interface;
 271         struct fcoe_ctlr        *ctlr;
 272         struct bnx2fc_hba *hba;
 273         struct fcoe_port        *port;
 274         struct fcoe_hdr         *hp;
 275         struct bnx2fc_rport     *tgt;
 276         u8                      sof, eof;
 277         u32                     crc;
 278         unsigned int            hlen, tlen, elen;
 279         int                     wlen, rc = 0;
 280
 281         port = (struct fcoe_port *)lport_priv(lport);
 282         interface = port->priv;
 283         ctlr = bnx2fc_to_ctlr(interface);
 284         hba = interface->hba;
 285
 286         fh = fc_frame_header_get(fp);
 287
 288         skb = fp_skb(fp);
 289         if (!lport->link_up) {
 290                 BNX2FC_HBA_DBG(lport, "bnx2fc_xmit link down\n");
 291                 kfree_skb(skb);
 292                 return 0;
 293         }
 294
 295         if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
 296                 if (!ctlr->sel_fcf) {
 297                         BNX2FC_HBA_DBG(lport, "FCF not selected yet!\n");
 298                         kfree_skb(skb);
 299                         return -EINVAL;
 300                 }
 301                 if (fcoe_ctlr_els_send(ctlr, lport, skb))
 302                         return 0;
 303         }
 304
 305         sof = fr_sof(fp);
 306         eof = fr_eof(fp);
 307
 308         /*
 309          * Snoop the frame header to check if the frame is for
 310          * an offloaded session
 311          */
 312         /*
 313          * tgt_ofld_list access is synchronized using
 314          * both hba mutex and hba lock. Atleast hba mutex or
 315          * hba lock needs to be held for read access.
 316          */
 317
 318         spin_lock_bh(&hba->hba_lock);
 319         tgt = bnx2fc_tgt_lookup(port, ntoh24(fh->fh_d_id));
 320         if (tgt && (test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags))) {
 321                 /* This frame is for offloaded session */
 322                 BNX2FC_HBA_DBG(lport, "xmit: Frame is for offloaded session "
 323                                 "port_id = 0x%x\n", ntoh24(fh->fh_d_id));
 324                 spin_unlock_bh(&hba->hba_lock);
 325                 rc = bnx2fc_xmit_l2_frame(tgt, fp);
 326                 if (rc != -ENODEV) {
 327                         kfree_skb(skb);
 328                         return rc;
 329                 }
 330         } else {
 331                 spin_unlock_bh(&hba->hba_lock);
 332         }
 333
 334         elen = sizeof(struct ethhdr);
 335         hlen = sizeof(struct fcoe_hdr);
 336         tlen = sizeof(struct fcoe_crc_eof);
 337         wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
 338
 339         skb->ip_summed = CHECKSUM_NONE;
 340         crc = fcoe_fc_crc(fp);
 341
 342         /* copy port crc and eof to the skb buff */
 343         if (skb_is_nonlinear(skb)) {
 344                 skb_frag_t *frag;
 345                 if (bnx2fc_get_paged_crc_eof(skb, tlen)) {
 346                         kfree_skb(skb);
 347                         return -ENOMEM;
 348                 }
 349                 frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
 350                 cp = kmap_atomic(skb_frag_page(frag)) + skb_frag_off(frag);
 351         } else {
 352                 cp = skb_put(skb, tlen);
 353         }
 354
 355         memset(cp, 0, sizeof(*cp));
 356         cp->fcoe_eof = eof;
 357         cp->fcoe_crc32 = cpu_to_le32(~crc);
 358         if (skb_is_nonlinear(skb)) {
 359                 kunmap_atomic(cp);
 360                 cp = NULL;
 361         }
 362
 363         /* adjust skb network/transport offsets to match mac/fcoe/port */
 364         skb_push(skb, elen + hlen);
 365         skb_reset_mac_header(skb);
 366         skb_reset_network_header(skb);
 367         skb->mac_len = elen;
 368         skb->protocol = htons(ETH_P_FCOE);
 369         skb->dev = interface->netdev;
 370
 371         /* fill up mac and fcoe headers */
 372         eh = eth_hdr(skb);
 373         eh->h_proto = htons(ETH_P_FCOE);
 374         if (ctlr->map_dest)
 375                 fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
 376         else
 377                 /* insert GW address */
 378                 memcpy(eh->h_dest, ctlr->dest_addr, ETH_ALEN);
 379
 380         if (unlikely(ctlr->flogi_oxid != FC_XID_UNKNOWN))
 381                 memcpy(eh->h_source, ctlr->ctl_src_addr, ETH_ALEN);
 382         else
 383                 memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
 384
 385         hp = (struct fcoe_hdr *)(eh + 1);
 386         memset(hp, 0, sizeof(*hp));
 387         if (FC_FCOE_VER)
 388                 FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
 389         hp->fcoe_sof = sof;
 390
 391         /* fcoe lso, mss is in max_payload which is non-zero for FCP data */
 392         if (lport->seq_offload && fr_max_payload(fp)) {
 393                 skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
 394                 skb_shinfo(skb)->gso_size = fr_max_payload(fp);
 395         } else {
 396                 skb_shinfo(skb)->gso_type = 0;
 397                 skb_shinfo(skb)->gso_size = 0;
 398         }
 399
 400         /*update tx stats */
 401         this_cpu_inc(lport->stats->TxFrames);
 402         this_cpu_add(lport->stats->TxWords, wlen);
 403
 404         /* send down to lld */
 405         fr_dev(fp) = lport;
 406         if (port->fcoe_pending_queue.qlen)
 407                 fcoe_check_wait_queue(lport, skb);
 408         else if (fcoe_start_io(skb))
 409                 fcoe_check_wait_queue(lport, skb);
 410
 411         return 0;
 412 }
 413
 414 /**
 415  * bnx2fc_rcv - This is bnx2fc's receive function called by NET_RX_SOFTIRQ
 416  *
 417  * @skb:        the receive socket buffer
 418  * @dev:        associated net device
 419  * @ptype:      context
 420  * @olddev:     last device
 421  *
 422  * This function receives the packet and builds FC frame and passes it up
 423  */
 424 static int bnx2fc_rcv(struct sk_buff *skb, struct net_device *dev,
 425                 struct packet_type *ptype, struct net_device *olddev)
 426 {
 427         struct fc_lport *lport;
 428         struct bnx2fc_interface *interface;
 429         struct fcoe_ctlr *ctlr;
 430         struct fcoe_rcv_info *fr;
 431         struct fcoe_percpu_s *bg;
 432         struct sk_buff *tmp_skb;
 433
 434         interface = container_of(ptype, struct bnx2fc_interface,
 435                                  fcoe_packet_type);
 436         ctlr = bnx2fc_to_ctlr(interface);
 437         lport = ctlr->lp;
 438
 439         if (unlikely(lport == NULL)) {
 440                 printk(KERN_ERR PFX "bnx2fc_rcv: lport is NULL\n");
 441                 goto err;
 442         }
 443
 444         tmp_skb = skb_share_check(skb, GFP_ATOMIC);
 445         if (!tmp_skb)
 446                 goto err;
 447
 448         skb = tmp_skb;
 449
 450         if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
 451                 printk(KERN_ERR PFX "bnx2fc_rcv: Wrong FC type frame\n");
 452                 goto err;
 453         }
 454
 455         /*
 456          * Check for minimum frame length, and make sure required FCoE
 457          * and FC headers are pulled into the linear data area.
 458          */
 459         if (unlikely((skb->len < FCOE_MIN_FRAME) ||
 460             !pskb_may_pull(skb, FCOE_HEADER_LEN)))
 461                 goto err;
 462
 463         skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
 464
 465         fr = fcoe_dev_from_skb(skb);
 466         fr->fr_dev = lport;
 467
 468         bg = &bnx2fc_global;
 469         spin_lock(&bg->fcoe_rx_list.lock);
 470
 471         __skb_queue_tail(&bg->fcoe_rx_list, skb);
 472         if (bg->fcoe_rx_list.qlen == 1)
 473                 wake_up_process(bg->kthread);
 474
 475         spin_unlock(&bg->fcoe_rx_list.lock);
 476
 477         return 0;
 478 err:
 479         kfree_skb(skb);
 480         return -1;
 481 }
 482
 483 static int bnx2fc_l2_rcv_thread(void *arg)
 484 {
 485         struct fcoe_percpu_s *bg = arg;
 486         struct sk_buff *skb;
 487
 488         set_user_nice(current, MIN_NICE);
 489         set_current_state(TASK_INTERRUPTIBLE);
 490         while (!kthread_should_stop()) {
 491                 schedule();
 492                 spin_lock_bh(&bg->fcoe_rx_list.lock);
 493                 while ((skb = __skb_dequeue(&bg->fcoe_rx_list)) != NULL) {
 494                         spin_unlock_bh(&bg->fcoe_rx_list.lock);
 495                         bnx2fc_recv_frame(skb);
 496                         spin_lock_bh(&bg->fcoe_rx_list.lock);
 497                 }
 498                 __set_current_state(TASK_INTERRUPTIBLE);
 499                 spin_unlock_bh(&bg->fcoe_rx_list.lock);
 500         }
 501         __set_current_state(TASK_RUNNING);
 502         return 0;
 503 }
 504
 505
 506 static void bnx2fc_recv_frame(struct sk_buff *skb)
 507 {
 508         u64 crc_err;
 509         u32 fr_len, fr_crc;
 510         struct fc_lport *lport;
 511         struct fcoe_rcv_info *fr;
 512         struct fc_frame_header *fh;
 513         struct fcoe_crc_eof crc_eof;
 514         struct fc_frame *fp;
 515         struct fc_lport *vn_port;
 516         struct fcoe_port *port, *phys_port;
 517         u8 *mac = NULL;
 518         u8 *dest_mac = NULL;
 519         struct fcoe_hdr *hp;
 520         struct bnx2fc_interface *interface;
 521         struct fcoe_ctlr *ctlr;
 522
 523         fr = fcoe_dev_from_skb(skb);
 524         lport = fr->fr_dev;
 525         if (unlikely(lport == NULL)) {
 526                 printk(KERN_ERR PFX "Invalid lport struct\n");
 527                 kfree_skb(skb);
 528                 return;
 529         }
 530
 531         if (skb_is_nonlinear(skb))
 532                 skb_linearize(skb);
 533         mac = eth_hdr(skb)->h_source;
 534         dest_mac = eth_hdr(skb)->h_dest;
 535
 536         /* Pull the header */
 537         hp = (struct fcoe_hdr *) skb_network_header(skb);
 538         fh = (struct fc_frame_header *) skb_transport_header(skb);
 539         skb_pull(skb, sizeof(struct fcoe_hdr));
 540         fr_len = skb->len - sizeof(struct fcoe_crc_eof);
 541
 542         this_cpu_inc(lport->stats->RxFrames);
 543         this_cpu_add(lport->stats->RxWords, fr_len / FCOE_WORD_TO_BYTE);
 544
 545         fp = (struct fc_frame *)skb;
 546         fc_frame_init(fp);
 547         fr_dev(fp) = lport;
 548         fr_sof(fp) = hp->fcoe_sof;
 549         if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
 550                 kfree_skb(skb);
 551                 return;
 552         }
 553         fr_eof(fp) = crc_eof.fcoe_eof;
 554         fr_crc(fp) = crc_eof.fcoe_crc32;
 555         if (pskb_trim(skb, fr_len)) {
 556                 kfree_skb(skb);
 557                 return;
 558         }
 559
 560         phys_port = lport_priv(lport);
 561         interface = phys_port->priv;
 562         ctlr = bnx2fc_to_ctlr(interface);
 563
 564         fh = fc_frame_header_get(fp);
 565
 566         if (ntoh24(&dest_mac[3]) != ntoh24(fh->fh_d_id)) {
 567                 BNX2FC_HBA_DBG(lport, "FC frame d_id mismatch with MAC %pM.\n",
 568                     dest_mac);
 569                 kfree_skb(skb);
 570                 return;
 571         }
 572
 573         vn_port = fc_vport_id_lookup(lport, ntoh24(fh->fh_d_id));
 574         if (vn_port) {
 575                 port = lport_priv(vn_port);
 576                 if (!ether_addr_equal(port->data_src_addr, dest_mac)) {
 577                         BNX2FC_HBA_DBG(lport, "fpma mismatch\n");
 578                         kfree_skb(skb);
 579                         return;
 580                 }
 581         }
 582         if (ctlr->state) {
 583                 if (!ether_addr_equal(mac, ctlr->dest_addr)) {
 584                         BNX2FC_HBA_DBG(lport, "Wrong source address: mac:%pM dest_addr:%pM.\n",
 585                             mac, ctlr->dest_addr);
 586                         kfree_skb(skb);
 587                         return;
 588                 }
 589         }
 590         if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
 591             fh->fh_type == FC_TYPE_FCP) {
 592                 /* Drop FCP data. We dont this in L2 path */
 593                 kfree_skb(skb);
 594                 return;
 595         }
 596         if (fh->fh_r_ctl == FC_RCTL_ELS_REQ &&
 597             fh->fh_type == FC_TYPE_ELS) {
 598                 switch (fc_frame_payload_op(fp)) {
 599                 case ELS_LOGO:
 600                         if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI) {
 601                                 /* drop non-FIP LOGO */
 602                                 kfree_skb(skb);
 603                                 return;
 604                         }
 605                         break;
 606                 }
 607         }
 608
 609         if (fh->fh_r_ctl == FC_RCTL_BA_ABTS) {
 610                 /* Drop incoming ABTS */
 611                 kfree_skb(skb);
 612                 return;
 613         }
 614
 615         /*
 616          * If the destination ID from the frame header does not match what we
 617          * have on record for lport and the search for a NPIV port came up
 618          * empty then this is not addressed to our port so simply drop it.
 619          */
 620         if (lport->port_id != ntoh24(fh->fh_d_id) && !vn_port) {
 621                 BNX2FC_HBA_DBG(lport, "Dropping frame due to destination mismatch: lport->port_id=%x fh->d_id=%x.\n",
 622                     lport->port_id, ntoh24(fh->fh_d_id));
 623                 kfree_skb(skb);
 624                 return;
 625         }
 626
 627         fr_crc = le32_to_cpu(fr_crc(fp));
 628
 629         if (unlikely(fr_crc != ~crc32(~0, skb->data, fr_len))) {
 630                 crc_err = this_cpu_inc_return(lport->stats->InvalidCRCCount);
 631                 if (crc_err < 5)
 632                         printk(KERN_WARNING PFX "dropping frame with "
 633                                "CRC error\n");
 634                 kfree_skb(skb);
 635                 return;
 636         }
 637         fc_exch_recv(lport, fp);
 638 }
 639
 640 /**
 641  * bnx2fc_percpu_io_thread - thread per cpu for ios
 642  *
 643  * @arg:        ptr to bnx2fc_percpu_info structure
 644  */
 645 static int bnx2fc_percpu_io_thread(void *arg)
 646 {
 647         struct bnx2fc_percpu_s *p = arg;
 648         struct bnx2fc_work *work, *tmp;
 649         LIST_HEAD(work_list);
 650
 651         set_user_nice(current, MIN_NICE);
 652         set_current_state(TASK_INTERRUPTIBLE);
 653         while (!kthread_should_stop()) {
 654                 schedule();
 655                 spin_lock_bh(&p->fp_work_lock);
 656                 while (!list_empty(&p->work_list)) {
 657                         list_splice_init(&p->work_list, &work_list);
 658                         spin_unlock_bh(&p->fp_work_lock);
 659
 660                         list_for_each_entry_safe(work, tmp, &work_list, list) {
 661                                 list_del_init(&work->list);
 662                                 bnx2fc_process_cq_compl(work->tgt, work->wqe,
 663                                                         work->rq_data,
 664                                                         work->num_rq,
 665                                                         work->task);
 666                                 kfree(work);
 667                         }
 668
 669                         spin_lock_bh(&p->fp_work_lock);
 670                 }
 671                 __set_current_state(TASK_INTERRUPTIBLE);
 672                 spin_unlock_bh(&p->fp_work_lock);
 673         }
 674         __set_current_state(TASK_RUNNING);
 675
 676         return 0;
 677 }
 678
 679 static struct fc_host_statistics *bnx2fc_get_host_stats(struct Scsi_Host *shost)
 680 {
 681         struct fc_host_statistics *bnx2fc_stats;
 682         struct fc_lport *lport = shost_priv(shost);
 683         struct fcoe_port *port = lport_priv(lport);
 684         struct bnx2fc_interface *interface = port->priv;
 685         struct bnx2fc_hba *hba = interface->hba;
 686         struct fcoe_statistics_params *fw_stats;
 687         int rc = 0;
 688
 689         fw_stats = (struct fcoe_statistics_params *)hba->stats_buffer;
 690         if (!fw_stats)
 691                 return NULL;
 692
 693         mutex_lock(&hba->hba_stats_mutex);
 694
 695         bnx2fc_stats = fc_get_host_stats(shost);
 696
 697         init_completion(&hba->stat_req_done);
 698         if (bnx2fc_send_stat_req(hba))
 699                 goto unlock_stats_mutex;
 700         rc = wait_for_completion_timeout(&hba->stat_req_done, (2 * HZ));
 701         if (!rc) {
 702                 BNX2FC_HBA_DBG(lport, "FW stat req timed out\n");
 703                 goto unlock_stats_mutex;
 704         }
 705         BNX2FC_STATS(hba, rx_stat2, fc_crc_cnt);
 706         bnx2fc_stats->invalid_crc_count += hba->bfw_stats.fc_crc_cnt;
 707         BNX2FC_STATS(hba, tx_stat, fcoe_tx_pkt_cnt);
 708         bnx2fc_stats->tx_frames += hba->bfw_stats.fcoe_tx_pkt_cnt;
 709         BNX2FC_STATS(hba, tx_stat, fcoe_tx_byte_cnt);
 710         bnx2fc_stats->tx_words += ((hba->bfw_stats.fcoe_tx_byte_cnt) / 4);
 711         BNX2FC_STATS(hba, rx_stat0, fcoe_rx_pkt_cnt);
 712         bnx2fc_stats->rx_frames += hba->bfw_stats.fcoe_rx_pkt_cnt;
 713         BNX2FC_STATS(hba, rx_stat0, fcoe_rx_byte_cnt);
 714         bnx2fc_stats->rx_words += ((hba->bfw_stats.fcoe_rx_byte_cnt) / 4);
 715
 716         bnx2fc_stats->dumped_frames = 0;
 717         bnx2fc_stats->lip_count = 0;
 718         bnx2fc_stats->nos_count = 0;
 719         bnx2fc_stats->loss_of_sync_count = 0;
 720         bnx2fc_stats->loss_of_signal_count = 0;
 721         bnx2fc_stats->prim_seq_protocol_err_count = 0;
 722
 723         memcpy(&hba->prev_stats, hba->stats_buffer,
 724                sizeof(struct fcoe_statistics_params));
 725
 726 unlock_stats_mutex:
 727         mutex_unlock(&hba->hba_stats_mutex);
 728         return bnx2fc_stats;
 729 }
 730
 731 static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
 732 {
 733         struct fcoe_port *port = lport_priv(lport);
 734         struct bnx2fc_interface *interface = port->priv;
 735         struct bnx2fc_hba *hba = interface->hba;
 736         struct Scsi_Host *shost = lport->host;
 737         int rc = 0;
 738
 739         shost->max_cmd_len = BNX2FC_MAX_CMD_LEN;
 740         shost->max_lun = bnx2fc_max_luns;
 741         shost->max_id = BNX2FC_MAX_FCP_TGT;
 742         shost->max_channel = 0;
 743         if (lport->vport)
 744                 shost->transportt = bnx2fc_vport_xport_template;
 745         else
 746                 shost->transportt = bnx2fc_transport_template;
 747
 748         /* Add the new host to SCSI-ml */
 749         rc = scsi_add_host(lport->host, dev);
 750         if (rc) {
 751                 printk(KERN_ERR PFX "Error on scsi_add_host\n");
 752                 return rc;
 753         }
 754         if (!lport->vport)
 755                 fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
 756         snprintf(fc_host_symbolic_name(lport->host), 256,
 757                  "%s (QLogic %s) v%s over %s",
 758                 BNX2FC_NAME, hba->chip_num, BNX2FC_VERSION,
 759                 interface->netdev->name);
 760
 761         return 0;
 762 }
 763
 764 static int bnx2fc_link_ok(struct fc_lport *lport)
 765 {
 766         struct fcoe_port *port = lport_priv(lport);
 767         struct bnx2fc_interface *interface = port->priv;
 768         struct bnx2fc_hba *hba = interface->hba;
 769         struct net_device *dev = hba->phys_dev;
 770         int rc = 0;
 771
 772         if ((dev->flags & IFF_UP) && netif_carrier_ok(dev))
 773                 clear_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
 774         else {
 775                 set_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
 776                 rc = -1;
 777         }
 778         return rc;
 779 }
 780
 781 /**
 782  * bnx2fc_get_link_state - get network link state
 783  *
 784  * @hba:        adapter instance pointer
 785  *
 786  * updates adapter structure flag based on netdev state
 787  */
 788 void bnx2fc_get_link_state(struct bnx2fc_hba *hba)
 789 {
 790         if (test_bit(__LINK_STATE_NOCARRIER, &hba->phys_dev->state))
 791                 set_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
 792         else
 793                 clear_bit(ADAPTER_STATE_LINK_DOWN, &hba->adapter_state);
 794 }
 795
 796 static int bnx2fc_net_config(struct fc_lport *lport, struct net_device *netdev)
 797 {
 798         struct bnx2fc_hba *hba;
 799         struct bnx2fc_interface *interface;
 800         struct fcoe_ctlr *ctlr;
 801         struct fcoe_port *port;
 802         u64 wwnn, wwpn;
 803
 804         port = lport_priv(lport);
 805         interface = port->priv;
 806         ctlr = bnx2fc_to_ctlr(interface);
 807         hba = interface->hba;
 808
 809         /* require support for get_pauseparam ethtool op. */
 810         if (!hba->phys_dev->ethtool_ops ||
 811             !hba->phys_dev->ethtool_ops->get_pauseparam)
 812                 return -EOPNOTSUPP;
 813
 814         if (fc_set_mfs(lport, BNX2FC_MFS))
 815                 return -EINVAL;
 816
 817         skb_queue_head_init(&port->fcoe_pending_queue);
 818         port->fcoe_pending_queue_active = 0;
 819         timer_setup(&port->timer, fcoe_queue_timer, 0);
 820
 821         fcoe_link_speed_update(lport);
 822
 823         if (!lport->vport) {
 824                 if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
 825                         wwnn = fcoe_wwn_from_mac(ctlr->ctl_src_addr,
 826                                                  1, 0);
 827                 BNX2FC_HBA_DBG(lport, "WWNN = 0x%llx\n", wwnn);
 828                 fc_set_wwnn(lport, wwnn);
 829
 830                 if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
 831                         wwpn = fcoe_wwn_from_mac(ctlr->ctl_src_addr,
 832                                                  2, 0);
 833
 834                 BNX2FC_HBA_DBG(lport, "WWPN = 0x%llx\n", wwpn);
 835                 fc_set_wwpn(lport, wwpn);
 836         }
 837
 838         return 0;
 839 }
 840
 841 static void bnx2fc_destroy_timer(struct timer_list *t)
 842 {
 843         struct bnx2fc_hba *hba = from_timer(hba, t, destroy_timer);
 844
 845         printk(KERN_ERR PFX "ERROR:bnx2fc_destroy_timer - "
 846                "Destroy compl not received!!\n");
 847         set_bit(BNX2FC_FLAG_DESTROY_CMPL, &hba->flags);
 848         wake_up_interruptible(&hba->destroy_wait);
 849 }
 850
 851 /**
 852  * bnx2fc_indicate_netevent - Generic netdev event handler
 853  *
 854  * @context:    adapter structure pointer
 855  * @event:      event type
 856  * @vlan_id:    vlan id - associated vlan id with this event
 857  *
 858  * Handles NETDEV_UP, NETDEV_DOWN, NETDEV_GOING_DOWN,NETDEV_CHANGE and
 859  * NETDEV_CHANGE_MTU events. Handle NETDEV_UNREGISTER only for vlans.
 860  */
 861 static void bnx2fc_indicate_netevent(void *context, unsigned long event,
 862                                      u16 vlan_id)
 863 {
 864         struct bnx2fc_hba *hba = (struct bnx2fc_hba *)context;
 865         struct fcoe_ctlr_device *cdev;
 866         struct fc_lport *lport;
 867         struct fc_lport *vport;
 868         struct bnx2fc_interface *interface, *tmp;
 869         struct fcoe_ctlr *ctlr;
 870         int wait_for_upload = 0;
 871         u32 link_possible = 1;
 872
 873         if (vlan_id != 0 && event != NETDEV_UNREGISTER)
 874                 return;
 875
 876         switch (event) {
 877         case NETDEV_UP:
 878                 if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state))
 879                         printk(KERN_ERR "indicate_netevent: "\
 880                                         "hba is not UP!!\n");
 881                 break;
 882
 883         case NETDEV_DOWN:
 884                 clear_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
 885                 clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
 886                 link_possible = 0;
 887                 break;
 888
 889         case NETDEV_GOING_DOWN:
 890                 set_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state);
 891                 link_possible = 0;
 892                 break;
 893
 894         case NETDEV_CHANGE:
 895                 break;
 896
 897         case NETDEV_UNREGISTER:
 898                 if (!vlan_id)
 899                         return;
 900                 mutex_lock(&bnx2fc_dev_lock);
 901                 list_for_each_entry_safe(interface, tmp, &if_list, list) {
 902                         if (interface->hba == hba &&
 903                             interface->vlan_id == (vlan_id & VLAN_VID_MASK))
 904                                 __bnx2fc_destroy(interface);
 905                 }
 906                 mutex_unlock(&bnx2fc_dev_lock);
 907                 return;
 908
 909         default:
 910                 return;
 911         }
 912
 913         mutex_lock(&bnx2fc_dev_lock);
 914         list_for_each_entry(interface, &if_list, list) {
 915
 916                 if (interface->hba != hba)
 917                         continue;
 918
 919                 ctlr = bnx2fc_to_ctlr(interface);
 920                 lport = ctlr->lp;
 921                 BNX2FC_HBA_DBG(lport, "netevent handler - event=%s %ld\n",
 922                                 interface->netdev->name, event);
 923
 924                 fcoe_link_speed_update(lport);
 925
 926                 cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
 927
 928                 if (link_possible && !bnx2fc_link_ok(lport)) {
 929                         switch (cdev->enabled) {
 930                         case FCOE_CTLR_DISABLED:
 931                                 pr_info("Link up while interface is disabled.\n");
 932                                 break;
 933                         case FCOE_CTLR_ENABLED:
 934                         case FCOE_CTLR_UNUSED:
 935                                 /* Reset max recv frame size to default */
 936                                 fc_set_mfs(lport, BNX2FC_MFS);
 937                                 /*
 938                                  * ctlr link up will only be handled during
 939                                  * enable to avoid sending discovery
 940                                  * solicitation on a stale vlan
 941                                  */
 942                                 if (interface->enabled)
 943                                         fcoe_ctlr_link_up(ctlr);
 944                         }
 945                 } else if (fcoe_ctlr_link_down(ctlr)) {
 946                         switch (cdev->enabled) {
 947                         case FCOE_CTLR_DISABLED:
 948                                 pr_info("Link down while interface is disabled.\n");
 949                                 break;
 950                         case FCOE_CTLR_ENABLED:
 951                         case FCOE_CTLR_UNUSED:
 952                                 mutex_lock(&lport->lp_mutex);
 953                                 list_for_each_entry(vport, &lport->vports, list)
 954                                         fc_host_port_type(vport->host) =
 955                                         FC_PORTTYPE_UNKNOWN;
 956                                 mutex_unlock(&lport->lp_mutex);
 957                                 fc_host_port_type(lport->host) =
 958                                         FC_PORTTYPE_UNKNOWN;
 959                                 this_cpu_inc(lport->stats->LinkFailureCount);
 960                                 fcoe_clean_pending_queue(lport);
 961                                 wait_for_upload = 1;
 962                         }
 963                 }
 964         }
 965         mutex_unlock(&bnx2fc_dev_lock);
 966
 967         if (wait_for_upload) {
 968                 clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
 969                 init_waitqueue_head(&hba->shutdown_wait);
 970                 BNX2FC_MISC_DBG("indicate_netevent "
 971                                 "num_ofld_sess = %d\n",
 972                                 hba->num_ofld_sess);
 973                 hba->wait_for_link_down = 1;
 974                 wait_event_interruptible(hba->shutdown_wait,
 975                                          (hba->num_ofld_sess == 0));
 976                 BNX2FC_MISC_DBG("wakeup - num_ofld_sess = %d\n",
 977                                 hba->num_ofld_sess);
 978                 hba->wait_for_link_down = 0;
 979
 980                 if (signal_pending(current))
 981                         flush_signals(current);
 982         }
 983 }
 984
 985 static int bnx2fc_libfc_config(struct fc_lport *lport)
 986 {
 987
 988         /* Set the function pointers set by bnx2fc driver */
 989         memcpy(&lport->tt, &bnx2fc_libfc_fcn_templ,
 990                 sizeof(struct libfc_function_template));
 991         fc_elsct_init(lport);
 992         fc_exch_init(lport);
 993         fc_disc_init(lport);
 994         fc_disc_config(lport, lport);
 995         return 0;
 996 }
 997
 998 static int bnx2fc_em_config(struct fc_lport *lport, struct bnx2fc_hba *hba)
 999 {
1000         int fcoe_min_xid, fcoe_max_xid;
1001
1002         fcoe_min_xid = hba->max_xid + 1;
1003         if (nr_cpu_ids <= 2)
1004                 fcoe_max_xid = hba->max_xid + FCOE_XIDS_PER_CPU_OFFSET;
1005         else
1006                 fcoe_max_xid = hba->max_xid + FCOE_MAX_XID_OFFSET;
1007         if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, fcoe_min_xid,
1008                                fcoe_max_xid, NULL)) {
1009                 printk(KERN_ERR PFX "em_config:fc_exch_mgr_alloc failed\n");
1010                 return -ENOMEM;
1011         }
1012
1013         return 0;
1014 }
1015
1016 static int bnx2fc_lport_config(struct fc_lport *lport)
1017 {
1018         lport->link_up = 0;
1019         lport->qfull = 0;
1020         lport->max_retry_count = BNX2FC_MAX_RETRY_CNT;
1021         lport->max_rport_retry_count = BNX2FC_MAX_RPORT_RETRY_CNT;
1022         lport->e_d_tov = 2 * 1000;
1023         lport->r_a_tov = 10 * 1000;
1024
1025         lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
1026                                 FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
1027         lport->does_npiv = 1;
1028
1029         memset(&lport->rnid_gen, 0, sizeof(struct fc_els_rnid_gen));
1030         lport->rnid_gen.rnid_atype = BNX2FC_RNID_HBA;
1031
1032         /* alloc stats structure */
1033         if (fc_lport_init_stats(lport))
1034                 return -ENOMEM;
1035
1036         /* Finish fc_lport configuration */
1037         fc_lport_config(lport);
1038
1039         return 0;
1040 }
1041
1042 /**
1043  * bnx2fc_fip_recv - handle a received FIP frame.
1044  *
1045  * @skb: the received skb
1046  * @dev: associated &net_device
1047  * @ptype: the &packet_type structure which was used to register this handler.
1048  * @orig_dev: original receive &net_device, in case @ dev is a bond.
1049  *
1050  * Returns: 0 for success
1051  */
1052 static int bnx2fc_fip_recv(struct sk_buff *skb, struct net_device *dev,
1053                            struct packet_type *ptype,
1054                            struct net_device *orig_dev)
1055 {
1056         struct bnx2fc_interface *interface;
1057         struct fcoe_ctlr *ctlr;
1058         interface = container_of(ptype, struct bnx2fc_interface,
1059                                  fip_packet_type);
1060         ctlr = bnx2fc_to_ctlr(interface);
1061         fcoe_ctlr_recv(ctlr, skb);
1062         return 0;
1063 }
1064
1065 /**
1066  * bnx2fc_update_src_mac - Update Ethernet MAC filters.
1067  *
1068  * @lport: The local port
1069  * @addr: Location of data to copy
1070  *
1071  * Remove any previously-set unicast MAC filter.
1072  * Add secondary FCoE MAC address filter for our OUI.
1073  */
1074 static void bnx2fc_update_src_mac(struct fc_lport *lport, u8 *addr)
1075 {
1076         struct fcoe_port *port = lport_priv(lport);
1077
1078         memcpy(port->data_src_addr, addr, ETH_ALEN);
1079 }
1080
1081 /**
1082  * bnx2fc_get_src_mac - return the ethernet source address for an lport
1083  *
1084  * @lport: libfc port
1085  */
1086 static u8 *bnx2fc_get_src_mac(struct fc_lport *lport)
1087 {
1088         struct fcoe_port *port;
1089
1090         port = (struct fcoe_port *)lport_priv(lport);
1091         return port->data_src_addr;
1092 }
1093
1094 /**
1095  * bnx2fc_fip_send - send an Ethernet-encapsulated FIP frame.
1096  *
1097  * @fip: FCoE controller.
1098  * @skb: FIP Packet.
1099  */
1100 static void bnx2fc_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
1101 {
1102         struct fip_header *fiph;
1103         struct ethhdr *eth_hdr;
1104         u16 op;
1105         u8 sub;
1106
1107         fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2);
1108         eth_hdr = (struct ethhdr *)skb_mac_header(skb);
1109         op = ntohs(fiph->fip_op);
1110         sub = fiph->fip_subcode;
1111
1112         if (op == FIP_OP_CTRL && sub == FIP_SC_SOL && bnx2fc_log_fka)
1113                 BNX2FC_MISC_DBG("Sending FKA from %pM to %pM.\n",
1114                     eth_hdr->h_source, eth_hdr->h_dest);
1115
1116         skb->dev = bnx2fc_from_ctlr(fip)->netdev;
1117         dev_queue_xmit(skb);
1118 }
1119
1120 static int bnx2fc_vport_create(struct fc_vport *vport, bool disabled)
1121 {
1122         struct Scsi_Host *shost = vport_to_shost(vport);
1123         struct fc_lport *n_port = shost_priv(shost);
1124         struct fcoe_port *port = lport_priv(n_port);
1125         struct bnx2fc_interface *interface = port->priv;
1126         struct net_device *netdev = interface->netdev;
1127         struct fc_lport *vn_port;
1128         int rc;
1129         char buf[32];
1130
1131         rc = fcoe_validate_vport_create(vport);
1132         if (rc) {
1133                 fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
1134                 printk(KERN_ERR PFX "Failed to create vport, "
1135                        "WWPN (0x%s) already exists\n",
1136                        buf);
1137                 return rc;
1138         }
1139
1140         if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags)) {
1141                 printk(KERN_ERR PFX "vn ports cannot be created on"
1142                         "this interface\n");
1143                 return -EIO;
1144         }
1145         rtnl_lock();
1146         mutex_lock(&bnx2fc_dev_lock);
1147         vn_port = bnx2fc_if_create(interface, &vport->dev, 1);
1148         mutex_unlock(&bnx2fc_dev_lock);
1149         rtnl_unlock();
1150
1151         if (!vn_port) {
1152                 printk(KERN_ERR PFX "bnx2fc_vport_create (%s) failed\n",
1153                         netdev->name);
1154                 return -EIO;
1155         }
1156
1157         if (bnx2fc_devloss_tmo)
1158                 fc_host_dev_loss_tmo(vn_port->host) = bnx2fc_devloss_tmo;
1159
1160         if (disabled) {
1161                 fc_vport_set_state(vport, FC_VPORT_DISABLED);
1162         } else {
1163                 vn_port->boot_time = jiffies;
1164                 fc_lport_init(vn_port);
1165                 fc_fabric_login(vn_port);
1166                 fc_vport_setlink(vn_port);
1167         }
1168         return 0;
1169 }
1170
1171 static void bnx2fc_free_vport(struct bnx2fc_hba *hba, struct fc_lport *lport)
1172 {
1173         struct bnx2fc_lport *blport, *tmp;
1174
1175         spin_lock_bh(&hba->hba_lock);
1176         list_for_each_entry_safe(blport, tmp, &hba->vports, list) {
1177                 if (blport->lport == lport) {
1178                         list_del(&blport->list);
1179                         kfree(blport);
1180                 }
1181         }
1182         spin_unlock_bh(&hba->hba_lock);
1183 }
1184
1185 static int bnx2fc_vport_destroy(struct fc_vport *vport)
1186 {
1187         struct Scsi_Host *shost = vport_to_shost(vport);
1188         struct fc_lport *n_port = shost_priv(shost);
1189         struct fc_lport *vn_port = vport->dd_data;
1190         struct fcoe_port *port = lport_priv(vn_port);
1191         struct bnx2fc_interface *interface = port->priv;
1192         struct fc_lport *v_port;
1193         bool found = false;
1194
1195         mutex_lock(&n_port->lp_mutex);
1196         list_for_each_entry(v_port, &n_port->vports, list)
1197                 if (v_port->vport == vport) {
1198                         found = true;
1199                         break;
1200                 }
1201
1202         if (!found) {
1203                 mutex_unlock(&n_port->lp_mutex);
1204                 return -ENOENT;
1205         }
1206         list_del(&vn_port->list);
1207         mutex_unlock(&n_port->lp_mutex);
1208         bnx2fc_free_vport(interface->hba, port->lport);
1209         bnx2fc_port_shutdown(port->lport);
1210         bnx2fc_port_destroy(port);
1211         bnx2fc_interface_put(interface);
1212         return 0;
1213 }
1214
1215 static int bnx2fc_vport_disable(struct fc_vport *vport, bool disable)
1216 {
1217         struct fc_lport *lport = vport->dd_data;
1218
1219         if (disable) {
1220                 fc_vport_set_state(vport, FC_VPORT_DISABLED);
1221                 fc_fabric_logoff(lport);
1222         } else {
1223                 lport->boot_time = jiffies;
1224                 fc_fabric_login(lport);
1225                 fc_vport_setlink(lport);
1226         }
1227         return 0;
1228 }
1229
1230
1231 static int bnx2fc_interface_setup(struct bnx2fc_interface *interface)
1232 {
1233         struct net_device *netdev = interface->netdev;
1234         struct net_device *physdev = interface->hba->phys_dev;
1235         struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
1236         struct netdev_hw_addr *ha;
1237         int sel_san_mac = 0;
1238
1239         /* setup Source MAC Address */
1240         rcu_read_lock();
1241         for_each_dev_addr(physdev, ha) {
1242                 BNX2FC_MISC_DBG("net_config: ha->type = %d, fip_mac = ",
1243                                 ha->type);
1244                 printk(KERN_INFO "%2x:%2x:%2x:%2x:%2x:%2x\n", ha->addr[0],
1245                                 ha->addr[1], ha->addr[2], ha->addr[3],
1246                                 ha->addr[4], ha->addr[5]);
1247
1248                 if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
1249                     (is_valid_ether_addr(ha->addr))) {
1250                         memcpy(ctlr->ctl_src_addr, ha->addr,
1251                                ETH_ALEN);
1252                         sel_san_mac = 1;
1253                         BNX2FC_MISC_DBG("Found SAN MAC\n");
1254                 }
1255         }
1256         rcu_read_unlock();
1257
1258         if (!sel_san_mac)
1259                 return -ENODEV;
1260
1261         interface->fip_packet_type.func = bnx2fc_fip_recv;
1262         interface->fip_packet_type.type = htons(ETH_P_FIP);
1263         interface->fip_packet_type.dev = netdev;
1264         dev_add_pack(&interface->fip_packet_type);
1265
1266         interface->fcoe_packet_type.func = bnx2fc_rcv;
1267         interface->fcoe_packet_type.type = __constant_htons(ETH_P_FCOE);
1268         interface->fcoe_packet_type.dev = netdev;
1269         dev_add_pack(&interface->fcoe_packet_type);
1270
1271         return 0;
1272 }
1273
1274 static int bnx2fc_attach_transport(void)
1275 {
1276         bnx2fc_transport_template =
1277                 fc_attach_transport(&bnx2fc_transport_function);
1278
1279         if (bnx2fc_transport_template == NULL) {
1280                 printk(KERN_ERR PFX "Failed to attach FC transport\n");
1281                 return -ENODEV;
1282         }
1283
1284         bnx2fc_vport_xport_template =
1285                 fc_attach_transport(&bnx2fc_vport_xport_function);
1286         if (bnx2fc_vport_xport_template == NULL) {
1287                 printk(KERN_ERR PFX
1288                        "Failed to attach FC transport for vport\n");
1289                 fc_release_transport(bnx2fc_transport_template);
1290                 bnx2fc_transport_template = NULL;
1291                 return -ENODEV;
1292         }
1293         return 0;
1294 }
1295 static void bnx2fc_release_transport(void)
1296 {
1297         fc_release_transport(bnx2fc_transport_template);
1298         fc_release_transport(bnx2fc_vport_xport_template);
1299         bnx2fc_transport_template = NULL;
1300         bnx2fc_vport_xport_template = NULL;
1301 }
1302
1303 static void bnx2fc_interface_release(struct kref *kref)
1304 {
1305         struct fcoe_ctlr_device *ctlr_dev;
1306         struct bnx2fc_interface *interface;
1307         struct fcoe_ctlr *ctlr;
1308         struct net_device *netdev;
1309
1310         interface = container_of(kref, struct bnx2fc_interface, kref);
1311         BNX2FC_MISC_DBG("Interface is being released\n");
1312
1313         ctlr = bnx2fc_to_ctlr(interface);
1314         ctlr_dev = fcoe_ctlr_to_ctlr_dev(ctlr);
1315         netdev = interface->netdev;
1316
1317         /* tear-down FIP controller */
1318         if (test_and_clear_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags))
1319                 fcoe_ctlr_destroy(ctlr);
1320
1321         fcoe_ctlr_device_delete(ctlr_dev);
1322
1323         dev_put(netdev);
1324         module_put(THIS_MODULE);
1325 }
1326
1327 static inline void bnx2fc_interface_get(struct bnx2fc_interface *interface)
1328 {
1329         kref_get(&interface->kref);
1330 }
1331
1332 static inline void bnx2fc_interface_put(struct bnx2fc_interface *interface)
1333 {
1334         kref_put(&interface->kref, bnx2fc_interface_release);
1335 }
1336 static void bnx2fc_hba_destroy(struct bnx2fc_hba *hba)
1337 {
1338         /* Free the command manager */
1339         if (hba->cmd_mgr) {
1340                 bnx2fc_cmd_mgr_free(hba->cmd_mgr);
1341                 hba->cmd_mgr = NULL;
1342         }
1343         kfree(hba->tgt_ofld_list);
1344         bnx2fc_unbind_pcidev(hba);
1345         kfree(hba);
1346 }
1347
1348 /**
1349  * bnx2fc_hba_create - create a new bnx2fc hba
1350  *
1351  * @cnic:       pointer to cnic device
1352  *
1353  * Creates a new FCoE hba on the given device.
1354  *
1355  */
1356 static struct bnx2fc_hba *bnx2fc_hba_create(struct cnic_dev *cnic)
1357 {
1358         struct bnx2fc_hba *hba;
1359         struct fcoe_capabilities *fcoe_cap;
1360         int rc;
1361
1362         hba = kzalloc(sizeof(*hba), GFP_KERNEL);
1363         if (!hba) {
1364                 printk(KERN_ERR PFX "Unable to allocate hba structure\n");
1365                 return NULL;
1366         }
1367         spin_lock_init(&hba->hba_lock);
1368         mutex_init(&hba->hba_mutex);
1369         mutex_init(&hba->hba_stats_mutex);
1370
1371         hba->cnic = cnic;
1372
1373         hba->max_tasks = cnic->max_fcoe_exchanges;
1374         hba->elstm_xids = (hba->max_tasks / 2);
1375         hba->max_outstanding_cmds = hba->elstm_xids;
1376         hba->max_xid = (hba->max_tasks - 1);
1377
1378         rc = bnx2fc_bind_pcidev(hba);
1379         if (rc) {
1380                 printk(KERN_ERR PFX "create_adapter:  bind error\n");
1381                 goto bind_err;
1382         }
1383         hba->phys_dev = cnic->netdev;
1384         hba->next_conn_id = 0;
1385
1386         hba->tgt_ofld_list =
1387                 kcalloc(BNX2FC_NUM_MAX_SESS, sizeof(struct bnx2fc_rport *),
1388                         GFP_KERNEL);
1389         if (!hba->tgt_ofld_list) {
1390                 printk(KERN_ERR PFX "Unable to allocate tgt offload list\n");
1391                 goto tgtofld_err;
1392         }
1393
1394         hba->num_ofld_sess = 0;
1395
1396         hba->cmd_mgr = bnx2fc_cmd_mgr_alloc(hba);
1397         if (!hba->cmd_mgr) {
1398                 printk(KERN_ERR PFX "em_config:bnx2fc_cmd_mgr_alloc failed\n");
1399                 goto cmgr_err;
1400         }
1401         fcoe_cap = &hba->fcoe_cap;
1402
1403         fcoe_cap->capability1 = BNX2FC_TM_MAX_SQES <<
1404                                         FCOE_IOS_PER_CONNECTION_SHIFT;
1405         fcoe_cap->capability1 |= BNX2FC_NUM_MAX_SESS <<
1406                                         FCOE_LOGINS_PER_PORT_SHIFT;
1407         fcoe_cap->capability2 = hba->max_outstanding_cmds <<
1408                                         FCOE_NUMBER_OF_EXCHANGES_SHIFT;
1409         fcoe_cap->capability2 |= BNX2FC_MAX_NPIV <<
1410                                         FCOE_NPIV_WWN_PER_PORT_SHIFT;
1411         fcoe_cap->capability3 = BNX2FC_NUM_MAX_SESS <<
1412                                         FCOE_TARGETS_SUPPORTED_SHIFT;
1413         fcoe_cap->capability3 |= hba->max_outstanding_cmds <<
1414                                         FCOE_OUTSTANDING_COMMANDS_SHIFT;
1415         fcoe_cap->capability4 = FCOE_CAPABILITY4_STATEFUL;
1416
1417         init_waitqueue_head(&hba->shutdown_wait);
1418         init_waitqueue_head(&hba->destroy_wait);
1419         INIT_LIST_HEAD(&hba->vports);
1420
1421         return hba;
1422
1423 cmgr_err:
1424         kfree(hba->tgt_ofld_list);
1425 tgtofld_err:
1426         bnx2fc_unbind_pcidev(hba);
1427 bind_err:
1428         kfree(hba);
1429         return NULL;
1430 }
1431
1432 static struct bnx2fc_interface *
1433 bnx2fc_interface_create(struct bnx2fc_hba *hba,
1434                         struct net_device *netdev,
1435                         enum fip_mode fip_mode)
1436 {
1437         struct fcoe_ctlr_device *ctlr_dev;
1438         struct bnx2fc_interface *interface;
1439         struct fcoe_ctlr *ctlr;
1440         int size;
1441         int rc = 0;
1442
1443         size = (sizeof(*interface) + sizeof(struct fcoe_ctlr));
1444         ctlr_dev = fcoe_ctlr_device_add(&netdev->dev, &bnx2fc_fcoe_sysfs_templ,
1445                                          size);
1446         if (!ctlr_dev) {
1447                 printk(KERN_ERR PFX "Unable to allocate interface structure\n");
1448                 return NULL;
1449         }
1450         ctlr = fcoe_ctlr_device_priv(ctlr_dev);
1451         ctlr->cdev = ctlr_dev;
1452         interface = fcoe_ctlr_priv(ctlr);
1453         dev_hold(netdev);
1454         kref_init(&interface->kref);
1455         interface->hba = hba;
1456         interface->netdev = netdev;
1457
1458         /* Initialize FIP */
1459         fcoe_ctlr_init(ctlr, fip_mode);
1460         ctlr->send = bnx2fc_fip_send;
1461         ctlr->update_mac = bnx2fc_update_src_mac;
1462         ctlr->get_src_addr = bnx2fc_get_src_mac;
1463         set_bit(BNX2FC_CTLR_INIT_DONE, &interface->if_flags);
1464
1465         rc = bnx2fc_interface_setup(interface);
1466         if (!rc)
1467                 return interface;
1468
1469         fcoe_ctlr_destroy(ctlr);
1470         dev_put(netdev);
1471         fcoe_ctlr_device_delete(ctlr_dev);
1472         return NULL;
1473 }
1474
1475 /**
1476  * bnx2fc_if_create - Create FCoE instance on a given interface
1477  *
1478  * @interface:  FCoE interface to create a local port on
1479  * @parent:     Device pointer to be the parent in sysfs for the SCSI host
1480  * @npiv:       Indicates if the port is vport or not
1481  *
1482  * Creates a fc_lport instance and a Scsi_Host instance and configure them.
1483  *
1484  * Returns:     Allocated fc_lport or an error pointer
1485  */
1486 static struct fc_lport *bnx2fc_if_create(struct bnx2fc_interface *interface,
1487                                   struct device *parent, int npiv)
1488 {
1489         struct fcoe_ctlr        *ctlr = bnx2fc_to_ctlr(interface);
1490         struct fc_lport         *lport, *n_port;
1491         struct fcoe_port        *port;
1492         struct Scsi_Host        *shost;
1493         struct fc_vport         *vport = dev_to_vport(parent);
1494         struct bnx2fc_lport     *blport;
1495         struct bnx2fc_hba       *hba = interface->hba;
1496         int                     rc = 0;
1497
1498         blport = kzalloc(sizeof(struct bnx2fc_lport), GFP_KERNEL);
1499         if (!blport) {
1500                 BNX2FC_HBA_DBG(ctlr->lp, "Unable to alloc blport\n");
1501                 return NULL;
1502         }
1503
1504         /* Allocate Scsi_Host structure */
1505         bnx2fc_shost_template.can_queue = hba->max_outstanding_cmds;
1506         if (!npiv)
1507                 lport = libfc_host_alloc(&bnx2fc_shost_template, sizeof(*port));
1508         else
1509                 lport = libfc_vport_create(vport, sizeof(*port));
1510
1511         if (!lport) {
1512                 printk(KERN_ERR PFX "could not allocate scsi host structure\n");
1513                 goto free_blport;
1514         }
1515         shost = lport->host;
1516         port = lport_priv(lport);
1517         port->lport = lport;
1518         port->priv = interface;
1519         port->get_netdev = bnx2fc_netdev;
1520
1521         /* Configure fcoe_port */
1522         rc = bnx2fc_lport_config(lport);
1523         if (rc)
1524                 goto lp_config_err;
1525
1526         if (npiv) {
1527                 printk(KERN_ERR PFX "Setting vport names, 0x%llX 0x%llX\n",
1528                         vport->node_name, vport->port_name);
1529                 fc_set_wwnn(lport, vport->node_name);
1530                 fc_set_wwpn(lport, vport->port_name);
1531         }
1532         /* Configure netdev and networking properties of the lport */
1533         rc = bnx2fc_net_config(lport, interface->netdev);
1534         if (rc) {
1535                 printk(KERN_ERR PFX "Error on bnx2fc_net_config\n");
1536                 goto lp_config_err;
1537         }
1538
1539         rc = bnx2fc_shost_config(lport, parent);
1540         if (rc) {
1541                 printk(KERN_ERR PFX "Couldn't configure shost for %s\n",
1542                         interface->netdev->name);
1543                 goto lp_config_err;
1544         }
1545
1546         /* Initialize the libfc library */
1547         rc = bnx2fc_libfc_config(lport);
1548         if (rc) {
1549                 printk(KERN_ERR PFX "Couldn't configure libfc\n");
1550                 goto shost_err;
1551         }
1552         fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
1553
1554         if (bnx2fc_devloss_tmo)
1555                 fc_host_dev_loss_tmo(shost) = bnx2fc_devloss_tmo;
1556
1557         /* Allocate exchange manager */
1558         if (!npiv)
1559                 rc = bnx2fc_em_config(lport, hba);
1560         else {
1561                 shost = vport_to_shost(vport);
1562                 n_port = shost_priv(shost);
1563                 rc = fc_exch_mgr_list_clone(n_port, lport);
1564         }
1565
1566         if (rc) {
1567                 printk(KERN_ERR PFX "Error on bnx2fc_em_config\n");
1568                 goto shost_err;
1569         }
1570
1571         bnx2fc_interface_get(interface);
1572
1573         spin_lock_bh(&hba->hba_lock);
1574         blport->lport = lport;
1575         list_add_tail(&blport->list, &hba->vports);
1576         spin_unlock_bh(&hba->hba_lock);
1577
1578         return lport;
1579
1580 shost_err:
1581         scsi_remove_host(shost);
1582 lp_config_err:
1583         scsi_host_put(lport->host);
1584 free_blport:
1585         kfree(blport);
1586         return NULL;
1587 }
1588
1589 static void bnx2fc_net_cleanup(struct bnx2fc_interface *interface)
1590 {
1591         /* Dont listen for Ethernet packets anymore */
1592         __dev_remove_pack(&interface->fcoe_packet_type);
1593         __dev_remove_pack(&interface->fip_packet_type);
1594         synchronize_net();
1595 }
1596
1597 static void bnx2fc_interface_cleanup(struct bnx2fc_interface *interface)
1598 {
1599         struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
1600         struct fc_lport *lport = ctlr->lp;
1601         struct fcoe_port *port = lport_priv(lport);
1602         struct bnx2fc_hba *hba = interface->hba;
1603
1604         /* Stop the transmit retry timer */
1605         del_timer_sync(&port->timer);
1606
1607         /* Free existing transmit skbs */
1608         fcoe_clean_pending_queue(lport);
1609
1610         bnx2fc_net_cleanup(interface);
1611
1612         bnx2fc_free_vport(hba, lport);
1613 }
1614
1615 static void bnx2fc_if_destroy(struct fc_lport *lport)
1616 {
1617
1618         /* Free queued packets for the receive thread */
1619         bnx2fc_clean_rx_queue(lport);
1620
1621         /* Detach from scsi-ml */
1622         fc_remove_host(lport->host);
1623         scsi_remove_host(lport->host);
1624
1625         /*
1626          * Note that only the physical lport will have the exchange manager.
1627          * for vports, this function is NOP
1628          */
1629         fc_exch_mgr_free(lport);
1630
1631         /* Free memory used by statistical counters */
1632         fc_lport_free_stats(lport);
1633
1634         /* Release Scsi_Host */
1635         scsi_host_put(lport->host);
1636 }
1637
1638 static void __bnx2fc_destroy(struct bnx2fc_interface *interface)
1639 {
1640         struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
1641         struct fc_lport *lport = ctlr->lp;
1642         struct fcoe_port *port = lport_priv(lport);
1643
1644         bnx2fc_interface_cleanup(interface);
1645         bnx2fc_stop(interface);
1646         list_del(&interface->list);
1647         bnx2fc_port_destroy(port);
1648         bnx2fc_interface_put(interface);
1649 }
1650
1651 /**
1652  * bnx2fc_destroy - Destroy a bnx2fc FCoE interface
1653  *
1654  * @netdev: The net device that the FCoE interface is on
1655  *
1656  * Called from sysfs.
1657  *
1658  * Returns: 0 for success
1659  */
1660 static int bnx2fc_destroy(struct net_device *netdev)
1661 {
1662         struct bnx2fc_interface *interface = NULL;
1663         struct workqueue_struct *timer_work_queue;
1664         struct fcoe_ctlr *ctlr;
1665         int rc = 0;
1666
1667         rtnl_lock();
1668         mutex_lock(&bnx2fc_dev_lock);
1669
1670         interface = bnx2fc_interface_lookup(netdev);
1671         ctlr = bnx2fc_to_ctlr(interface);
1672         if (!interface || !ctlr->lp) {
1673                 rc = -ENODEV;
1674                 printk(KERN_ERR PFX "bnx2fc_destroy: interface or lport not found\n");
1675                 goto netdev_err;
1676         }
1677
1678         timer_work_queue = interface->timer_work_queue;
1679         __bnx2fc_destroy(interface);
1680         destroy_workqueue(timer_work_queue);
1681
1682 netdev_err:
1683         mutex_unlock(&bnx2fc_dev_lock);
1684         rtnl_unlock();
1685         return rc;
1686 }
1687
1688 static void bnx2fc_port_destroy(struct fcoe_port *port)
1689 {
1690         struct fc_lport *lport;
1691
1692         lport = port->lport;
1693         BNX2FC_HBA_DBG(lport, "Entered %s, destroying lport %p\n", __func__, lport);
1694
1695         bnx2fc_if_destroy(lport);
1696 }
1697
1698 static void bnx2fc_unbind_adapter_devices(struct bnx2fc_hba *hba)
1699 {
1700         bnx2fc_free_fw_resc(hba);
1701         bnx2fc_free_task_ctx(hba);
1702 }
1703
1704 /**
1705  * bnx2fc_bind_adapter_devices - binds bnx2fc adapter with the associated
1706  *                      pci structure
1707  *
1708  * @hba:                Adapter instance
1709  */
1710 static int bnx2fc_bind_adapter_devices(struct bnx2fc_hba *hba)
1711 {
1712         if (bnx2fc_setup_task_ctx(hba))
1713                 goto mem_err;
1714
1715         if (bnx2fc_setup_fw_resc(hba))
1716                 goto mem_err;
1717
1718         return 0;
1719 mem_err:
1720         bnx2fc_unbind_adapter_devices(hba);
1721         return -ENOMEM;
1722 }
1723
1724 static int bnx2fc_bind_pcidev(struct bnx2fc_hba *hba)
1725 {
1726         struct cnic_dev *cnic;
1727         struct pci_dev *pdev;
1728
1729         if (!hba->cnic) {
1730                 printk(KERN_ERR PFX "cnic is NULL\n");
1731                 return -ENODEV;
1732         }
1733         cnic = hba->cnic;
1734         pdev = hba->pcidev = cnic->pcidev;
1735         if (!hba->pcidev)
1736                 return -ENODEV;
1737
1738         switch (pdev->device) {
1739         case PCI_DEVICE_ID_NX2_57710:
1740                 strncpy(hba->chip_num, "BCM57710", BCM_CHIP_LEN);
1741                 break;
1742         case PCI_DEVICE_ID_NX2_57711:
1743                 strncpy(hba->chip_num, "BCM57711", BCM_CHIP_LEN);
1744                 break;
1745         case PCI_DEVICE_ID_NX2_57712:
1746         case PCI_DEVICE_ID_NX2_57712_MF:
1747         case PCI_DEVICE_ID_NX2_57712_VF:
1748                 strncpy(hba->chip_num, "BCM57712", BCM_CHIP_LEN);
1749                 break;
1750         case PCI_DEVICE_ID_NX2_57800:
1751         case PCI_DEVICE_ID_NX2_57800_MF:
1752         case PCI_DEVICE_ID_NX2_57800_VF:
1753                 strncpy(hba->chip_num, "BCM57800", BCM_CHIP_LEN);
1754                 break;
1755         case PCI_DEVICE_ID_NX2_57810:
1756         case PCI_DEVICE_ID_NX2_57810_MF:
1757         case PCI_DEVICE_ID_NX2_57810_VF:
1758                 strncpy(hba->chip_num, "BCM57810", BCM_CHIP_LEN);
1759                 break;
1760         case PCI_DEVICE_ID_NX2_57840:
1761         case PCI_DEVICE_ID_NX2_57840_MF:
1762         case PCI_DEVICE_ID_NX2_57840_VF:
1763         case PCI_DEVICE_ID_NX2_57840_2_20:
1764         case PCI_DEVICE_ID_NX2_57840_4_10:
1765                 strncpy(hba->chip_num, "BCM57840", BCM_CHIP_LEN);
1766                 break;
1767         default:
1768                 pr_err(PFX "Unknown device id 0x%x\n", pdev->device);
1769                 break;
1770         }
1771         pci_dev_get(hba->pcidev);
1772         return 0;
1773 }
1774
1775 static void bnx2fc_unbind_pcidev(struct bnx2fc_hba *hba)
1776 {
1777         if (hba->pcidev) {
1778                 hba->chip_num[0] = '\0';
1779                 pci_dev_put(hba->pcidev);
1780         }
1781         hba->pcidev = NULL;
1782 }
1783
1784 /**
1785  * bnx2fc_ulp_get_stats - cnic callback to populate FCoE stats
1786  *
1787  * @handle:    transport handle pointing to adapter structure
1788  */
1789 static int bnx2fc_ulp_get_stats(void *handle)
1790 {
1791         struct bnx2fc_hba *hba = handle;
1792         struct cnic_dev *cnic;
1793         struct fcoe_stats_info *stats_addr;
1794
1795         if (!hba)
1796                 return -EINVAL;
1797
1798         cnic = hba->cnic;
1799         stats_addr = &cnic->stats_addr->fcoe_stat;
1800         if (!stats_addr)
1801                 return -EINVAL;
1802
1803         strncpy(stats_addr->version, BNX2FC_VERSION,
1804                 sizeof(stats_addr->version));
1805         stats_addr->txq_size = BNX2FC_SQ_WQES_MAX;
1806         stats_addr->rxq_size = BNX2FC_CQ_WQES_MAX;
1807
1808         return 0;
1809 }
1810
1811
1812 /**
1813  * bnx2fc_ulp_start - cnic callback to initialize & start adapter instance
1814  *
1815  * @handle:     transport handle pointing to adapter structure
1816  *
1817  * This function maps adapter structure to pcidev structure and initiates
1818  *      firmware handshake to enable/initialize on-chip FCoE components.
1819  *      This bnx2fc - cnic interface api callback is used after following
1820  *      conditions are met -
1821  *      a) underlying network interface is up (marked by event NETDEV_UP
1822  *              from netdev
1823  *      b) bnx2fc adatper structure is registered.
1824  */
1825 static void bnx2fc_ulp_start(void *handle)
1826 {
1827         struct bnx2fc_hba *hba = handle;
1828         struct bnx2fc_interface *interface;
1829         struct fcoe_ctlr *ctlr;
1830         struct fc_lport *lport;
1831
1832         mutex_lock(&bnx2fc_dev_lock);
1833
1834         if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags))
1835                 bnx2fc_fw_init(hba);
1836
1837         BNX2FC_MISC_DBG("bnx2fc started.\n");
1838
1839         list_for_each_entry(interface, &if_list, list) {
1840                 if (interface->hba == hba) {
1841                         ctlr = bnx2fc_to_ctlr(interface);
1842                         lport = ctlr->lp;
1843                         /* Kick off Fabric discovery*/
1844                         printk(KERN_ERR PFX "ulp_init: start discovery\n");
1845                         lport->tt.frame_send = bnx2fc_xmit;
1846                         bnx2fc_start_disc(interface);
1847                 }
1848         }
1849
1850         mutex_unlock(&bnx2fc_dev_lock);
1851 }
1852
1853 static void bnx2fc_port_shutdown(struct fc_lport *lport)
1854 {
1855         BNX2FC_MISC_DBG("Entered %s\n", __func__);
1856         fc_fabric_logoff(lport);
1857         fc_lport_destroy(lport);
1858 }
1859
1860 static void bnx2fc_stop(struct bnx2fc_interface *interface)
1861 {
1862         struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
1863         struct fc_lport *lport;
1864         struct fc_lport *vport;
1865
1866         if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags))
1867                 return;
1868
1869         lport = ctlr->lp;
1870         bnx2fc_port_shutdown(lport);
1871
1872         mutex_lock(&lport->lp_mutex);
1873         list_for_each_entry(vport, &lport->vports, list)
1874                 fc_host_port_type(vport->host) =
1875                                         FC_PORTTYPE_UNKNOWN;
1876         mutex_unlock(&lport->lp_mutex);
1877         fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
1878         fcoe_ctlr_link_down(ctlr);
1879         fcoe_clean_pending_queue(lport);
1880 }
1881
1882 static int bnx2fc_fw_init(struct bnx2fc_hba *hba)
1883 {
1884 #define BNX2FC_INIT_POLL_TIME           (1000 / HZ)
1885         int rc = -1;
1886         int i = HZ;
1887
1888         rc = bnx2fc_bind_adapter_devices(hba);
1889         if (rc) {
1890                 printk(KERN_ALERT PFX
1891                         "bnx2fc_bind_adapter_devices failed - rc = %d\n", rc);
1892                 goto err_out;
1893         }
1894
1895         rc = bnx2fc_send_fw_fcoe_init_msg(hba);
1896         if (rc) {
1897                 printk(KERN_ALERT PFX
1898                         "bnx2fc_send_fw_fcoe_init_msg failed - rc = %d\n", rc);
1899                 goto err_unbind;
1900         }
1901
1902         /*
1903          * Wait until the adapter init message is complete, and adapter
1904          * state is UP.
1905          */
1906         while (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state) && i--)
1907                 msleep(BNX2FC_INIT_POLL_TIME);
1908
1909         if (!test_bit(ADAPTER_STATE_UP, &hba->adapter_state)) {
1910                 printk(KERN_ERR PFX "bnx2fc_start: %s failed to initialize.  "
1911                                 "Ignoring...\n",
1912                                 hba->cnic->netdev->name);
1913                 rc = -1;
1914                 goto err_unbind;
1915         }
1916
1917
1918         set_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags);
1919         return 0;
1920
1921 err_unbind:
1922         bnx2fc_unbind_adapter_devices(hba);
1923 err_out:
1924         return rc;
1925 }
1926
1927 static void bnx2fc_fw_destroy(struct bnx2fc_hba *hba)
1928 {
1929         if (test_and_clear_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags)) {
1930                 if (bnx2fc_send_fw_fcoe_destroy_msg(hba) == 0) {
1931                         timer_setup(&hba->destroy_timer, bnx2fc_destroy_timer,
1932                                     0);
1933                         hba->destroy_timer.expires = BNX2FC_FW_TIMEOUT +
1934                                                                 jiffies;
1935                         add_timer(&hba->destroy_timer);
1936                         wait_event_interruptible(hba->destroy_wait,
1937                                         test_bit(BNX2FC_FLAG_DESTROY_CMPL,
1938                                                  &hba->flags));
1939                         clear_bit(BNX2FC_FLAG_DESTROY_CMPL, &hba->flags);
1940                         /* This should never happen */
1941                         if (signal_pending(current))
1942                                 flush_signals(current);
1943
1944                         del_timer_sync(&hba->destroy_timer);
1945                 }
1946                 bnx2fc_unbind_adapter_devices(hba);
1947         }
1948 }
1949
1950 /**
1951  * bnx2fc_ulp_stop - cnic callback to shutdown adapter instance
1952  *
1953  * @handle:     transport handle pointing to adapter structure
1954  *
1955  * Driver checks if adapter is already in shutdown mode, if not start
1956  *      the shutdown process.
1957  */
1958 static void bnx2fc_ulp_stop(void *handle)
1959 {
1960         struct bnx2fc_hba *hba = handle;
1961         struct bnx2fc_interface *interface;
1962
1963         printk(KERN_ERR "ULP_STOP\n");
1964
1965         mutex_lock(&bnx2fc_dev_lock);
1966         if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &hba->flags))
1967                 goto exit;
1968         list_for_each_entry(interface, &if_list, list) {
1969                 if (interface->hba == hba)
1970                         bnx2fc_stop(interface);
1971         }
1972         BUG_ON(hba->num_ofld_sess != 0);
1973
1974         mutex_lock(&hba->hba_mutex);
1975         clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
1976         clear_bit(ADAPTER_STATE_GOING_DOWN,
1977                   &hba->adapter_state);
1978
1979         clear_bit(ADAPTER_STATE_READY, &hba->adapter_state);
1980         mutex_unlock(&hba->hba_mutex);
1981
1982         bnx2fc_fw_destroy(hba);
1983 exit:
1984         mutex_unlock(&bnx2fc_dev_lock);
1985 }
1986
1987 static void bnx2fc_start_disc(struct bnx2fc_interface *interface)
1988 {
1989         struct fcoe_ctlr *ctlr = bnx2fc_to_ctlr(interface);
1990         struct fc_lport *lport;
1991         int wait_cnt = 0;
1992
1993         BNX2FC_MISC_DBG("Entered %s\n", __func__);
1994         /* Kick off FIP/FLOGI */
1995         if (!test_bit(BNX2FC_FLAG_FW_INIT_DONE, &interface->hba->flags)) {
1996                 printk(KERN_ERR PFX "Init not done yet\n");
1997                 return;
1998         }
1999
2000         lport = ctlr->lp;
2001         BNX2FC_HBA_DBG(lport, "calling fc_fabric_login\n");
2002
2003         if (!bnx2fc_link_ok(lport) && interface->enabled) {
2004                 BNX2FC_HBA_DBG(lport, "ctlr_link_up\n");
2005                 fcoe_ctlr_link_up(ctlr);
2006                 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
2007                 set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
2008         }
2009
2010         /* wait for the FCF to be selected before issuing FLOGI */
2011         while (!ctlr->sel_fcf) {
2012                 msleep(250);
2013                 /* give up after 3 secs */
2014                 if (++wait_cnt > 12)
2015                         break;
2016         }
2017
2018         /* Reset max receive frame size to default */
2019         if (fc_set_mfs(lport, BNX2FC_MFS))
2020                 return;
2021
2022         fc_lport_init(lport);
2023         fc_fabric_login(lport);
2024 }
2025
2026
2027 /**
2028  * bnx2fc_ulp_init - Initialize an adapter instance
2029  *
2030  * @dev :       cnic device handle
2031  * Called from cnic_register_driver() context to initialize all
2032  *      enumerated cnic devices. This routine allocates adapter structure
2033  *      and other device specific resources.
2034  */
2035 static void bnx2fc_ulp_init(struct cnic_dev *dev)
2036 {
2037         struct bnx2fc_hba *hba;
2038         int rc = 0;
2039
2040         BNX2FC_MISC_DBG("Entered %s\n", __func__);
2041         /* bnx2fc works only when bnx2x is loaded */
2042         if (!test_bit(CNIC_F_BNX2X_CLASS, &dev->flags) ||
2043             (dev->max_fcoe_conn == 0)) {
2044                 printk(KERN_ERR PFX "bnx2fc FCoE not supported on %s,"
2045                                     " flags: %lx fcoe_conn: %d\n",
2046                         dev->netdev->name, dev->flags, dev->max_fcoe_conn);
2047                 return;
2048         }
2049
2050         hba = bnx2fc_hba_create(dev);
2051         if (!hba) {
2052                 printk(KERN_ERR PFX "hba initialization failed\n");
2053                 return;
2054         }
2055
2056         pr_info(PFX "FCoE initialized for %s.\n", dev->netdev->name);
2057
2058         /* Add HBA to the adapter list */
2059         mutex_lock(&bnx2fc_dev_lock);
2060         list_add_tail(&hba->list, &adapter_list);
2061         adapter_count++;
2062         mutex_unlock(&bnx2fc_dev_lock);
2063
2064         dev->fcoe_cap = &hba->fcoe_cap;
2065         clear_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic);
2066         rc = dev->register_device(dev, CNIC_ULP_FCOE,
2067                                                 (void *) hba);
2068         if (rc)
2069                 printk(KERN_ERR PFX "register_device failed, rc = %d\n", rc);
2070         else
2071                 set_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic);
2072 }
2073
2074 /* Assumes rtnl_lock and the bnx2fc_dev_lock are already taken */
2075 static int __bnx2fc_disable(struct fcoe_ctlr *ctlr)
2076 {
2077         struct bnx2fc_interface *interface = fcoe_ctlr_priv(ctlr);
2078
2079         if (interface->enabled) {
2080                 if (!ctlr->lp) {
2081                         pr_err(PFX "__bnx2fc_disable: lport not found\n");
2082                         return -ENODEV;
2083                 } else {
2084                         interface->enabled = false;
2085                         fcoe_ctlr_link_down(ctlr);
2086                         fcoe_clean_pending_queue(ctlr->lp);
2087                 }
2088         }
2089         return 0;
2090 }
2091
2092 /*
2093  * Deperecated: Use bnx2fc_enabled()
2094  */
2095 static int bnx2fc_disable(struct net_device *netdev)
2096 {
2097         struct bnx2fc_interface *interface;
2098         struct fcoe_ctlr *ctlr;
2099         int rc = 0;
2100
2101         rtnl_lock();
2102         mutex_lock(&bnx2fc_dev_lock);
2103
2104         interface = bnx2fc_interface_lookup(netdev);
2105         ctlr = bnx2fc_to_ctlr(interface);
2106
2107         if (!interface) {
2108                 rc = -ENODEV;
2109                 pr_err(PFX "bnx2fc_disable: interface not found\n");
2110         } else {
2111                 rc = __bnx2fc_disable(ctlr);
2112         }
2113         mutex_unlock(&bnx2fc_dev_lock);
2114         rtnl_unlock();
2115         return rc;
2116 }
2117
2118 static uint bnx2fc_npiv_create_vports(struct fc_lport *lport,
2119                                       struct cnic_fc_npiv_tbl *npiv_tbl)
2120 {
2121         struct fc_vport_identifiers vpid;
2122         uint i, created = 0;
2123         u64 wwnn = 0;
2124         char wwpn_str[32];
2125         char wwnn_str[32];
2126
2127         if (npiv_tbl->count > MAX_NPIV_ENTRIES) {
2128                 BNX2FC_HBA_DBG(lport, "Exceeded count max of npiv table\n");
2129                 goto done;
2130         }
2131
2132         /* Sanity check the first entry to make sure it's not 0 */
2133         if (wwn_to_u64(npiv_tbl->wwnn[0]) == 0 &&
2134             wwn_to_u64(npiv_tbl->wwpn[0]) == 0) {
2135                 BNX2FC_HBA_DBG(lport, "First NPIV table entries invalid.\n");
2136                 goto done;
2137         }
2138
2139         vpid.roles = FC_PORT_ROLE_FCP_INITIATOR;
2140         vpid.vport_type = FC_PORTTYPE_NPIV;
2141         vpid.disable = false;
2142
2143         for (i = 0; i < npiv_tbl->count; i++) {
2144                 wwnn = wwn_to_u64(npiv_tbl->wwnn[i]);
2145                 if (wwnn == 0) {
2146                         /*
2147                          * If we get a 0 element from for the WWNN then assume
2148                          * the WWNN should be the same as the physical port.
2149                          */
2150                         wwnn = lport->wwnn;
2151                 }
2152                 vpid.node_name = wwnn;
2153                 vpid.port_name = wwn_to_u64(npiv_tbl->wwpn[i]);
2154                 scnprintf(vpid.symbolic_name, sizeof(vpid.symbolic_name),
2155                     "NPIV[%u]:%016llx-%016llx",
2156                     created, vpid.port_name, vpid.node_name);
2157                 fcoe_wwn_to_str(vpid.node_name, wwnn_str, sizeof(wwnn_str));
2158                 fcoe_wwn_to_str(vpid.port_name, wwpn_str, sizeof(wwpn_str));
2159                 BNX2FC_HBA_DBG(lport, "Creating vport %s:%s.\n", wwnn_str,
2160                     wwpn_str);
2161                 if (fc_vport_create(lport->host, 0, &vpid))
2162                         created++;
2163                 else
2164                         BNX2FC_HBA_DBG(lport, "Failed to create vport\n");
2165         }
2166 done:
2167         return created;
2168 }
2169
2170 static int __bnx2fc_enable(struct fcoe_ctlr *ctlr)
2171 {
2172         struct bnx2fc_interface *interface = fcoe_ctlr_priv(ctlr);
2173         struct bnx2fc_hba *hba;
2174         struct cnic_fc_npiv_tbl *npiv_tbl;
2175         struct fc_lport *lport;
2176
2177         if (!interface->enabled) {
2178                 if (!ctlr->lp) {
2179                         pr_err(PFX "__bnx2fc_enable: lport not found\n");
2180                         return -ENODEV;
2181                 } else if (!bnx2fc_link_ok(ctlr->lp)) {
2182                         fcoe_ctlr_link_up(ctlr);
2183                         interface->enabled = true;
2184                 }
2185         }
2186
2187         /* Create static NPIV ports if any are contained in NVRAM */
2188         hba = interface->hba;
2189         lport = ctlr->lp;
2190
2191         if (!hba)
2192                 goto done;
2193
2194         if (!hba->cnic)
2195                 goto done;
2196
2197         if (!lport)
2198                 goto done;
2199
2200         if (!lport->host)
2201                 goto done;
2202
2203         if (!hba->cnic->get_fc_npiv_tbl)
2204                 goto done;
2205
2206         npiv_tbl = kzalloc(sizeof(struct cnic_fc_npiv_tbl), GFP_KERNEL);
2207         if (!npiv_tbl)
2208                 goto done;
2209
2210         if (hba->cnic->get_fc_npiv_tbl(hba->cnic, npiv_tbl))
2211                 goto done_free;
2212
2213         bnx2fc_npiv_create_vports(lport, npiv_tbl);
2214 done_free:
2215         kfree(npiv_tbl);
2216 done:
2217         return 0;
2218 }
2219
2220 /*
2221  * Deprecated: Use bnx2fc_enabled()
2222  */
2223 static int bnx2fc_enable(struct net_device *netdev)
2224 {
2225         struct bnx2fc_interface *interface;
2226         struct fcoe_ctlr *ctlr;
2227         int rc = 0;
2228
2229         rtnl_lock();
2230         mutex_lock(&bnx2fc_dev_lock);
2231
2232         interface = bnx2fc_interface_lookup(netdev);
2233         ctlr = bnx2fc_to_ctlr(interface);
2234         if (!interface) {
2235                 rc = -ENODEV;
2236                 pr_err(PFX "bnx2fc_enable: interface not found\n");
2237         } else {
2238                 rc = __bnx2fc_enable(ctlr);
2239         }
2240
2241         mutex_unlock(&bnx2fc_dev_lock);
2242         rtnl_unlock();
2243         return rc;
2244 }
2245
2246 /**
2247  * bnx2fc_ctlr_enabled() - Enable or disable an FCoE Controller
2248  * @cdev: The FCoE Controller that is being enabled or disabled
2249  *
2250  * fcoe_sysfs will ensure that the state of 'enabled' has
2251  * changed, so no checking is necessary here. This routine simply
2252  * calls fcoe_enable or fcoe_disable, both of which are deprecated.
2253  * When those routines are removed the functionality can be merged
2254  * here.
2255  */
2256 static int bnx2fc_ctlr_enabled(struct fcoe_ctlr_device *cdev)
2257 {
2258         struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(cdev);
2259
2260         switch (cdev->enabled) {
2261         case FCOE_CTLR_ENABLED:
2262                 return __bnx2fc_enable(ctlr);
2263         case FCOE_CTLR_DISABLED:
2264                 return __bnx2fc_disable(ctlr);
2265         case FCOE_CTLR_UNUSED:
2266         default:
2267                 return -ENOTSUPP;
2268         }
2269 }
2270
2271 enum bnx2fc_create_link_state {
2272         BNX2FC_CREATE_LINK_DOWN,
2273         BNX2FC_CREATE_LINK_UP,
2274 };
2275
2276 /**
2277  * _bnx2fc_create() - Create bnx2fc FCoE interface
2278  * @netdev  :   The net_device object the Ethernet interface to create on
2279  * @fip_mode:   The FIP mode for this creation
2280  * @link_state: The ctlr link state on creation
2281  *
2282  * Called from either the libfcoe 'create' module parameter
2283  * via fcoe_create or from fcoe_syfs's ctlr_create file.
2284  *
2285  * libfcoe's 'create' module parameter is deprecated so some
2286  * consolidation of code can be done when that interface is
2287  * removed.
2288  *
2289  * Returns: 0 for success
2290  */
2291 static int _bnx2fc_create(struct net_device *netdev,
2292                           enum fip_mode fip_mode,
2293                           enum bnx2fc_create_link_state link_state)
2294 {
2295         struct fcoe_ctlr_device *cdev;
2296         struct fcoe_ctlr *ctlr;
2297         struct bnx2fc_interface *interface;
2298         struct bnx2fc_hba *hba;
2299         struct net_device *phys_dev = netdev;
2300         struct fc_lport *lport;
2301         struct ethtool_drvinfo drvinfo;
2302         int rc = 0;
2303         int vlan_id = 0;
2304
2305         BNX2FC_MISC_DBG("Entered bnx2fc_create\n");
2306         if (fip_mode != FIP_MODE_FABRIC) {
2307                 printk(KERN_ERR "fip mode not FABRIC\n");
2308                 return -EIO;
2309         }
2310
2311         rtnl_lock();
2312
2313         mutex_lock(&bnx2fc_dev_lock);
2314
2315         if (!try_module_get(THIS_MODULE)) {
2316                 rc = -EINVAL;
2317                 goto mod_err;
2318         }
2319
2320         /* obtain physical netdev */
2321         if (is_vlan_dev(netdev))
2322                 phys_dev = vlan_dev_real_dev(netdev);
2323
2324         /* verify if the physical device is a netxtreme2 device */
2325         if (phys_dev->ethtool_ops && phys_dev->ethtool_ops->get_drvinfo) {
2326                 memset(&drvinfo, 0, sizeof(drvinfo));
2327                 phys_dev->ethtool_ops->get_drvinfo(phys_dev, &drvinfo);
2328                 if (strncmp(drvinfo.driver, "bnx2x", strlen("bnx2x"))) {
2329                         printk(KERN_ERR PFX "Not a netxtreme2 device\n");
2330                         rc = -EINVAL;
2331                         goto netdev_err;
2332                 }
2333         } else {
2334                 printk(KERN_ERR PFX "unable to obtain drv_info\n");
2335                 rc = -EINVAL;
2336                 goto netdev_err;
2337         }
2338
2339         /* obtain interface and initialize rest of the structure */
2340         hba = bnx2fc_hba_lookup(phys_dev);
2341         if (!hba) {
2342                 rc = -ENODEV;
2343                 printk(KERN_ERR PFX "bnx2fc_create: hba not found\n");
2344                 goto netdev_err;
2345         }
2346
2347         if (bnx2fc_interface_lookup(netdev)) {
2348                 rc = -EEXIST;
2349                 goto netdev_err;
2350         }
2351
2352         interface = bnx2fc_interface_create(hba, netdev, fip_mode);
2353         if (!interface) {
2354                 printk(KERN_ERR PFX "bnx2fc_interface_create failed\n");
2355                 rc = -ENOMEM;
2356                 goto netdev_err;
2357         }
2358
2359         if (is_vlan_dev(netdev)) {
2360                 vlan_id = vlan_dev_vlan_id(netdev);
2361                 interface->vlan_enabled = 1;
2362         }
2363
2364         ctlr = bnx2fc_to_ctlr(interface);
2365         cdev = fcoe_ctlr_to_ctlr_dev(ctlr);
2366         interface->vlan_id = vlan_id;
2367         interface->tm_timeout = BNX2FC_TM_TIMEOUT;
2368
2369         interface->timer_work_queue =
2370                         create_singlethread_workqueue("bnx2fc_timer_wq");
2371         if (!interface->timer_work_queue) {
2372                 printk(KERN_ERR PFX "ulp_init could not create timer_wq\n");
2373                 rc = -EINVAL;
2374                 goto ifput_err;
2375         }
2376
2377         lport = bnx2fc_if_create(interface, &cdev->dev, 0);
2378         if (!lport) {
2379                 printk(KERN_ERR PFX "Failed to create interface (%s)\n",
2380                         netdev->name);
2381                 rc = -EINVAL;
2382                 goto if_create_err;
2383         }
2384
2385         /* Add interface to if_list */
2386         list_add_tail(&interface->list, &if_list);
2387
2388         lport->boot_time = jiffies;
2389
2390         /* Make this master N_port */
2391         ctlr->lp = lport;
2392
2393         if (link_state == BNX2FC_CREATE_LINK_UP)
2394                 cdev->enabled = FCOE_CTLR_ENABLED;
2395         else
2396                 cdev->enabled = FCOE_CTLR_DISABLED;
2397
2398         if (link_state == BNX2FC_CREATE_LINK_UP &&
2399             !bnx2fc_link_ok(lport)) {
2400                 fcoe_ctlr_link_up(ctlr);
2401                 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
2402                 set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
2403         }
2404
2405         BNX2FC_HBA_DBG(lport, "create: START DISC\n");
2406         bnx2fc_start_disc(interface);
2407
2408         if (link_state == BNX2FC_CREATE_LINK_UP)
2409                 interface->enabled = true;
2410
2411         /*
2412          * Release from kref_init in bnx2fc_interface_setup, on success
2413          * lport should be holding a reference taken in bnx2fc_if_create
2414          */
2415         bnx2fc_interface_put(interface);
2416         /* put netdev that was held while calling dev_get_by_name */
2417         mutex_unlock(&bnx2fc_dev_lock);
2418         rtnl_unlock();
2419         return 0;
2420
2421 if_create_err:
2422         destroy_workqueue(interface->timer_work_queue);
2423 ifput_err:
2424         bnx2fc_net_cleanup(interface);
2425         bnx2fc_interface_put(interface);
2426         goto mod_err;
2427 netdev_err:
2428         module_put(THIS_MODULE);
2429 mod_err:
2430         mutex_unlock(&bnx2fc_dev_lock);
2431         rtnl_unlock();
2432         return rc;
2433 }
2434
2435 /**
2436  * bnx2fc_create() - Create a bnx2fc interface
2437  * @netdev  : The net_device object the Ethernet interface to create on
2438  * @fip_mode: The FIP mode for this creation
2439  *
2440  * Called from fcoe transport
2441  *
2442  * Returns: 0 for success
2443  */
2444 static int bnx2fc_create(struct net_device *netdev, enum fip_mode fip_mode)
2445 {
2446         return _bnx2fc_create(netdev, fip_mode, BNX2FC_CREATE_LINK_UP);
2447 }
2448
2449 /**
2450  * bnx2fc_ctlr_alloc() - Allocate a bnx2fc interface from fcoe_sysfs
2451  * @netdev: The net_device to be used by the allocated FCoE Controller
2452  *
2453  * This routine is called from fcoe_sysfs. It will start the fcoe_ctlr
2454  * in a link_down state. The allows the user an opportunity to configure
2455  * the FCoE Controller from sysfs before enabling the FCoE Controller.
2456  *
2457  * Creating in with this routine starts the FCoE Controller in Fabric
2458  * mode. The user can change to VN2VN or another mode before enabling.
2459  */
2460 static int bnx2fc_ctlr_alloc(struct net_device *netdev)
2461 {
2462         return _bnx2fc_create(netdev, FIP_MODE_FABRIC,
2463                               BNX2FC_CREATE_LINK_DOWN);
2464 }
2465
2466 /**
2467  * bnx2fc_find_hba_for_cnic - maps cnic instance to bnx2fc hba instance
2468  *
2469  * @cnic:       Pointer to cnic device instance
2470  *
2471  **/
2472 static struct bnx2fc_hba *bnx2fc_find_hba_for_cnic(struct cnic_dev *cnic)
2473 {
2474         struct bnx2fc_hba *hba;
2475
2476         /* Called with bnx2fc_dev_lock held */
2477         list_for_each_entry(hba, &adapter_list, list) {
2478                 if (hba->cnic == cnic)
2479                         return hba;
2480         }
2481         return NULL;
2482 }
2483
2484 static struct bnx2fc_interface *bnx2fc_interface_lookup(struct net_device
2485                                                         *netdev)
2486 {
2487         struct bnx2fc_interface *interface;
2488
2489         /* Called with bnx2fc_dev_lock held */
2490         list_for_each_entry(interface, &if_list, list) {
2491                 if (interface->netdev == netdev)
2492                         return interface;
2493         }
2494         return NULL;
2495 }
2496
2497 static struct bnx2fc_hba *bnx2fc_hba_lookup(struct net_device
2498                                                       *phys_dev)
2499 {
2500         struct bnx2fc_hba *hba;
2501
2502         /* Called with bnx2fc_dev_lock held */
2503         list_for_each_entry(hba, &adapter_list, list) {
2504                 if (hba->phys_dev == phys_dev)
2505                         return hba;
2506         }
2507         printk(KERN_ERR PFX "adapter_lookup: hba NULL\n");
2508         return NULL;
2509 }
2510
2511 /**
2512  * bnx2fc_ulp_exit - shuts down adapter instance and frees all resources
2513  *
2514  * @dev:        cnic device handle
2515  */
2516 static void bnx2fc_ulp_exit(struct cnic_dev *dev)
2517 {
2518         struct bnx2fc_hba *hba;
2519         struct bnx2fc_interface *interface, *tmp;
2520
2521         BNX2FC_MISC_DBG("Entered bnx2fc_ulp_exit\n");
2522
2523         if (!test_bit(CNIC_F_BNX2X_CLASS, &dev->flags)) {
2524                 printk(KERN_ERR PFX "bnx2fc port check: %s, flags: %lx\n",
2525                         dev->netdev->name, dev->flags);
2526                 return;
2527         }
2528
2529         mutex_lock(&bnx2fc_dev_lock);
2530         hba = bnx2fc_find_hba_for_cnic(dev);
2531         if (!hba) {
2532                 printk(KERN_ERR PFX "bnx2fc_ulp_exit: hba not found, dev 0%p\n",
2533                        dev);
2534                 mutex_unlock(&bnx2fc_dev_lock);
2535                 return;
2536         }
2537
2538         list_del_init(&hba->list);
2539         adapter_count--;
2540
2541         list_for_each_entry_safe(interface, tmp, &if_list, list)
2542                 /* destroy not called yet, move to quiesced list */
2543                 if (interface->hba == hba)
2544                         __bnx2fc_destroy(interface);
2545         mutex_unlock(&bnx2fc_dev_lock);
2546
2547         bnx2fc_ulp_stop(hba);
2548         /* unregister cnic device */
2549         if (test_and_clear_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic))
2550                 hba->cnic->unregister_device(hba->cnic, CNIC_ULP_FCOE);
2551         bnx2fc_hba_destroy(hba);
2552 }
2553
2554 static void bnx2fc_rport_terminate_io(struct fc_rport *rport)
2555 {
2556         /* This is a no-op */
2557 }
2558
2559 /**
2560  * bnx2fc_fcoe_reset - Resets the fcoe
2561  *
2562  * @shost: shost the reset is from
2563  *
2564  * Returns: always 0
2565  */
2566 static int bnx2fc_fcoe_reset(struct Scsi_Host *shost)
2567 {
2568         struct fc_lport *lport = shost_priv(shost);
2569         fc_lport_reset(lport);
2570         return 0;
2571 }
2572
2573
2574 static bool bnx2fc_match(struct net_device *netdev)
2575 {
2576         struct net_device *phys_dev = netdev;
2577
2578         mutex_lock(&bnx2fc_dev_lock);
2579         if (is_vlan_dev(netdev))
2580                 phys_dev = vlan_dev_real_dev(netdev);
2581
2582         if (bnx2fc_hba_lookup(phys_dev)) {
2583                 mutex_unlock(&bnx2fc_dev_lock);
2584                 return true;
2585         }
2586
2587         mutex_unlock(&bnx2fc_dev_lock);
2588         return false;
2589 }
2590
2591
2592 static struct fcoe_transport bnx2fc_transport = {
2593         .name = {"bnx2fc"},
2594         .attached = false,
2595         .list = LIST_HEAD_INIT(bnx2fc_transport.list),
2596         .alloc = bnx2fc_ctlr_alloc,
2597         .match = bnx2fc_match,
2598         .create = bnx2fc_create,
2599         .destroy = bnx2fc_destroy,
2600         .enable = bnx2fc_enable,
2601         .disable = bnx2fc_disable,
2602 };
2603
2604 /**
2605  * bnx2fc_cpu_online - Create a receive thread for an  online CPU
2606  *
2607  * @cpu: cpu index for the online cpu
2608  */
2609 static int bnx2fc_cpu_online(unsigned int cpu)
2610 {
2611         struct bnx2fc_percpu_s *p;
2612         struct task_struct *thread;
2613
2614         p = &per_cpu(bnx2fc_percpu, cpu);
2615
2616         thread = kthread_create_on_node(bnx2fc_percpu_io_thread,
2617                                         (void *)p, cpu_to_node(cpu),
2618                                         "bnx2fc_thread/%d", cpu);
2619         if (IS_ERR(thread))
2620                 return PTR_ERR(thread);
2621
2622         /* bind thread to the cpu */
2623         kthread_bind(thread, cpu);
2624         p->iothread = thread;
2625         wake_up_process(thread);
2626         return 0;
2627 }
2628
2629 static int bnx2fc_cpu_offline(unsigned int cpu)
2630 {
2631         struct bnx2fc_percpu_s *p;
2632         struct task_struct *thread;
2633         struct bnx2fc_work *work, *tmp;
2634
2635         BNX2FC_MISC_DBG("destroying io thread for CPU %d\n", cpu);
2636
2637         /* Prevent any new work from being queued for this CPU */
2638         p = &per_cpu(bnx2fc_percpu, cpu);
2639         spin_lock_bh(&p->fp_work_lock);
2640         thread = p->iothread;
2641         p->iothread = NULL;
2642
2643         /* Free all work in the list */
2644         list_for_each_entry_safe(work, tmp, &p->work_list, list) {
2645                 list_del_init(&work->list);
2646                 bnx2fc_process_cq_compl(work->tgt, work->wqe, work->rq_data,
2647                                         work->num_rq, work->task);
2648                 kfree(work);
2649         }
2650
2651         spin_unlock_bh(&p->fp_work_lock);
2652
2653         if (thread)
2654                 kthread_stop(thread);
2655         return 0;
2656 }
2657
2658 static int bnx2fc_slave_configure(struct scsi_device *sdev)
2659 {
2660         if (!bnx2fc_queue_depth)
2661                 return 0;
2662
2663         scsi_change_queue_depth(sdev, bnx2fc_queue_depth);
2664         return 0;
2665 }
2666
2667 static enum cpuhp_state bnx2fc_online_state;
2668
2669 /**
2670  * bnx2fc_mod_init - module init entry point
2671  *
2672  * Initialize driver wide global data structures, and register
2673  * with cnic module
2674  **/
2675 static int __init bnx2fc_mod_init(void)
2676 {
2677         struct fcoe_percpu_s *bg;
2678         struct task_struct *l2_thread;
2679         int rc = 0;
2680         unsigned int cpu = 0;
2681         struct bnx2fc_percpu_s *p;
2682
2683         printk(KERN_INFO PFX "%s", version);
2684
2685         /* register as a fcoe transport */
2686         rc = fcoe_transport_attach(&bnx2fc_transport);
2687         if (rc) {
2688                 printk(KERN_ERR "failed to register an fcoe transport, check "
2689                         "if libfcoe is loaded\n");
2690                 goto out;
2691         }
2692
2693         INIT_LIST_HEAD(&adapter_list);
2694         INIT_LIST_HEAD(&if_list);
2695         mutex_init(&bnx2fc_dev_lock);
2696         adapter_count = 0;
2697
2698         /* Attach FC transport template */
2699         rc = bnx2fc_attach_transport();
2700         if (rc)
2701                 goto detach_ft;
2702
2703         bnx2fc_wq = alloc_workqueue("bnx2fc", 0, 0);
2704         if (!bnx2fc_wq) {
2705                 rc = -ENOMEM;
2706                 goto release_bt;
2707         }
2708
2709         bg = &bnx2fc_global;
2710         skb_queue_head_init(&bg->fcoe_rx_list);
2711         l2_thread = kthread_run(bnx2fc_l2_rcv_thread,
2712                                 (void *)bg,
2713                                 "bnx2fc_l2_thread");
2714         if (IS_ERR(l2_thread)) {
2715                 rc = PTR_ERR(l2_thread);
2716                 goto free_wq;
2717         }
2718         spin_lock_bh(&bg->fcoe_rx_list.lock);
2719         bg->kthread = l2_thread;
2720         spin_unlock_bh(&bg->fcoe_rx_list.lock);
2721
2722         for_each_possible_cpu(cpu) {
2723                 p = &per_cpu(bnx2fc_percpu, cpu);
2724                 INIT_LIST_HEAD(&p->work_list);
2725                 spin_lock_init(&p->fp_work_lock);
2726         }
2727
2728         rc = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "scsi/bnx2fc:online",
2729                                bnx2fc_cpu_online, bnx2fc_cpu_offline);
2730         if (rc < 0)
2731                 goto stop_thread;
2732         bnx2fc_online_state = rc;
2733
2734         cnic_register_driver(CNIC_ULP_FCOE, &bnx2fc_cnic_cb);
2735         return 0;
2736
2737 stop_thread:
2738         kthread_stop(l2_thread);
2739 free_wq:
2740         destroy_workqueue(bnx2fc_wq);
2741 release_bt:
2742         bnx2fc_release_transport();
2743 detach_ft:
2744         fcoe_transport_detach(&bnx2fc_transport);
2745 out:
2746         return rc;
2747 }
2748
2749 static void __exit bnx2fc_mod_exit(void)
2750 {
2751         LIST_HEAD(to_be_deleted);
2752         struct bnx2fc_hba *hba, *next;
2753         struct fcoe_percpu_s *bg;
2754         struct task_struct *l2_thread;
2755         struct sk_buff *skb;
2756
2757         /*
2758          * NOTE: Since cnic calls register_driver routine rtnl_lock,
2759          * it will have higher precedence than bnx2fc_dev_lock.
2760          * unregister_device() cannot be called with bnx2fc_dev_lock
2761          * held.
2762          */
2763         mutex_lock(&bnx2fc_dev_lock);
2764         list_splice_init(&adapter_list, &to_be_deleted);
2765         adapter_count = 0;
2766         mutex_unlock(&bnx2fc_dev_lock);
2767
2768         /* Unregister with cnic */
2769         list_for_each_entry_safe(hba, next, &to_be_deleted, list) {
2770                 list_del_init(&hba->list);
2771                 printk(KERN_ERR PFX "MOD_EXIT:destroy hba = 0x%p\n",
2772                        hba);
2773                 bnx2fc_ulp_stop(hba);
2774                 /* unregister cnic device */
2775                 if (test_and_clear_bit(BNX2FC_CNIC_REGISTERED,
2776                                        &hba->reg_with_cnic))
2777                         hba->cnic->unregister_device(hba->cnic,
2778                                                          CNIC_ULP_FCOE);
2779                 bnx2fc_hba_destroy(hba);
2780         }
2781         cnic_unregister_driver(CNIC_ULP_FCOE);
2782
2783         /* Destroy global thread */
2784         bg = &bnx2fc_global;
2785         spin_lock_bh(&bg->fcoe_rx_list.lock);
2786         l2_thread = bg->kthread;
2787         bg->kthread = NULL;
2788         while ((skb = __skb_dequeue(&bg->fcoe_rx_list)) != NULL)
2789                 kfree_skb(skb);
2790
2791         spin_unlock_bh(&bg->fcoe_rx_list.lock);
2792
2793         if (l2_thread)
2794                 kthread_stop(l2_thread);
2795
2796         cpuhp_remove_state(bnx2fc_online_state);
2797
2798         destroy_workqueue(bnx2fc_wq);
2799         /*
2800          * detach from scsi transport
2801          * must happen after all destroys are done
2802          */
2803         bnx2fc_release_transport();
2804
2805         /* detach from fcoe transport */
2806         fcoe_transport_detach(&bnx2fc_transport);
2807 }
2808
2809 module_init(bnx2fc_mod_init);
2810 module_exit(bnx2fc_mod_exit);
2811
2812 static struct fcoe_sysfs_function_template bnx2fc_fcoe_sysfs_templ = {
2813         .set_fcoe_ctlr_enabled = bnx2fc_ctlr_enabled,
2814         .get_fcoe_ctlr_link_fail = fcoe_ctlr_get_lesb,
2815         .get_fcoe_ctlr_vlink_fail = fcoe_ctlr_get_lesb,
2816         .get_fcoe_ctlr_miss_fka = fcoe_ctlr_get_lesb,
2817         .get_fcoe_ctlr_symb_err = fcoe_ctlr_get_lesb,
2818         .get_fcoe_ctlr_err_block = fcoe_ctlr_get_lesb,
2819         .get_fcoe_ctlr_fcs_error = fcoe_ctlr_get_lesb,
2820
2821         .get_fcoe_fcf_selected = fcoe_fcf_get_selected,
2822         .get_fcoe_fcf_vlan_id = bnx2fc_fcf_get_vlan_id,
2823 };
2824
2825 static struct fc_function_template bnx2fc_transport_function = {
2826         .show_host_node_name = 1,
2827         .show_host_port_name = 1,
2828         .show_host_supported_classes = 1,
2829         .show_host_supported_fc4s = 1,
2830         .show_host_active_fc4s = 1,
2831         .show_host_maxframe_size = 1,
2832
2833         .show_host_port_id = 1,
2834         .show_host_supported_speeds = 1,
2835         .get_host_speed = fc_get_host_speed,
2836         .show_host_speed = 1,
2837         .show_host_port_type = 1,
2838         .get_host_port_state = fc_get_host_port_state,
2839         .show_host_port_state = 1,
2840         .show_host_symbolic_name = 1,
2841
2842         .dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
2843                                 sizeof(struct bnx2fc_rport)),
2844         .show_rport_maxframe_size = 1,
2845         .show_rport_supported_classes = 1,
2846
2847         .show_host_fabric_name = 1,
2848         .show_starget_node_name = 1,
2849         .show_starget_port_name = 1,
2850         .show_starget_port_id = 1,
2851         .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
2852         .show_rport_dev_loss_tmo = 1,
2853         .get_fc_host_stats = bnx2fc_get_host_stats,
2854
2855         .issue_fc_host_lip = bnx2fc_fcoe_reset,
2856
2857         .terminate_rport_io = bnx2fc_rport_terminate_io,
2858
2859         .vport_create = bnx2fc_vport_create,
2860         .vport_delete = bnx2fc_vport_destroy,
2861         .vport_disable = bnx2fc_vport_disable,
2862         .bsg_request = fc_lport_bsg_request,
2863 };
2864
2865 static struct fc_function_template bnx2fc_vport_xport_function = {
2866         .show_host_node_name = 1,
2867         .show_host_port_name = 1,
2868         .show_host_supported_classes = 1,
2869         .show_host_supported_fc4s = 1,
2870         .show_host_active_fc4s = 1,
2871         .show_host_maxframe_size = 1,
2872
2873         .show_host_port_id = 1,
2874         .show_host_supported_speeds = 1,
2875         .get_host_speed = fc_get_host_speed,
2876         .show_host_speed = 1,
2877         .show_host_port_type = 1,
2878         .get_host_port_state = fc_get_host_port_state,
2879         .show_host_port_state = 1,
2880         .show_host_symbolic_name = 1,
2881
2882         .dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
2883                                 sizeof(struct bnx2fc_rport)),
2884         .show_rport_maxframe_size = 1,
2885         .show_rport_supported_classes = 1,
2886
2887         .show_host_fabric_name = 1,
2888         .show_starget_node_name = 1,
2889         .show_starget_port_name = 1,
2890         .show_starget_port_id = 1,
2891         .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
2892         .show_rport_dev_loss_tmo = 1,
2893         .get_fc_host_stats = fc_get_host_stats,
2894         .issue_fc_host_lip = bnx2fc_fcoe_reset,
2895         .terminate_rport_io = fc_rport_terminate_io,
2896         .bsg_request = fc_lport_bsg_request,
2897 };
2898
2899 /*
2900  * Additional scsi_host attributes.
2901  */
2902 static ssize_t
2903 bnx2fc_tm_timeout_show(struct device *dev, struct device_attribute *attr,
2904         char *buf)
2905 {
2906         struct Scsi_Host *shost = class_to_shost(dev);
2907         struct fc_lport *lport = shost_priv(shost);
2908         struct fcoe_port *port = lport_priv(lport);
2909         struct bnx2fc_interface *interface = port->priv;
2910
2911         sprintf(buf, "%u\n", interface->tm_timeout);
2912         return strlen(buf);
2913 }
2914
2915 static ssize_t
2916 bnx2fc_tm_timeout_store(struct device *dev,
2917         struct device_attribute *attr, const char *buf, size_t count)
2918 {
2919         struct Scsi_Host *shost = class_to_shost(dev);
2920         struct fc_lport *lport = shost_priv(shost);
2921         struct fcoe_port *port = lport_priv(lport);
2922         struct bnx2fc_interface *interface = port->priv;
2923         int rval, val;
2924
2925         rval = kstrtouint(buf, 10, &val);
2926         if (rval)
2927                 return rval;
2928         if (val > 255)
2929                 return -ERANGE;
2930
2931         interface->tm_timeout = (u8)val;
2932         return strlen(buf);
2933 }
2934
2935 static DEVICE_ATTR(tm_timeout, S_IRUGO|S_IWUSR, bnx2fc_tm_timeout_show,
2936         bnx2fc_tm_timeout_store);
2937
2938 static struct attribute *bnx2fc_host_attrs[] = {
2939         &dev_attr_tm_timeout.attr,
2940         NULL,
2941 };
2942
2943 ATTRIBUTE_GROUPS(bnx2fc_host);
2944
2945 /*
2946  * scsi_host_template structure used while registering with SCSI-ml
2947  */
2948 static struct scsi_host_template bnx2fc_shost_template = {
2949         .module                 = THIS_MODULE,
2950         .name                   = "QLogic Offload FCoE Initiator",
2951         .queuecommand           = bnx2fc_queuecommand,
2952         .eh_timed_out           = fc_eh_timed_out,
2953         .eh_abort_handler       = bnx2fc_eh_abort,        /* abts */
2954         .eh_device_reset_handler = bnx2fc_eh_device_reset, /* lun reset */
2955         .eh_target_reset_handler = bnx2fc_eh_target_reset, /* tgt reset */
2956         .eh_host_reset_handler  = fc_eh_host_reset,
2957         .slave_alloc            = fc_slave_alloc,
2958         .change_queue_depth     = scsi_change_queue_depth,
2959         .this_id                = -1,
2960         .cmd_per_lun            = 3,
2961         .sg_tablesize           = BNX2FC_MAX_BDS_PER_CMD,
2962         .dma_boundary           = 0x7fff,
2963         .max_sectors            = 0x3fbf,
2964         .track_queue_depth      = 1,
2965         .slave_configure        = bnx2fc_slave_configure,
2966         .shost_groups           = bnx2fc_host_groups,
2967         .cmd_size               = sizeof(struct bnx2fc_priv),
2968 };
2969
2970 static struct libfc_function_template bnx2fc_libfc_fcn_templ = {
2971         .frame_send             = bnx2fc_xmit,
2972         .elsct_send             = bnx2fc_elsct_send,
2973         .fcp_abort_io           = bnx2fc_abort_io,
2974         .fcp_cleanup            = bnx2fc_cleanup,
2975         .get_lesb               = fcoe_get_lesb,
2976         .rport_event_callback   = bnx2fc_rport_event_handler,
2977 };
2978
2979 /*
2980  * bnx2fc_cnic_cb - global template of bnx2fc - cnic driver interface
2981  *                      structure carrying callback function pointers
2982  */
2983 static struct cnic_ulp_ops bnx2fc_cnic_cb = {
2984         .owner                  = THIS_MODULE,
2985         .cnic_init              = bnx2fc_ulp_init,
2986         .cnic_exit              = bnx2fc_ulp_exit,
2987         .cnic_start             = bnx2fc_ulp_start,
2988         .cnic_stop              = bnx2fc_ulp_stop,
2989         .indicate_kcqes         = bnx2fc_indicate_kcqe,
2990         .indicate_netevent      = bnx2fc_indicate_netevent,
2991         .cnic_get_stats         = bnx2fc_ulp_get_stats,
2992 };