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