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