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(priv->tx_max_out * sizeof(int), GFP_KERNEL);
398 if (priv->mpt_txfidx == NULL)
399 goto out;
400 priv->mpt_txfidx_tail = -1;
401
402 priv->SendCtl = kcalloc(priv->tx_max_out, sizeof(struct BufferControl),
403 GFP_KERNEL);
404 if (priv->SendCtl == NULL)
405 goto out_mpt_txfidx;
406 for (i = 0; i < priv->tx_max_out; i++)
407 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
408
409 dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
410
411 priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int),
412 GFP_KERNEL);
413 if (priv->mpt_rxfidx == NULL)
414 goto out_SendCtl;
415 priv->mpt_rxfidx_tail = -1;
416
417 priv->RcvCtl = kcalloc(priv->max_buckets_out,
418 sizeof(struct BufferControl),
419 GFP_KERNEL);
420 if (priv->RcvCtl == NULL)
421 goto out_mpt_rxfidx;
422 for (i = 0; i < priv->max_buckets_out; i++)
423 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
424
425 dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - "));
426 for (i = 0; i < priv->tx_max_out; i++)
427 dlprintk((" %xh", priv->mpt_txfidx[i]));
428 dlprintk(("\n"));
429
430 dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n"));
431
432 mpt_lan_post_receive_buckets(priv);
433 printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n",
434 IOC_AND_NETDEV_NAMES_s_s(dev));
435
436 if (mpt_event_register(LanCtx, mpt_lan_event_process) != 0) {
437 printk (KERN_WARNING MYNAM "/lo: Unable to register for Event"
438 " Notifications. This is a bad thing! We're not going "
439 "to go ahead, but I'd be leery of system stability at "
440 "this point.\n");
441 }
442
443 netif_start_queue(dev);
444 dlprintk((KERN_INFO MYNAM "/lo: Done.\n"));
445
446 return 0;
447out_mpt_rxfidx:
448 kfree(priv->mpt_rxfidx);
449 priv->mpt_rxfidx = NULL;
450out_SendCtl:
451 kfree(priv->SendCtl);
452 priv->SendCtl = NULL;
453out_mpt_txfidx:
454 kfree(priv->mpt_txfidx);
455 priv->mpt_txfidx = NULL;
456out: return -ENOMEM;
457}
458
459
460
461
462static int
463mpt_lan_reset(struct net_device *dev)
464{
465 MPT_FRAME_HDR *mf;
466 LANResetRequest_t *pResetReq;
467 struct mpt_lan_priv *priv = netdev_priv(dev);
468
469 mf = mpt_get_msg_frame(LanCtx, priv->mpt_dev);
470
471 if (mf == NULL) {
472
473
474
475 return -1;
476 }
477
478 pResetReq = (LANResetRequest_t *) mf;
479
480 pResetReq->Function = MPI_FUNCTION_LAN_RESET;
481 pResetReq->ChainOffset = 0;
482 pResetReq->Reserved = 0;
483 pResetReq->PortNumber = priv->pnum;
484 pResetReq->MsgFlags = 0;
485 pResetReq->Reserved2 = 0;
486
487 mpt_put_msg_frame(LanCtx, priv->mpt_dev, mf);
488
489 return 0;
490}
491
492
493static int
494mpt_lan_close(struct net_device *dev)
495{
496 struct mpt_lan_priv *priv = netdev_priv(dev);
497 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
498 unsigned long timeout;
499 int i;
500
501 dlprintk((KERN_INFO MYNAM ": mpt_lan_close called\n"));
502
503 mpt_event_deregister(LanCtx);
504
505 dlprintk((KERN_INFO MYNAM ":lan_close: Posted %d buckets "
506 "since driver was loaded, %d still out\n",
507 priv->total_posted,atomic_read(&priv->buckets_out)));
508
509 netif_stop_queue(dev);
510
511 mpt_lan_reset(dev);
512
513 timeout = jiffies + 2 * HZ;
514 while (atomic_read(&priv->buckets_out) && time_before(jiffies, timeout))
515 schedule_timeout_interruptible(1);
516
517 for (i = 0; i < priv->max_buckets_out; i++) {
518 if (priv->RcvCtl[i].skb != NULL) {
519 dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
520 "is still out\n", i));
521 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma,
522 priv->RcvCtl[i].len,
523 PCI_DMA_FROMDEVICE);
524 dev_kfree_skb(priv->RcvCtl[i].skb);
525 }
526 }
527
528 kfree(priv->RcvCtl);
529 kfree(priv->mpt_rxfidx);
530
531 for (i = 0; i < priv->tx_max_out; i++) {
532 if (priv->SendCtl[i].skb != NULL) {
533 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma,
534 priv->SendCtl[i].len,
535 PCI_DMA_TODEVICE);
536 dev_kfree_skb(priv->SendCtl[i].skb);
537 }
538 }
539
540 kfree(priv->SendCtl);
541 kfree(priv->mpt_txfidx);
542
543 atomic_set(&priv->buckets_out, 0);
544
545 printk(KERN_INFO MYNAM ": %s/%s: interface down & inactive\n",
546 IOC_AND_NETDEV_NAMES_s_s(dev));
547
548 return 0;
549}
550
551
552static int
553mpt_lan_change_mtu(struct net_device *dev, int new_mtu)
554{
555 if ((new_mtu < MPT_LAN_MIN_MTU) || (new_mtu > MPT_LAN_MAX_MTU))
556 return -EINVAL;
557 dev->mtu = new_mtu;
558 return 0;
559}
560
561
562
563static void
564mpt_lan_tx_timeout(struct net_device *dev)
565{
566 struct mpt_lan_priv *priv = netdev_priv(dev);
567 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
568
569 if (mpt_dev->active) {
570 dlprintk (("mptlan/tx_timeout: calling netif_wake_queue for %s.\n", dev->name));
571 netif_wake_queue(dev);
572 }
573}
574
575
576
577static int
578mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
579{
580 struct mpt_lan_priv *priv = netdev_priv(dev);
581 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
582 struct sk_buff *sent;
583 unsigned long flags;
584 u32 ctx;
585
586 ctx = GET_LAN_BUFFER_CONTEXT(tmsg);
587 sent = priv->SendCtl[ctx].skb;
588
589 dev->stats.tx_packets++;
590 dev->stats.tx_bytes += sent->len;
591
592 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
593 IOC_AND_NETDEV_NAMES_s_s(dev),
594 __func__, sent));
595
596 priv->SendCtl[ctx].skb = NULL;
597 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
598 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
599 dev_kfree_skb_irq(sent);
600
601 spin_lock_irqsave(&priv->txfidx_lock, flags);
602 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
603 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
604
605 netif_wake_queue(dev);
606 return 0;
607}
608
609
610static int
611mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
612{
613 struct mpt_lan_priv *priv = netdev_priv(dev);
614 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
615 struct sk_buff *sent;
616 unsigned long flags;
617 int FreeReqFrame = 0;
618 u32 *pContext;
619 u32 ctx;
620 u8 count;
621
622 count = pSendRep->NumberOfContexts;
623
624 dioprintk((KERN_INFO MYNAM ": send_reply: IOCStatus: %04x\n",
625 le16_to_cpu(pSendRep->IOCStatus)));
626
627
628
629 switch (le16_to_cpu(pSendRep->IOCStatus) & MPI_IOCSTATUS_MASK) {
630 case MPI_IOCSTATUS_SUCCESS:
631 dev->stats.tx_packets += count;
632 break;
633
634 case MPI_IOCSTATUS_LAN_CANCELED:
635 case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED:
636 break;
637
638 case MPI_IOCSTATUS_INVALID_SGL:
639 dev->stats.tx_errors += count;
640 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Invalid SGL sent to IOC!\n",
641 IOC_AND_NETDEV_NAMES_s_s(dev));
642 goto out;
643
644 default:
645 dev->stats.tx_errors += count;
646 break;
647 }
648
649 pContext = &pSendRep->BufferContext;
650
651 spin_lock_irqsave(&priv->txfidx_lock, flags);
652 while (count > 0) {
653 ctx = GET_LAN_BUFFER_CONTEXT(le32_to_cpu(*pContext));
654
655 sent = priv->SendCtl[ctx].skb;
656 dev->stats.tx_bytes += sent->len;
657
658 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
659 IOC_AND_NETDEV_NAMES_s_s(dev),
660 __func__, sent));
661
662 priv->SendCtl[ctx].skb = NULL;
663 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
664 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
665 dev_kfree_skb_irq(sent);
666
667 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
668
669 pContext++;
670 count--;
671 }
672 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
673
674out:
675 if (!(pSendRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
676 FreeReqFrame = 1;
677
678 netif_wake_queue(dev);
679 return FreeReqFrame;
680}
681
682
683static int
684mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
685{
686 struct mpt_lan_priv *priv = netdev_priv(dev);
687 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
688 MPT_FRAME_HDR *mf;
689 LANSendRequest_t *pSendReq;
690 SGETransaction32_t *pTrans;
691 SGESimple64_t *pSimple;
692 const unsigned char *mac;
693 dma_addr_t dma;
694 unsigned long flags;
695 int ctx;
696 u16 cur_naa = 0x1000;
697
698 dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
699 __func__, skb));
700
701 spin_lock_irqsave(&priv->txfidx_lock, flags);
702 if (priv->mpt_txfidx_tail < 0) {
703 netif_stop_queue(dev);
704 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
705
706 printk (KERN_ERR "%s: no tx context available: %u\n",
707 __func__, priv->mpt_txfidx_tail);
708 return NETDEV_TX_BUSY;
709 }
710
711 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
712 if (mf == NULL) {
713 netif_stop_queue(dev);
714 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
715
716 printk (KERN_ERR "%s: Unable to alloc request frame\n",
717 __func__);
718 return NETDEV_TX_BUSY;
719 }
720
721 ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
722 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
723
724
725
726
727 pSendReq = (LANSendRequest_t *) mf;
728
729
730
731
732 skb_reset_mac_header(skb);
733 skb_pull(skb, 12);
734
735 dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
736 PCI_DMA_TODEVICE);
737
738 priv->SendCtl[ctx].skb = skb;
739 priv->SendCtl[ctx].dma = dma;
740 priv->SendCtl[ctx].len = skb->len;
741
742
743 pSendReq->Reserved = 0;
744 pSendReq->Function = MPI_FUNCTION_LAN_SEND;
745 pSendReq->ChainOffset = 0;
746 pSendReq->Reserved2 = 0;
747 pSendReq->MsgFlags = 0;
748 pSendReq->PortNumber = priv->pnum;
749
750
751 pTrans = (SGETransaction32_t *) pSendReq->SG_List;
752
753
754 pTrans->ContextSize = sizeof(u32);
755 pTrans->DetailsLength = 2 * sizeof(u32);
756 pTrans->Flags = 0;
757 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
758
759
760
761
762
763 mac = skb_mac_header(skb);
764
765 pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) |
766 (mac[0] << 8) |
767 (mac[1] << 0));
768 pTrans->TransactionDetails[1] = cpu_to_le32((mac[2] << 24) |
769 (mac[3] << 16) |
770 (mac[4] << 8) |
771 (mac[5] << 0));
772
773 pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
774
775
776
777
778 pSimple->FlagsLength = cpu_to_le32(
779 ((MPI_SGE_FLAGS_LAST_ELEMENT |
780 MPI_SGE_FLAGS_END_OF_BUFFER |
781 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
782 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
783 MPI_SGE_FLAGS_HOST_TO_IOC |
784 MPI_SGE_FLAGS_64_BIT_ADDRESSING |
785 MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
786 skb->len);
787 pSimple->Address.Low = cpu_to_le32((u32) dma);
788 if (sizeof(dma_addr_t) > sizeof(u32))
789 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
790 else
791 pSimple->Address.High = 0;
792
793 mpt_put_msg_frame (LanCtx, mpt_dev, mf);
794 netif_trans_update(dev);
795
796 dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.\n",
797 IOC_AND_NETDEV_NAMES_s_s(dev),
798 le32_to_cpu(pSimple->FlagsLength)));
799
800 return NETDEV_TX_OK;
801}
802
803
804static void
805mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
806
807
808
809{
810 struct mpt_lan_priv *priv = netdev_priv(dev);
811
812 if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
813 if (priority) {
814 schedule_delayed_work(&priv->post_buckets_task, 0);
815 } else {
816 schedule_delayed_work(&priv->post_buckets_task, 1);
817 dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
818 "timer.\n"));
819 }
820 dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.\n",
821 IOC_AND_NETDEV_NAMES_s_s(dev) ));
822 }
823}
824
825
826static int
827mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
828{
829 struct mpt_lan_priv *priv = netdev_priv(dev);
830
831 skb->protocol = mpt_lan_type_trans(skb, dev);
832
833 dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
834 "delivered to upper level.\n",
835 IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
836
837 dev->stats.rx_bytes += skb->len;
838 dev->stats.rx_packets++;
839
840 skb->dev = dev;
841 netif_rx(skb);
842
843 dioprintk((MYNAM "/receive_skb: %d buckets remaining\n",
844 atomic_read(&priv->buckets_out)));
845
846 if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
847 mpt_lan_wake_post_buckets_task(dev, 1);
848
849 dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
850 "remaining, %d received back since sod\n",
851 atomic_read(&priv->buckets_out), priv->total_received));
852
853 return 0;
854}
855
856
857
858static int
859mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
860{
861 struct mpt_lan_priv *priv = netdev_priv(dev);
862 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
863 struct sk_buff *skb, *old_skb;
864 unsigned long flags;
865 u32 ctx, len;
866
867 ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
868 skb = priv->RcvCtl[ctx].skb;
869
870 len = GET_LAN_PACKET_LENGTH(tmsg);
871
872 if (len < MPT_LAN_RX_COPYBREAK) {
873 old_skb = skb;
874
875 skb = (struct sk_buff *)dev_alloc_skb(len);
876 if (!skb) {
877 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
878 IOC_AND_NETDEV_NAMES_s_s(dev),
879 __FILE__, __LINE__);
880 return -ENOMEM;
881 }
882
883 pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
884 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
885
886 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
887
888 pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
889 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
890 goto out;
891 }
892
893 skb_put(skb, len);
894
895 priv->RcvCtl[ctx].skb = NULL;
896
897 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
898 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
899
900out:
901 spin_lock_irqsave(&priv->rxfidx_lock, flags);
902 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
903 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
904
905 atomic_dec(&priv->buckets_out);
906 priv->total_received++;
907
908 return mpt_lan_receive_skb(dev, skb);
909}
910
911
912static int
913mpt_lan_receive_post_free(struct net_device *dev,
914 LANReceivePostReply_t *pRecvRep)
915{
916 struct mpt_lan_priv *priv = netdev_priv(dev);
917 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
918 unsigned long flags;
919 struct sk_buff *skb;
920 u32 ctx;
921 int count;
922 int i;
923
924 count = pRecvRep->NumberOfContexts;
925
926 dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
927 "IOC returned %d buckets, freeing them...\n", count));
928
929 spin_lock_irqsave(&priv->rxfidx_lock, flags);
930 for (i = 0; i < count; i++) {
931 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
932
933 skb = priv->RcvCtl[ctx].skb;
934
935
936
937
938
939
940
941 priv->RcvCtl[ctx].skb = NULL;
942 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
943 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
944 dev_kfree_skb_any(skb);
945
946 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
947 }
948 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
949
950 atomic_sub(count, &priv->buckets_out);
951
952
953
954
955
956
957
958
959
960 dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
961 "remaining, %d received back since sod.\n",
962 atomic_read(&priv->buckets_out), priv->total_received));
963 return 0;
964}
965
966
967static int
968mpt_lan_receive_post_reply(struct net_device *dev,
969 LANReceivePostReply_t *pRecvRep)
970{
971 struct mpt_lan_priv *priv = netdev_priv(dev);
972 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
973 struct sk_buff *skb, *old_skb;
974 unsigned long flags;
975 u32 len, ctx, offset;
976 u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
977 int count;
978 int i, l;
979
980 dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply called\n"));
981 dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04x\n",
982 le16_to_cpu(pRecvRep->IOCStatus)));
983
984 if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
985 MPI_IOCSTATUS_LAN_CANCELED)
986 return mpt_lan_receive_post_free(dev, pRecvRep);
987
988 len = le32_to_cpu(pRecvRep->PacketLength);
989 if (len == 0) {
990 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
991 "ReceivePostReply w/ PacketLength zero!\n",
992 IOC_AND_NETDEV_NAMES_s_s(dev));
993 printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04x\n",
994 pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
995 return -1;
996 }
997
998 ctx = le32_to_cpu(pRecvRep->BucketContext[0]);
999 count = pRecvRep->NumberOfContexts;
1000 skb = priv->RcvCtl[ctx].skb;
1001
1002 offset = le32_to_cpu(pRecvRep->PacketOffset);
1003
1004
1005
1006
1007
1008
1009
1010 dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %d\n",
1011 IOC_AND_NETDEV_NAMES_s_s(dev),
1012 offset, len));
1013
1014 if (count > 1) {
1015 int szrem = len;
1016
1017
1018
1019
1020
1021 skb = (struct sk_buff *)dev_alloc_skb(len);
1022 if (!skb) {
1023 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1024 IOC_AND_NETDEV_NAMES_s_s(dev),
1025 __FILE__, __LINE__);
1026 return -ENOMEM;
1027 }
1028
1029 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1030 for (i = 0; i < count; i++) {
1031
1032 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
1033 old_skb = priv->RcvCtl[ctx].skb;
1034
1035 l = priv->RcvCtl[ctx].len;
1036 if (szrem < l)
1037 l = szrem;
1038
1039
1040
1041
1042
1043 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1044 priv->RcvCtl[ctx].dma,
1045 priv->RcvCtl[ctx].len,
1046 PCI_DMA_FROMDEVICE);
1047 skb_copy_from_linear_data(old_skb, skb_put(skb, l), l);
1048
1049 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1050 priv->RcvCtl[ctx].dma,
1051 priv->RcvCtl[ctx].len,
1052 PCI_DMA_FROMDEVICE);
1053
1054 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1055 szrem -= l;
1056 }
1057 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1058
1059 } else if (len < MPT_LAN_RX_COPYBREAK) {
1060
1061 old_skb = skb;
1062
1063 skb = (struct sk_buff *)dev_alloc_skb(len);
1064 if (!skb) {
1065 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1066 IOC_AND_NETDEV_NAMES_s_s(dev),
1067 __FILE__, __LINE__);
1068 return -ENOMEM;
1069 }
1070
1071 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1072 priv->RcvCtl[ctx].dma,
1073 priv->RcvCtl[ctx].len,
1074 PCI_DMA_FROMDEVICE);
1075
1076 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
1077
1078 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1079 priv->RcvCtl[ctx].dma,
1080 priv->RcvCtl[ctx].len,
1081 PCI_DMA_FROMDEVICE);
1082
1083 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1084 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1085 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1086
1087 } else {
1088 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1089
1090 priv->RcvCtl[ctx].skb = NULL;
1091
1092 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
1093 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
1094 priv->RcvCtl[ctx].dma = 0;
1095
1096 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1097 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1098
1099 skb_put(skb,len);
1100 }
1101
1102 atomic_sub(count, &priv->buckets_out);
1103 priv->total_received += count;
1104
1105 if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
1106 printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
1107 "MPT_LAN_MAX_BUCKETS_OUT = %d\n",
1108 IOC_AND_NETDEV_NAMES_s_s(dev),
1109 priv->mpt_rxfidx_tail,
1110 MPT_LAN_MAX_BUCKETS_OUT);
1111
1112 return -1;
1113 }
1114
1115 if (remaining == 0)
1116 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1117 "(priv->buckets_out = %d)\n",
1118 IOC_AND_NETDEV_NAMES_s_s(dev),
1119 atomic_read(&priv->buckets_out));
1120 else if (remaining < 10)
1121 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1122 "(priv->buckets_out = %d)\n",
1123 IOC_AND_NETDEV_NAMES_s_s(dev),
1124 remaining, atomic_read(&priv->buckets_out));
1125
1126 if ((remaining < priv->bucketthresh) &&
1127 ((atomic_read(&priv->buckets_out) - remaining) >
1128 MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1129
1130 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1131 "buckets_out count and fw's BucketsRemaining "
1132 "count has crossed the threshold, issuing a "
1133 "LanReset to clear the fw's hashtable. You may "
1134 "want to check your /var/log/messages for \"CRC "
1135 "error\" event notifications.\n");
1136
1137 mpt_lan_reset(dev);
1138 mpt_lan_wake_post_buckets_task(dev, 0);
1139 }
1140
1141 return mpt_lan_receive_skb(dev, skb);
1142}
1143
1144
1145
1146
1147static void
1148mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
1149{
1150 struct net_device *dev = priv->dev;
1151 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1152 MPT_FRAME_HDR *mf;
1153 LANReceivePostRequest_t *pRecvReq;
1154 SGETransaction32_t *pTrans;
1155 SGESimple64_t *pSimple;
1156 struct sk_buff *skb;
1157 dma_addr_t dma;
1158 u32 curr, buckets, count, max;
1159 u32 len = (dev->mtu + dev->hard_header_len + 4);
1160 unsigned long flags;
1161 int i;
1162
1163 curr = atomic_read(&priv->buckets_out);
1164 buckets = (priv->max_buckets_out - curr);
1165
1166 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
1167 IOC_AND_NETDEV_NAMES_s_s(dev),
1168 __func__, buckets, curr));
1169
1170 max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
1171 (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
1172
1173 while (buckets) {
1174 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
1175 if (mf == NULL) {
1176 printk (KERN_ERR "%s: Unable to alloc request frame\n",
1177 __func__);
1178 dioprintk((KERN_ERR "%s: %u buckets remaining\n",
1179 __func__, buckets));
1180 goto out;
1181 }
1182 pRecvReq = (LANReceivePostRequest_t *) mf;
1183
1184 i = le16_to_cpu(mf->u.frame.hwhdr.msgctxu.fld.req_idx);
1185 mpt_dev->RequestNB[i] = 0;
1186 count = buckets;
1187 if (count > max)
1188 count = max;
1189
1190 pRecvReq->Function = MPI_FUNCTION_LAN_RECEIVE;
1191 pRecvReq->ChainOffset = 0;
1192 pRecvReq->MsgFlags = 0;
1193 pRecvReq->PortNumber = priv->pnum;
1194
1195 pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
1196 pSimple = NULL;
1197
1198 for (i = 0; i < count; i++) {
1199 int ctx;
1200
1201 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1202 if (priv->mpt_rxfidx_tail < 0) {
1203 printk (KERN_ERR "%s: Can't alloc context\n",
1204 __func__);
1205 spin_unlock_irqrestore(&priv->rxfidx_lock,
1206 flags);
1207 break;
1208 }
1209
1210 ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
1211
1212 skb = priv->RcvCtl[ctx].skb;
1213 if (skb && (priv->RcvCtl[ctx].len != len)) {
1214 pci_unmap_single(mpt_dev->pcidev,
1215 priv->RcvCtl[ctx].dma,
1216 priv->RcvCtl[ctx].len,
1217 PCI_DMA_FROMDEVICE);
1218 dev_kfree_skb(priv->RcvCtl[ctx].skb);
1219 skb = priv->RcvCtl[ctx].skb = NULL;
1220 }
1221
1222 if (skb == NULL) {
1223 skb = dev_alloc_skb(len);
1224 if (skb == NULL) {
1225 printk (KERN_WARNING
1226 MYNAM "/%s: Can't alloc skb\n",
1227 __func__);
1228 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1229 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1230 break;
1231 }
1232
1233 dma = pci_map_single(mpt_dev->pcidev, skb->data,
1234 len, PCI_DMA_FROMDEVICE);
1235
1236 priv->RcvCtl[ctx].skb = skb;
1237 priv->RcvCtl[ctx].dma = dma;
1238 priv->RcvCtl[ctx].len = len;
1239 }
1240
1241 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1242
1243 pTrans->ContextSize = sizeof(u32);
1244 pTrans->DetailsLength = 0;
1245 pTrans->Flags = 0;
1246 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
1247
1248 pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
1249
1250 pSimple->FlagsLength = cpu_to_le32(
1251 ((MPI_SGE_FLAGS_END_OF_BUFFER |
1252 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1253 MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
1254 pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
1255 if (sizeof(dma_addr_t) > sizeof(u32))
1256 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
1257 else
1258 pSimple->Address.High = 0;
1259
1260 pTrans = (SGETransaction32_t *) (pSimple + 1);
1261 }
1262
1263 if (pSimple == NULL) {
1264 printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
1265 __func__);
1266 mpt_free_msg_frame(mpt_dev, mf);
1267 goto out;
1268 }
1269
1270 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
1271
1272 pRecvReq->BucketCount = cpu_to_le32(i);
1273
1274
1275
1276
1277
1278
1279
1280 mpt_put_msg_frame(LanCtx, mpt_dev, mf);
1281
1282 priv->total_posted += i;
1283 buckets -= i;
1284 atomic_add(i, &priv->buckets_out);
1285 }
1286
1287out:
1288 dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
1289 __func__, buckets, atomic_read(&priv->buckets_out)));
1290 dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
1291 __func__, priv->total_posted, priv->total_received));
1292
1293 clear_bit(0, &priv->post_buckets_active);
1294}
1295
1296static void
1297mpt_lan_post_receive_buckets_work(struct work_struct *work)
1298{
1299 mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
1300 post_buckets_task.work));
1301}
1302
1303static const struct net_device_ops mpt_netdev_ops = {
1304 .ndo_open = mpt_lan_open,
1305 .ndo_stop = mpt_lan_close,
1306 .ndo_start_xmit = mpt_lan_sdu_send,
1307 .ndo_change_mtu = mpt_lan_change_mtu,
1308 .ndo_tx_timeout = mpt_lan_tx_timeout,
1309};
1310
1311
1312static struct net_device *
1313mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1314{
1315 struct net_device *dev;
1316 struct mpt_lan_priv *priv;
1317 u8 HWaddr[FC_ALEN], *a;
1318
1319 dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1320 if (!dev)
1321 return NULL;
1322
1323 dev->mtu = MPT_LAN_MTU;
1324
1325 priv = netdev_priv(dev);
1326
1327 priv->dev = dev;
1328 priv->mpt_dev = mpt_dev;
1329 priv->pnum = pnum;
1330
1331 INIT_DELAYED_WORK(&priv->post_buckets_task,
1332 mpt_lan_post_receive_buckets_work);
1333 priv->post_buckets_active = 0;
1334
1335 dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
1336 __LINE__, dev->mtu + dev->hard_header_len + 4));
1337
1338 atomic_set(&priv->buckets_out, 0);
1339 priv->total_posted = 0;
1340 priv->total_received = 0;
1341 priv->max_buckets_out = max_buckets_out;
1342 if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
1343 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
1344
1345 dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n",
1346 __LINE__,
1347 mpt_dev->pfacts[0].MaxLanBuckets,
1348 max_buckets_out,
1349 priv->max_buckets_out));
1350
1351 priv->bucketthresh = priv->max_buckets_out * 2 / 3;
1352 spin_lock_init(&priv->txfidx_lock);
1353 spin_lock_init(&priv->rxfidx_lock);
1354
1355
1356 a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
1357
1358 HWaddr[0] = a[5];
1359 HWaddr[1] = a[4];
1360 HWaddr[2] = a[3];
1361 HWaddr[3] = a[2];
1362 HWaddr[4] = a[1];
1363 HWaddr[5] = a[0];
1364
1365 dev->addr_len = FC_ALEN;
1366 memcpy(dev->dev_addr, HWaddr, FC_ALEN);
1367 memset(dev->broadcast, 0xff, FC_ALEN);
1368
1369
1370
1371
1372 priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
1373 tx_max_out_p : MPT_TX_MAX_OUT_LIM;
1374
1375 dev->netdev_ops = &mpt_netdev_ops;
1376 dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
1377
1378 dlprintk((KERN_INFO MYNAM ": Finished registering dev "
1379 "and setting initial values\n"));
1380
1381 if (register_netdev(dev) != 0) {
1382 free_netdev(dev);
1383 dev = NULL;
1384 }
1385 return dev;
1386}
1387
1388static int
1389mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1390{
1391 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1392 struct net_device *dev;
1393 int i;
1394
1395 for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1396 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1397 "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1398 ioc->name, ioc->pfacts[i].PortNumber,
1399 ioc->pfacts[i].ProtocolFlags,
1400 MPT_PROTOCOL_FLAGS_c_c_c_c(
1401 ioc->pfacts[i].ProtocolFlags));
1402
1403 if (!(ioc->pfacts[i].ProtocolFlags &
1404 MPI_PORTFACTS_PROTOCOL_LAN)) {
1405 printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1406 "seems to be disabled on this adapter port!\n",
1407 ioc->name);
1408 continue;
1409 }
1410
1411 dev = mpt_register_lan_device(ioc, i);
1412 if (!dev) {
1413 printk(KERN_ERR MYNAM ": %s: Unable to register "
1414 "port%d as a LAN device\n", ioc->name,
1415 ioc->pfacts[i].PortNumber);
1416 continue;
1417 }
1418
1419 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1420 "registered as '%s'\n", ioc->name, dev->name);
1421 printk(KERN_INFO MYNAM ": %s/%s: "
1422 "LanAddr = %pM\n",
1423 IOC_AND_NETDEV_NAMES_s_s(dev),
1424 dev->dev_addr);
1425
1426 ioc->netdev = dev;
1427
1428 return 0;
1429 }
1430
1431 return -ENODEV;
1432}
1433
1434static void
1435mptlan_remove(struct pci_dev *pdev)
1436{
1437 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1438 struct net_device *dev = ioc->netdev;
1439
1440 if(dev != NULL) {
1441 unregister_netdev(dev);
1442 free_netdev(dev);
1443 }
1444}
1445
1446static struct mpt_pci_driver mptlan_driver = {
1447 .probe = mptlan_probe,
1448 .remove = mptlan_remove,
1449};
1450
1451static int __init mpt_lan_init (void)
1452{
1453 show_mptmod_ver(LANAME, LANVER);
1454
1455 LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER,
1456 "lan_reply");
1457 if (LanCtx <= 0) {
1458 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1459 return -EBUSY;
1460 }
1461
1462 dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1463
1464 if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1465 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1466 "handler with mptbase! The world is at an end! "
1467 "Everything is fading to black! Goodbye.\n");
1468 return -EBUSY;
1469 }
1470
1471 dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1472
1473 mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER);
1474 return 0;
1475}
1476
1477static void __exit mpt_lan_exit(void)
1478{
1479 mpt_device_driver_deregister(MPTLAN_DRIVER);
1480 mpt_reset_deregister(LanCtx);
1481
1482 if (LanCtx) {
1483 mpt_deregister(LanCtx);
1484 LanCtx = MPT_MAX_PROTOCOL_DRIVERS;
1485 }
1486}
1487
1488module_init(mpt_lan_init);
1489module_exit(mpt_lan_exit);
1490
1491
1492static unsigned short
1493mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1494{
1495 struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1496 struct fcllc *fcllc;
1497
1498 skb_reset_mac_header(skb);
1499 skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1500
1501 if (fch->dtype == htons(0xffff)) {
1502 u32 *p = (u32 *) fch;
1503
1504 swab32s(p + 0);
1505 swab32s(p + 1);
1506 swab32s(p + 2);
1507 swab32s(p + 3);
1508
1509 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1510 NETDEV_PTR_TO_IOC_NAME_s(dev));
1511 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %pM\n",
1512 fch->saddr);
1513 }
1514
1515 if (*fch->daddr & 1) {
1516 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1517 skb->pkt_type = PACKET_BROADCAST;
1518 } else {
1519 skb->pkt_type = PACKET_MULTICAST;
1520 }
1521 } else {
1522 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1523 skb->pkt_type = PACKET_OTHERHOST;
1524 } else {
1525 skb->pkt_type = PACKET_HOST;
1526 }
1527 }
1528
1529 fcllc = (struct fcllc *)skb->data;
1530
1531
1532
1533
1534 if (fcllc->dsap == EXTENDED_SAP &&
1535 (fcllc->ethertype == htons(ETH_P_IP) ||
1536 fcllc->ethertype == htons(ETH_P_ARP))) {
1537 skb_pull(skb, sizeof(struct fcllc));
1538 return fcllc->ethertype;
1539 }
1540
1541 return htons(ETH_P_802_2);
1542}
1543
1544
1545