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