1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55#include "mptlan.h"
56#include <linux/init.h>
57#include <linux/module.h>
58#include <linux/fs.h>
59#include <linux/sched.h>
60#include <linux/slab.h>
61
62#define my_VERSION MPT_LINUX_VERSION_COMMON
63#define MYNAM "mptlan"
64
65MODULE_LICENSE("GPL");
66MODULE_VERSION(my_VERSION);
67
68
69
70
71
72#define MPT_LAN_RECEIVE_POST_REQUEST_SIZE \
73 (sizeof(LANReceivePostRequest_t) - sizeof(SGE_MPI_UNION))
74
75#define MPT_LAN_TRANSACTION32_SIZE \
76 (sizeof(SGETransaction32_t) - sizeof(u32))
77
78
79
80
81
82struct BufferControl {
83 struct sk_buff *skb;
84 dma_addr_t dma;
85 unsigned int len;
86};
87
88struct mpt_lan_priv {
89 MPT_ADAPTER *mpt_dev;
90 u8 pnum;
91
92 atomic_t buckets_out;
93 int bucketthresh;
94
95 int *mpt_txfidx;
96 int mpt_txfidx_tail;
97 spinlock_t txfidx_lock;
98
99 int *mpt_rxfidx;
100 int mpt_rxfidx_tail;
101 spinlock_t rxfidx_lock;
102
103 struct BufferControl *RcvCtl;
104 struct BufferControl *SendCtl;
105
106 int max_buckets_out;
107 int tx_max_out;
108
109 u32 total_posted;
110 u32 total_received;
111
112 struct delayed_work post_buckets_task;
113 struct net_device *dev;
114 unsigned long post_buckets_active;
115};
116
117struct mpt_lan_ohdr {
118 u16 dtype;
119 u8 daddr[FC_ALEN];
120 u16 stype;
121 u8 saddr[FC_ALEN];
122};
123
124
125
126
127
128
129static int lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
130 MPT_FRAME_HDR *reply);
131static int mpt_lan_open(struct net_device *dev);
132static int mpt_lan_reset(struct net_device *dev);
133static int mpt_lan_close(struct net_device *dev);
134static void mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv);
135static void mpt_lan_wake_post_buckets_task(struct net_device *dev,
136 int priority);
137static int mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg);
138static int mpt_lan_receive_post_reply(struct net_device *dev,
139 LANReceivePostReply_t *pRecvRep);
140static int mpt_lan_send_turbo(struct net_device *dev, u32 tmsg);
141static int mpt_lan_send_reply(struct net_device *dev,
142 LANSendReply_t *pSendRep);
143static int mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
144static int mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
145static unsigned short mpt_lan_type_trans(struct sk_buff *skb,
146 struct net_device *dev);
147
148
149
150
151
152static u8 LanCtx = MPT_MAX_PROTOCOL_DRIVERS;
153
154static u32 max_buckets_out = 127;
155static u32 tx_max_out_p = 127 - 16;
156
157
158
159
160
161
162
163
164
165
166
167static int
168lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
169{
170 struct net_device *dev = ioc->netdev;
171 int FreeReqFrame = 0;
172
173 dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.\n",
174 IOC_AND_NETDEV_NAMES_s_s(dev)));
175
176
177
178
179 if (mf == NULL) {
180 u32 tmsg = CAST_PTR_TO_U32(reply);
181
182 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
183 IOC_AND_NETDEV_NAMES_s_s(dev),
184 tmsg));
185
186 switch (GET_LAN_FORM(tmsg)) {
187
188
189
190
191#if 0
192 case LAN_REPLY_FORM_MESSAGE_CONTEXT:
193
194
195 FreeReqFrame = 1;
196 break;
197#endif
198
199 case LAN_REPLY_FORM_SEND_SINGLE:
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214 (void) mpt_lan_send_turbo(dev, tmsg);
215 FreeReqFrame = 0;
216
217 break;
218
219 case LAN_REPLY_FORM_RECEIVE_SINGLE:
220
221
222 mpt_lan_receive_post_turbo(dev, tmsg);
223 break;
224
225 default:
226 printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply "
227 "that I don't know what to do with\n");
228
229
230
231 break;
232 }
233
234 return FreeReqFrame;
235 }
236
237
238
239
240
241
242
243
244 switch (reply->u.hdr.Function) {
245
246 case MPI_FUNCTION_LAN_SEND:
247 {
248 LANSendReply_t *pSendRep;
249
250 pSendRep = (LANSendReply_t *) reply;
251 FreeReqFrame = mpt_lan_send_reply(dev, pSendRep);
252 break;
253 }
254
255 case MPI_FUNCTION_LAN_RECEIVE:
256 {
257 LANReceivePostReply_t *pRecvRep;
258
259 pRecvRep = (LANReceivePostReply_t *) reply;
260 if (pRecvRep->NumberOfContexts) {
261 mpt_lan_receive_post_reply(dev, pRecvRep);
262 if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
263 FreeReqFrame = 1;
264 } else
265 dioprintk((KERN_INFO MYNAM "@lan_reply: zero context "
266 "ReceivePostReply received.\n"));
267 break;
268 }
269
270 case MPI_FUNCTION_LAN_RESET:
271
272
273
274 FreeReqFrame = 1;
275 break;
276
277 case MPI_FUNCTION_EVENT_NOTIFICATION:
278 case MPI_FUNCTION_EVENT_ACK:
279
280
281
282 FreeReqFrame = 1;
283 break;
284
285 default:
286 printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo "
287 "reply that I don't know what to do with\n");
288
289
290 FreeReqFrame = 1;
291
292 break;
293 }
294
295 return FreeReqFrame;
296}
297
298
299static int
300mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
301{
302 struct net_device *dev = ioc->netdev;
303 struct mpt_lan_priv *priv;
304
305 if (dev == NULL)
306 return(1);
307 else
308 priv = netdev_priv(dev);
309
310 dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!\n",
311 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
312 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
313
314 if (priv->mpt_rxfidx == NULL)
315 return (1);
316
317 if (reset_phase == MPT_IOC_SETUP_RESET) {
318 ;
319 } else if (reset_phase == MPT_IOC_PRE_RESET) {
320 int i;
321 unsigned long flags;
322
323 netif_stop_queue(dev);
324
325 dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.\n", dev->name));
326
327 atomic_set(&priv->buckets_out, 0);
328
329
330 spin_lock_irqsave(&priv->rxfidx_lock, flags);
331 priv->mpt_rxfidx_tail = -1;
332 for (i = 0; i < priv->max_buckets_out; i++)
333 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
334 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
335 } else {
336 mpt_lan_post_receive_buckets(priv);
337 netif_wake_queue(dev);
338 }
339
340 return 1;
341}
342
343
344static int
345mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
346{
347 dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!\n"));
348
349 switch (le32_to_cpu(pEvReply->Event)) {
350 case MPI_EVENT_NONE:
351 case MPI_EVENT_LOG_DATA:
352 case MPI_EVENT_STATE_CHANGE:
353 case MPI_EVENT_UNIT_ATTENTION:
354 case MPI_EVENT_IOC_BUS_RESET:
355 case MPI_EVENT_EXT_BUS_RESET:
356 case MPI_EVENT_RESCAN:
357
358
359
360 case MPI_EVENT_LINK_STATUS_CHANGE:
361 case MPI_EVENT_LOOP_STATE_CHANGE:
362 case MPI_EVENT_LOGOUT:
363 case MPI_EVENT_EVENT_CHANGE:
364 default:
365 break;
366 }
367
368
369
370
371
372
373 return 1;
374}
375
376
377static int
378mpt_lan_open(struct net_device *dev)
379{
380 struct mpt_lan_priv *priv = netdev_priv(dev);
381 int i;
382
383 if (mpt_lan_reset(dev) != 0) {
384 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
385
386 printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed.");
387
388 if (mpt_dev->active)
389 printk ("The ioc is active. Perhaps it needs to be"
390 " reset?\n");
391 else
392 printk ("The ioc in inactive, most likely in the "
393 "process of being reset. Please try again in "
394 "a moment.\n");
395 }
396
397 priv->mpt_txfidx = kmalloc_array(priv->tx_max_out, sizeof(int),
398 GFP_KERNEL);
399 if (priv->mpt_txfidx == NULL)
400 goto out;
401 priv->mpt_txfidx_tail = -1;
402
403 priv->SendCtl = kcalloc(priv->tx_max_out, sizeof(struct BufferControl),
404 GFP_KERNEL);
405 if (priv->SendCtl == NULL)
406 goto out_mpt_txfidx;
407 for (i = 0; i < priv->tx_max_out; i++)
408 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
409
410 dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
411
412 priv->mpt_rxfidx = kmalloc_array(priv->max_buckets_out, sizeof(int),
413 GFP_KERNEL);
414 if (priv->mpt_rxfidx == NULL)
415 goto out_SendCtl;
416 priv->mpt_rxfidx_tail = -1;
417
418 priv->RcvCtl = kcalloc(priv->max_buckets_out,
419 sizeof(struct BufferControl),
420 GFP_KERNEL);
421 if (priv->RcvCtl == NULL)
422 goto out_mpt_rxfidx;
423 for (i = 0; i < priv->max_buckets_out; i++)
424 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
425
426 dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - "));
427 for (i = 0; i < priv->tx_max_out; i++)
428 dlprintk((" %xh", priv->mpt_txfidx[i]));
429 dlprintk(("\n"));
430
431 dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n"));
432
433 mpt_lan_post_receive_buckets(priv);
434 printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n",
435 IOC_AND_NETDEV_NAMES_s_s(dev));
436
437 if (mpt_event_register(LanCtx, mpt_lan_event_process) != 0) {
438 printk (KERN_WARNING MYNAM "/lo: Unable to register for Event"
439 " Notifications. This is a bad thing! We're not going "
440 "to go ahead, but I'd be leery of system stability at "
441 "this point.\n");
442 }
443
444 netif_start_queue(dev);
445 dlprintk((KERN_INFO MYNAM "/lo: Done.\n"));
446
447 return 0;
448out_mpt_rxfidx:
449 kfree(priv->mpt_rxfidx);
450 priv->mpt_rxfidx = NULL;
451out_SendCtl:
452 kfree(priv->SendCtl);
453 priv->SendCtl = NULL;
454out_mpt_txfidx:
455 kfree(priv->mpt_txfidx);
456 priv->mpt_txfidx = NULL;
457out: return -ENOMEM;
458}
459
460
461
462
463static int
464mpt_lan_reset(struct net_device *dev)
465{
466 MPT_FRAME_HDR *mf;
467 LANResetRequest_t *pResetReq;
468 struct mpt_lan_priv *priv = netdev_priv(dev);
469
470 mf = mpt_get_msg_frame(LanCtx, priv->mpt_dev);
471
472 if (mf == NULL) {
473
474
475
476 return -1;
477 }
478
479 pResetReq = (LANResetRequest_t *) mf;
480
481 pResetReq->Function = MPI_FUNCTION_LAN_RESET;
482 pResetReq->ChainOffset = 0;
483 pResetReq->Reserved = 0;
484 pResetReq->PortNumber = priv->pnum;
485 pResetReq->MsgFlags = 0;
486 pResetReq->Reserved2 = 0;
487
488 mpt_put_msg_frame(LanCtx, priv->mpt_dev, mf);
489
490 return 0;
491}
492
493
494static int
495mpt_lan_close(struct net_device *dev)
496{
497 struct mpt_lan_priv *priv = netdev_priv(dev);
498 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
499 unsigned long timeout;
500 int i;
501
502 dlprintk((KERN_INFO MYNAM ": mpt_lan_close called\n"));
503
504 mpt_event_deregister(LanCtx);
505
506 dlprintk((KERN_INFO MYNAM ":lan_close: Posted %d buckets "
507 "since driver was loaded, %d still out\n",
508 priv->total_posted,atomic_read(&priv->buckets_out)));
509
510 netif_stop_queue(dev);
511
512 mpt_lan_reset(dev);
513
514 timeout = jiffies + 2 * HZ;
515 while (atomic_read(&priv->buckets_out) && time_before(jiffies, timeout))
516 schedule_timeout_interruptible(1);
517
518 for (i = 0; i < priv->max_buckets_out; i++) {
519 if (priv->RcvCtl[i].skb != NULL) {
520 dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
521 "is still out\n", i));
522 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma,
523 priv->RcvCtl[i].len,
524 PCI_DMA_FROMDEVICE);
525 dev_kfree_skb(priv->RcvCtl[i].skb);
526 }
527 }
528
529 kfree(priv->RcvCtl);
530 kfree(priv->mpt_rxfidx);
531
532 for (i = 0; i < priv->tx_max_out; i++) {
533 if (priv->SendCtl[i].skb != NULL) {
534 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma,
535 priv->SendCtl[i].len,
536 PCI_DMA_TODEVICE);
537 dev_kfree_skb(priv->SendCtl[i].skb);
538 }
539 }
540
541 kfree(priv->SendCtl);
542 kfree(priv->mpt_txfidx);
543
544 atomic_set(&priv->buckets_out, 0);
545
546 printk(KERN_INFO MYNAM ": %s/%s: interface down & inactive\n",
547 IOC_AND_NETDEV_NAMES_s_s(dev));
548
549 return 0;
550}
551
552
553
554static void
555mpt_lan_tx_timeout(struct net_device *dev)
556{
557 struct mpt_lan_priv *priv = netdev_priv(dev);
558 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
559
560 if (mpt_dev->active) {
561 dlprintk (("mptlan/tx_timeout: calling netif_wake_queue for %s.\n", dev->name));
562 netif_wake_queue(dev);
563 }
564}
565
566
567
568static int
569mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
570{
571 struct mpt_lan_priv *priv = netdev_priv(dev);
572 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
573 struct sk_buff *sent;
574 unsigned long flags;
575 u32 ctx;
576
577 ctx = GET_LAN_BUFFER_CONTEXT(tmsg);
578 sent = priv->SendCtl[ctx].skb;
579
580 dev->stats.tx_packets++;
581 dev->stats.tx_bytes += sent->len;
582
583 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
584 IOC_AND_NETDEV_NAMES_s_s(dev),
585 __func__, sent));
586
587 priv->SendCtl[ctx].skb = NULL;
588 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
589 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
590 dev_kfree_skb_irq(sent);
591
592 spin_lock_irqsave(&priv->txfidx_lock, flags);
593 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
594 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
595
596 netif_wake_queue(dev);
597 return 0;
598}
599
600
601static int
602mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
603{
604 struct mpt_lan_priv *priv = netdev_priv(dev);
605 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
606 struct sk_buff *sent;
607 unsigned long flags;
608 int FreeReqFrame = 0;
609 u32 *pContext;
610 u32 ctx;
611 u8 count;
612
613 count = pSendRep->NumberOfContexts;
614
615 dioprintk((KERN_INFO MYNAM ": send_reply: IOCStatus: %04x\n",
616 le16_to_cpu(pSendRep->IOCStatus)));
617
618
619
620 switch (le16_to_cpu(pSendRep->IOCStatus) & MPI_IOCSTATUS_MASK) {
621 case MPI_IOCSTATUS_SUCCESS:
622 dev->stats.tx_packets += count;
623 break;
624
625 case MPI_IOCSTATUS_LAN_CANCELED:
626 case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED:
627 break;
628
629 case MPI_IOCSTATUS_INVALID_SGL:
630 dev->stats.tx_errors += count;
631 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Invalid SGL sent to IOC!\n",
632 IOC_AND_NETDEV_NAMES_s_s(dev));
633 goto out;
634
635 default:
636 dev->stats.tx_errors += count;
637 break;
638 }
639
640 pContext = &pSendRep->BufferContext;
641
642 spin_lock_irqsave(&priv->txfidx_lock, flags);
643 while (count > 0) {
644 ctx = GET_LAN_BUFFER_CONTEXT(le32_to_cpu(*pContext));
645
646 sent = priv->SendCtl[ctx].skb;
647 dev->stats.tx_bytes += sent->len;
648
649 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
650 IOC_AND_NETDEV_NAMES_s_s(dev),
651 __func__, sent));
652
653 priv->SendCtl[ctx].skb = NULL;
654 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
655 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
656 dev_kfree_skb_irq(sent);
657
658 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
659
660 pContext++;
661 count--;
662 }
663 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
664
665out:
666 if (!(pSendRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
667 FreeReqFrame = 1;
668
669 netif_wake_queue(dev);
670 return FreeReqFrame;
671}
672
673
674static netdev_tx_t
675mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
676{
677 struct mpt_lan_priv *priv = netdev_priv(dev);
678 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
679 MPT_FRAME_HDR *mf;
680 LANSendRequest_t *pSendReq;
681 SGETransaction32_t *pTrans;
682 SGESimple64_t *pSimple;
683 const unsigned char *mac;
684 dma_addr_t dma;
685 unsigned long flags;
686 int ctx;
687 u16 cur_naa = 0x1000;
688
689 dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
690 __func__, skb));
691
692 spin_lock_irqsave(&priv->txfidx_lock, flags);
693 if (priv->mpt_txfidx_tail < 0) {
694 netif_stop_queue(dev);
695 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
696
697 printk (KERN_ERR "%s: no tx context available: %u\n",
698 __func__, priv->mpt_txfidx_tail);
699 return NETDEV_TX_BUSY;
700 }
701
702 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
703 if (mf == NULL) {
704 netif_stop_queue(dev);
705 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
706
707 printk (KERN_ERR "%s: Unable to alloc request frame\n",
708 __func__);
709 return NETDEV_TX_BUSY;
710 }
711
712 ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
713 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
714
715
716
717
718 pSendReq = (LANSendRequest_t *) mf;
719
720
721
722
723 skb_reset_mac_header(skb);
724 skb_pull(skb, 12);
725
726 dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
727 PCI_DMA_TODEVICE);
728
729 priv->SendCtl[ctx].skb = skb;
730 priv->SendCtl[ctx].dma = dma;
731 priv->SendCtl[ctx].len = skb->len;
732
733
734 pSendReq->Reserved = 0;
735 pSendReq->Function = MPI_FUNCTION_LAN_SEND;
736 pSendReq->ChainOffset = 0;
737 pSendReq->Reserved2 = 0;
738 pSendReq->MsgFlags = 0;
739 pSendReq->PortNumber = priv->pnum;
740
741
742 pTrans = (SGETransaction32_t *) pSendReq->SG_List;
743
744
745 pTrans->ContextSize = sizeof(u32);
746 pTrans->DetailsLength = 2 * sizeof(u32);
747 pTrans->Flags = 0;
748 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
749
750
751
752
753
754 mac = skb_mac_header(skb);
755
756 pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) |
757 (mac[0] << 8) |
758 (mac[1] << 0));
759 pTrans->TransactionDetails[1] = cpu_to_le32((mac[2] << 24) |
760 (mac[3] << 16) |
761 (mac[4] << 8) |
762 (mac[5] << 0));
763
764 pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
765
766
767
768
769 pSimple->FlagsLength = cpu_to_le32(
770 ((MPI_SGE_FLAGS_LAST_ELEMENT |
771 MPI_SGE_FLAGS_END_OF_BUFFER |
772 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
773 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
774 MPI_SGE_FLAGS_HOST_TO_IOC |
775 MPI_SGE_FLAGS_64_BIT_ADDRESSING |
776 MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
777 skb->len);
778 pSimple->Address.Low = cpu_to_le32((u32) dma);
779 if (sizeof(dma_addr_t) > sizeof(u32))
780 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
781 else
782 pSimple->Address.High = 0;
783
784 mpt_put_msg_frame (LanCtx, mpt_dev, mf);
785 netif_trans_update(dev);
786
787 dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.\n",
788 IOC_AND_NETDEV_NAMES_s_s(dev),
789 le32_to_cpu(pSimple->FlagsLength)));
790
791 return NETDEV_TX_OK;
792}
793
794
795static void
796mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
797
798
799
800{
801 struct mpt_lan_priv *priv = netdev_priv(dev);
802
803 if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
804 if (priority) {
805 schedule_delayed_work(&priv->post_buckets_task, 0);
806 } else {
807 schedule_delayed_work(&priv->post_buckets_task, 1);
808 dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
809 "timer.\n"));
810 }
811 dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.\n",
812 IOC_AND_NETDEV_NAMES_s_s(dev) ));
813 }
814}
815
816
817static int
818mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
819{
820 struct mpt_lan_priv *priv = netdev_priv(dev);
821
822 skb->protocol = mpt_lan_type_trans(skb, dev);
823
824 dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
825 "delivered to upper level.\n",
826 IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
827
828 dev->stats.rx_bytes += skb->len;
829 dev->stats.rx_packets++;
830
831 skb->dev = dev;
832 netif_rx(skb);
833
834 dioprintk((MYNAM "/receive_skb: %d buckets remaining\n",
835 atomic_read(&priv->buckets_out)));
836
837 if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
838 mpt_lan_wake_post_buckets_task(dev, 1);
839
840 dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
841 "remaining, %d received back since sod\n",
842 atomic_read(&priv->buckets_out), priv->total_received));
843
844 return 0;
845}
846
847
848
849static int
850mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
851{
852 struct mpt_lan_priv *priv = netdev_priv(dev);
853 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
854 struct sk_buff *skb, *old_skb;
855 unsigned long flags;
856 u32 ctx, len;
857
858 ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
859 skb = priv->RcvCtl[ctx].skb;
860
861 len = GET_LAN_PACKET_LENGTH(tmsg);
862
863 if (len < MPT_LAN_RX_COPYBREAK) {
864 old_skb = skb;
865
866 skb = (struct sk_buff *)dev_alloc_skb(len);
867 if (!skb) {
868 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
869 IOC_AND_NETDEV_NAMES_s_s(dev),
870 __FILE__, __LINE__);
871 return -ENOMEM;
872 }
873
874 pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
875 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
876
877 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
878
879 pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
880 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
881 goto out;
882 }
883
884 skb_put(skb, len);
885
886 priv->RcvCtl[ctx].skb = NULL;
887
888 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
889 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
890
891out:
892 spin_lock_irqsave(&priv->rxfidx_lock, flags);
893 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
894 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
895
896 atomic_dec(&priv->buckets_out);
897 priv->total_received++;
898
899 return mpt_lan_receive_skb(dev, skb);
900}
901
902
903static int
904mpt_lan_receive_post_free(struct net_device *dev,
905 LANReceivePostReply_t *pRecvRep)
906{
907 struct mpt_lan_priv *priv = netdev_priv(dev);
908 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
909 unsigned long flags;
910 struct sk_buff *skb;
911 u32 ctx;
912 int count;
913 int i;
914
915 count = pRecvRep->NumberOfContexts;
916
917 dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
918 "IOC returned %d buckets, freeing them...\n", count));
919
920 spin_lock_irqsave(&priv->rxfidx_lock, flags);
921 for (i = 0; i < count; i++) {
922 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
923
924 skb = priv->RcvCtl[ctx].skb;
925
926
927
928
929
930
931
932 priv->RcvCtl[ctx].skb = NULL;
933 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
934 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
935 dev_kfree_skb_any(skb);
936
937 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
938 }
939 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
940
941 atomic_sub(count, &priv->buckets_out);
942
943
944
945
946
947
948
949
950
951 dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
952 "remaining, %d received back since sod.\n",
953 atomic_read(&priv->buckets_out), priv->total_received));
954 return 0;
955}
956
957
958static int
959mpt_lan_receive_post_reply(struct net_device *dev,
960 LANReceivePostReply_t *pRecvRep)
961{
962 struct mpt_lan_priv *priv = netdev_priv(dev);
963 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
964 struct sk_buff *skb, *old_skb;
965 unsigned long flags;
966 u32 len, ctx, offset;
967 u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
968 int count;
969 int i, l;
970
971 dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply called\n"));
972 dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04x\n",
973 le16_to_cpu(pRecvRep->IOCStatus)));
974
975 if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
976 MPI_IOCSTATUS_LAN_CANCELED)
977 return mpt_lan_receive_post_free(dev, pRecvRep);
978
979 len = le32_to_cpu(pRecvRep->PacketLength);
980 if (len == 0) {
981 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
982 "ReceivePostReply w/ PacketLength zero!\n",
983 IOC_AND_NETDEV_NAMES_s_s(dev));
984 printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04x\n",
985 pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
986 return -1;
987 }
988
989 ctx = le32_to_cpu(pRecvRep->BucketContext[0]);
990 count = pRecvRep->NumberOfContexts;
991 skb = priv->RcvCtl[ctx].skb;
992
993 offset = le32_to_cpu(pRecvRep->PacketOffset);
994
995
996
997
998
999
1000
1001 dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %d\n",
1002 IOC_AND_NETDEV_NAMES_s_s(dev),
1003 offset, len));
1004
1005 if (count > 1) {
1006 int szrem = len;
1007
1008
1009
1010
1011
1012 skb = (struct sk_buff *)dev_alloc_skb(len);
1013 if (!skb) {
1014 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1015 IOC_AND_NETDEV_NAMES_s_s(dev),
1016 __FILE__, __LINE__);
1017 return -ENOMEM;
1018 }
1019
1020 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1021 for (i = 0; i < count; i++) {
1022
1023 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
1024 old_skb = priv->RcvCtl[ctx].skb;
1025
1026 l = priv->RcvCtl[ctx].len;
1027 if (szrem < l)
1028 l = szrem;
1029
1030
1031
1032
1033
1034 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1035 priv->RcvCtl[ctx].dma,
1036 priv->RcvCtl[ctx].len,
1037 PCI_DMA_FROMDEVICE);
1038 skb_copy_from_linear_data(old_skb, skb_put(skb, l), l);
1039
1040 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1041 priv->RcvCtl[ctx].dma,
1042 priv->RcvCtl[ctx].len,
1043 PCI_DMA_FROMDEVICE);
1044
1045 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1046 szrem -= l;
1047 }
1048 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1049
1050 } else if (len < MPT_LAN_RX_COPYBREAK) {
1051
1052 old_skb = skb;
1053
1054 skb = (struct sk_buff *)dev_alloc_skb(len);
1055 if (!skb) {
1056 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1057 IOC_AND_NETDEV_NAMES_s_s(dev),
1058 __FILE__, __LINE__);
1059 return -ENOMEM;
1060 }
1061
1062 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1063 priv->RcvCtl[ctx].dma,
1064 priv->RcvCtl[ctx].len,
1065 PCI_DMA_FROMDEVICE);
1066
1067 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
1068
1069 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1070 priv->RcvCtl[ctx].dma,
1071 priv->RcvCtl[ctx].len,
1072 PCI_DMA_FROMDEVICE);
1073
1074 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1075 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1076 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1077
1078 } else {
1079 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1080
1081 priv->RcvCtl[ctx].skb = NULL;
1082
1083 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
1084 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
1085 priv->RcvCtl[ctx].dma = 0;
1086
1087 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1088 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1089
1090 skb_put(skb,len);
1091 }
1092
1093 atomic_sub(count, &priv->buckets_out);
1094 priv->total_received += count;
1095
1096 if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
1097 printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
1098 "MPT_LAN_MAX_BUCKETS_OUT = %d\n",
1099 IOC_AND_NETDEV_NAMES_s_s(dev),
1100 priv->mpt_rxfidx_tail,
1101 MPT_LAN_MAX_BUCKETS_OUT);
1102
1103 return -1;
1104 }
1105
1106 if (remaining == 0)
1107 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1108 "(priv->buckets_out = %d)\n",
1109 IOC_AND_NETDEV_NAMES_s_s(dev),
1110 atomic_read(&priv->buckets_out));
1111 else if (remaining < 10)
1112 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1113 "(priv->buckets_out = %d)\n",
1114 IOC_AND_NETDEV_NAMES_s_s(dev),
1115 remaining, atomic_read(&priv->buckets_out));
1116
1117 if ((remaining < priv->bucketthresh) &&
1118 ((atomic_read(&priv->buckets_out) - remaining) >
1119 MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1120
1121 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1122 "buckets_out count and fw's BucketsRemaining "
1123 "count has crossed the threshold, issuing a "
1124 "LanReset to clear the fw's hashtable. You may "
1125 "want to check your /var/log/messages for \"CRC "
1126 "error\" event notifications.\n");
1127
1128 mpt_lan_reset(dev);
1129 mpt_lan_wake_post_buckets_task(dev, 0);
1130 }
1131
1132 return mpt_lan_receive_skb(dev, skb);
1133}
1134
1135
1136
1137
1138static void
1139mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
1140{
1141 struct net_device *dev = priv->dev;
1142 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1143 MPT_FRAME_HDR *mf;
1144 LANReceivePostRequest_t *pRecvReq;
1145 SGETransaction32_t *pTrans;
1146 SGESimple64_t *pSimple;
1147 struct sk_buff *skb;
1148 dma_addr_t dma;
1149 u32 curr, buckets, count, max;
1150 u32 len = (dev->mtu + dev->hard_header_len + 4);
1151 unsigned long flags;
1152 int i;
1153
1154 curr = atomic_read(&priv->buckets_out);
1155 buckets = (priv->max_buckets_out - curr);
1156
1157 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
1158 IOC_AND_NETDEV_NAMES_s_s(dev),
1159 __func__, buckets, curr));
1160
1161 max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
1162 (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
1163
1164 while (buckets) {
1165 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
1166 if (mf == NULL) {
1167 printk (KERN_ERR "%s: Unable to alloc request frame\n",
1168 __func__);
1169 dioprintk((KERN_ERR "%s: %u buckets remaining\n",
1170 __func__, buckets));
1171 goto out;
1172 }
1173 pRecvReq = (LANReceivePostRequest_t *) mf;
1174
1175 i = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1176 mpt_dev->RequestNB[i] = 0;
1177 count = buckets;
1178 if (count > max)
1179 count = max;
1180
1181 pRecvReq->Function = MPI_FUNCTION_LAN_RECEIVE;
1182 pRecvReq->ChainOffset = 0;
1183 pRecvReq->MsgFlags = 0;
1184 pRecvReq->PortNumber = priv->pnum;
1185
1186 pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
1187 pSimple = NULL;
1188
1189 for (i = 0; i < count; i++) {
1190 int ctx;
1191
1192 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1193 if (priv->mpt_rxfidx_tail < 0) {
1194 printk (KERN_ERR "%s: Can't alloc context\n",
1195 __func__);
1196 spin_unlock_irqrestore(&priv->rxfidx_lock,
1197 flags);
1198 break;
1199 }
1200
1201 ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
1202
1203 skb = priv->RcvCtl[ctx].skb;
1204 if (skb && (priv->RcvCtl[ctx].len != len)) {
1205 pci_unmap_single(mpt_dev->pcidev,
1206 priv->RcvCtl[ctx].dma,
1207 priv->RcvCtl[ctx].len,
1208 PCI_DMA_FROMDEVICE);
1209 dev_kfree_skb(priv->RcvCtl[ctx].skb);
1210 skb = priv->RcvCtl[ctx].skb = NULL;
1211 }
1212
1213 if (skb == NULL) {
1214 skb = dev_alloc_skb(len);
1215 if (skb == NULL) {
1216 printk (KERN_WARNING
1217 MYNAM "/%s: Can't alloc skb\n",
1218 __func__);
1219 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1220 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1221 break;
1222 }
1223
1224 dma = pci_map_single(mpt_dev->pcidev, skb->data,
1225 len, PCI_DMA_FROMDEVICE);
1226
1227 priv->RcvCtl[ctx].skb = skb;
1228 priv->RcvCtl[ctx].dma = dma;
1229 priv->RcvCtl[ctx].len = len;
1230 }
1231
1232 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1233
1234 pTrans->ContextSize = sizeof(u32);
1235 pTrans->DetailsLength = 0;
1236 pTrans->Flags = 0;
1237 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
1238
1239 pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
1240
1241 pSimple->FlagsLength = cpu_to_le32(
1242 ((MPI_SGE_FLAGS_END_OF_BUFFER |
1243 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1244 MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
1245 pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
1246 if (sizeof(dma_addr_t) > sizeof(u32))
1247 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
1248 else
1249 pSimple->Address.High = 0;
1250
1251 pTrans = (SGETransaction32_t *) (pSimple + 1);
1252 }
1253
1254 if (pSimple == NULL) {
1255 printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
1256 __func__);
1257 mpt_free_msg_frame(mpt_dev, mf);
1258 goto out;
1259 }
1260
1261 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
1262
1263 pRecvReq->BucketCount = cpu_to_le32(i);
1264
1265
1266
1267
1268
1269
1270
1271 mpt_put_msg_frame(LanCtx, mpt_dev, mf);
1272
1273 priv->total_posted += i;
1274 buckets -= i;
1275 atomic_add(i, &priv->buckets_out);
1276 }
1277
1278out:
1279 dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
1280 __func__, buckets, atomic_read(&priv->buckets_out)));
1281 dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
1282 __func__, priv->total_posted, priv->total_received));
1283
1284 clear_bit(0, &priv->post_buckets_active);
1285}
1286
1287static void
1288mpt_lan_post_receive_buckets_work(struct work_struct *work)
1289{
1290 mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
1291 post_buckets_task.work));
1292}
1293
1294static const struct net_device_ops mpt_netdev_ops = {
1295 .ndo_open = mpt_lan_open,
1296 .ndo_stop = mpt_lan_close,
1297 .ndo_start_xmit = mpt_lan_sdu_send,
1298 .ndo_tx_timeout = mpt_lan_tx_timeout,
1299};
1300
1301
1302static struct net_device *
1303mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1304{
1305 struct net_device *dev;
1306 struct mpt_lan_priv *priv;
1307 u8 HWaddr[FC_ALEN], *a;
1308
1309 dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1310 if (!dev)
1311 return NULL;
1312
1313 dev->mtu = MPT_LAN_MTU;
1314
1315 priv = netdev_priv(dev);
1316
1317 priv->dev = dev;
1318 priv->mpt_dev = mpt_dev;
1319 priv->pnum = pnum;
1320
1321 INIT_DELAYED_WORK(&priv->post_buckets_task,
1322 mpt_lan_post_receive_buckets_work);
1323 priv->post_buckets_active = 0;
1324
1325 dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
1326 __LINE__, dev->mtu + dev->hard_header_len + 4));
1327
1328 atomic_set(&priv->buckets_out, 0);
1329 priv->total_posted = 0;
1330 priv->total_received = 0;
1331 priv->max_buckets_out = max_buckets_out;
1332 if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
1333 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
1334
1335 dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n",
1336 __LINE__,
1337 mpt_dev->pfacts[0].MaxLanBuckets,
1338 max_buckets_out,
1339 priv->max_buckets_out));
1340
1341 priv->bucketthresh = priv->max_buckets_out * 2 / 3;
1342 spin_lock_init(&priv->txfidx_lock);
1343 spin_lock_init(&priv->rxfidx_lock);
1344
1345
1346 a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
1347
1348 HWaddr[0] = a[5];
1349 HWaddr[1] = a[4];
1350 HWaddr[2] = a[3];
1351 HWaddr[3] = a[2];
1352 HWaddr[4] = a[1];
1353 HWaddr[5] = a[0];
1354
1355 dev->addr_len = FC_ALEN;
1356 memcpy(dev->dev_addr, HWaddr, FC_ALEN);
1357 memset(dev->broadcast, 0xff, FC_ALEN);
1358
1359
1360
1361
1362 priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
1363 tx_max_out_p : MPT_TX_MAX_OUT_LIM;
1364
1365 dev->netdev_ops = &mpt_netdev_ops;
1366 dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
1367
1368
1369 dev->min_mtu = MPT_LAN_MIN_MTU;
1370 dev->max_mtu = MPT_LAN_MAX_MTU;
1371
1372 dlprintk((KERN_INFO MYNAM ": Finished registering dev "
1373 "and setting initial values\n"));
1374
1375 if (register_netdev(dev) != 0) {
1376 free_netdev(dev);
1377 dev = NULL;
1378 }
1379 return dev;
1380}
1381
1382static int
1383mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1384{
1385 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1386 struct net_device *dev;
1387 int i;
1388
1389 for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1390 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1391 "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1392 ioc->name, ioc->pfacts[i].PortNumber,
1393 ioc->pfacts[i].ProtocolFlags,
1394 MPT_PROTOCOL_FLAGS_c_c_c_c(
1395 ioc->pfacts[i].ProtocolFlags));
1396
1397 if (!(ioc->pfacts[i].ProtocolFlags &
1398 MPI_PORTFACTS_PROTOCOL_LAN)) {
1399 printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1400 "seems to be disabled on this adapter port!\n",
1401 ioc->name);
1402 continue;
1403 }
1404
1405 dev = mpt_register_lan_device(ioc, i);
1406 if (!dev) {
1407 printk(KERN_ERR MYNAM ": %s: Unable to register "
1408 "port%d as a LAN device\n", ioc->name,
1409 ioc->pfacts[i].PortNumber);
1410 continue;
1411 }
1412
1413 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1414 "registered as '%s'\n", ioc->name, dev->name);
1415 printk(KERN_INFO MYNAM ": %s/%s: "
1416 "LanAddr = %pM\n",
1417 IOC_AND_NETDEV_NAMES_s_s(dev),
1418 dev->dev_addr);
1419
1420 ioc->netdev = dev;
1421
1422 return 0;
1423 }
1424
1425 return -ENODEV;
1426}
1427
1428static void
1429mptlan_remove(struct pci_dev *pdev)
1430{
1431 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1432 struct net_device *dev = ioc->netdev;
1433
1434 if(dev != NULL) {
1435 unregister_netdev(dev);
1436 free_netdev(dev);
1437 }
1438}
1439
1440static struct mpt_pci_driver mptlan_driver = {
1441 .probe = mptlan_probe,
1442 .remove = mptlan_remove,
1443};
1444
1445static int __init mpt_lan_init (void)
1446{
1447 show_mptmod_ver(LANAME, LANVER);
1448
1449 LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER,
1450 "lan_reply");
1451 if (LanCtx <= 0) {
1452 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1453 return -EBUSY;
1454 }
1455
1456 dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1457
1458 if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1459 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1460 "handler with mptbase! The world is at an end! "
1461 "Everything is fading to black! Goodbye.\n");
1462 return -EBUSY;
1463 }
1464
1465 dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1466
1467 mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER);
1468 return 0;
1469}
1470
1471static void __exit mpt_lan_exit(void)
1472{
1473 mpt_device_driver_deregister(MPTLAN_DRIVER);
1474 mpt_reset_deregister(LanCtx);
1475
1476 if (LanCtx) {
1477 mpt_deregister(LanCtx);
1478 LanCtx = MPT_MAX_PROTOCOL_DRIVERS;
1479 }
1480}
1481
1482module_init(mpt_lan_init);
1483module_exit(mpt_lan_exit);
1484
1485
1486static unsigned short
1487mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1488{
1489 struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1490 struct fcllc *fcllc;
1491
1492 skb_reset_mac_header(skb);
1493 skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1494
1495 if (fch->dtype == htons(0xffff)) {
1496 u32 *p = (u32 *) fch;
1497
1498 swab32s(p + 0);
1499 swab32s(p + 1);
1500 swab32s(p + 2);
1501 swab32s(p + 3);
1502
1503 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1504 NETDEV_PTR_TO_IOC_NAME_s(dev));
1505 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %pM\n",
1506 fch->saddr);
1507 }
1508
1509 if (*fch->daddr & 1) {
1510 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1511 skb->pkt_type = PACKET_BROADCAST;
1512 } else {
1513 skb->pkt_type = PACKET_MULTICAST;
1514 }
1515 } else {
1516 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1517 skb->pkt_type = PACKET_OTHERHOST;
1518 } else {
1519 skb->pkt_type = PACKET_HOST;
1520 }
1521 }
1522
1523 fcllc = (struct fcllc *)skb->data;
1524
1525
1526
1527
1528 if (fcllc->dsap == EXTENDED_SAP &&
1529 (fcllc->ethertype == htons(ETH_P_IP) ||
1530 fcllc->ethertype == htons(ETH_P_ARP))) {
1531 skb_pull(skb, sizeof(struct fcllc));
1532 return fcllc->ethertype;
1533 }
1534
1535 return htons(ETH_P_802_2);
1536}
1537
1538
1539
