[SCSI] fusion - bump version - 3.04.04
[linux-2.6.git] / drivers / message / fusion / mptlan.c
1 /*
2  *  linux/drivers/message/fusion/mptlan.c
3  *      IP Over Fibre Channel device driver.
4  *      For use with LSI Logic Fibre Channel PCI chip/adapters
5  *      running LSI Logic Fusion MPT (Message Passing Technology) firmware.
6  *
7  *  Copyright (c) 2000-2007 LSI Logic Corporation
8  *  (mailto:mpt_linux_developer@lsi.com)
9  *
10  */
11 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
12 /*
13     This program is free software; you can redistribute it and/or modify
14     it under the terms of the GNU General Public License as published by
15     the Free Software Foundation; version 2 of the License.
16
17     This program is distributed in the hope that it will be useful,
18     but WITHOUT ANY WARRANTY; without even the implied warranty of
19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20     GNU General Public License for more details.
21
22     NO WARRANTY
23     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
24     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
25     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
26     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
27     solely responsible for determining the appropriateness of using and
28     distributing the Program and assumes all risks associated with its
29     exercise of rights under this Agreement, including but not limited to
30     the risks and costs of program errors, damage to or loss of data,
31     programs or equipment, and unavailability or interruption of operations.
32
33     DISCLAIMER OF LIABILITY
34     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
35     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
37     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
38     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
39     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
40     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
41
42     You should have received a copy of the GNU General Public License
43     along with this program; if not, write to the Free Software
44     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
45 */
46
47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
48 /*
49  * Define statements used for debugging
50  */
51 //#define MPT_LAN_IO_DEBUG
52
53 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
54
55 #include "mptlan.h"
56 #include <linux/init.h>
57 #include <linux/module.h>
58 #include <linux/fs.h>
59
60 #define my_VERSION      MPT_LINUX_VERSION_COMMON
61 #define MYNAM           "mptlan"
62
63 MODULE_LICENSE("GPL");
64 MODULE_VERSION(my_VERSION);
65
66 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
67 /*
68  * MPT LAN message sizes without variable part.
69  */
70 #define MPT_LAN_RECEIVE_POST_REQUEST_SIZE \
71         (sizeof(LANReceivePostRequest_t) - sizeof(SGE_MPI_UNION))
72
73 #define MPT_LAN_TRANSACTION32_SIZE \
74         (sizeof(SGETransaction32_t) - sizeof(u32))
75
76 /*
77  *  Fusion MPT LAN private structures
78  */
79
80 struct NAA_Hosed {
81         u16 NAA;
82         u8 ieee[FC_ALEN];
83         struct NAA_Hosed *next;
84 };
85
86 struct BufferControl {
87         struct sk_buff  *skb;
88         dma_addr_t      dma;
89         unsigned int    len;
90 };
91
92 struct mpt_lan_priv {
93         MPT_ADAPTER *mpt_dev;
94         u8 pnum; /* Port number in the IOC. This is not a Unix network port! */
95
96         atomic_t buckets_out;           /* number of unused buckets on IOC */
97         int bucketthresh;               /* Send more when this many left */
98
99         int *mpt_txfidx; /* Free Tx Context list */
100         int mpt_txfidx_tail;
101         spinlock_t txfidx_lock;
102
103         int *mpt_rxfidx; /* Free Rx Context list */
104         int mpt_rxfidx_tail;
105         spinlock_t rxfidx_lock;
106
107         struct BufferControl *RcvCtl;   /* Receive BufferControl structs */
108         struct BufferControl *SendCtl;  /* Send BufferControl structs */
109
110         int max_buckets_out;            /* Max buckets to send to IOC */
111         int tx_max_out;                 /* IOC's Tx queue len */
112
113         u32 total_posted;
114         u32 total_received;
115         struct net_device_stats stats;  /* Per device statistics */
116
117         struct delayed_work post_buckets_task;
118         struct net_device *dev;
119         unsigned long post_buckets_active;
120 };
121
122 struct mpt_lan_ohdr {
123         u16     dtype;
124         u8      daddr[FC_ALEN];
125         u16     stype;
126         u8      saddr[FC_ALEN];
127 };
128
129 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
130
131 /*
132  *  Forward protos...
133  */
134 static int  lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
135                        MPT_FRAME_HDR *reply);
136 static int  mpt_lan_open(struct net_device *dev);
137 static int  mpt_lan_reset(struct net_device *dev);
138 static int  mpt_lan_close(struct net_device *dev);
139 static void mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv);
140 static void mpt_lan_wake_post_buckets_task(struct net_device *dev,
141                                            int priority);
142 static int  mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg);
143 static int  mpt_lan_receive_post_reply(struct net_device *dev,
144                                        LANReceivePostReply_t *pRecvRep);
145 static int  mpt_lan_send_turbo(struct net_device *dev, u32 tmsg);
146 static int  mpt_lan_send_reply(struct net_device *dev,
147                                LANSendReply_t *pSendRep);
148 static int  mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
149 static int  mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
150 static unsigned short mpt_lan_type_trans(struct sk_buff *skb,
151                                          struct net_device *dev);
152
153 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
154 /*
155  *  Fusion MPT LAN private data
156  */
157 static int LanCtx = -1;
158
159 static u32 max_buckets_out = 127;
160 static u32 tx_max_out_p = 127 - 16;
161
162 #ifdef QLOGIC_NAA_WORKAROUND
163 static struct NAA_Hosed *mpt_bad_naa = NULL;
164 DEFINE_RWLOCK(bad_naa_lock);
165 #endif
166
167 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
168 /*
169  * Fusion MPT LAN external data
170  */
171 extern int mpt_lan_index;
172
173 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
174 /**
175  *      lan_reply - Handle all data sent from the hardware.
176  *      @ioc: Pointer to MPT_ADAPTER structure
177  *      @mf: Pointer to original MPT request frame (NULL if TurboReply)
178  *      @reply: Pointer to MPT reply frame
179  *
180  *      Returns 1 indicating original alloc'd request frame ptr
181  *      should be freed, or 0 if it shouldn't.
182  */
183 static int
184 lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
185 {
186         struct net_device *dev = ioc->netdev;
187         int FreeReqFrame = 0;
188
189         dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.\n",
190                   IOC_AND_NETDEV_NAMES_s_s(dev)));
191
192 //      dioprintk((KERN_INFO MYNAM "@lan_reply: mf = %p, reply = %p\n",
193 //                      mf, reply));
194
195         if (mf == NULL) {
196                 u32 tmsg = CAST_PTR_TO_U32(reply);
197
198                 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
199                                 IOC_AND_NETDEV_NAMES_s_s(dev),
200                                 tmsg));
201
202                 switch (GET_LAN_FORM(tmsg)) {
203
204                 // NOTE!  (Optimization) First case here is now caught in
205                 //  mptbase.c::mpt_interrupt() routine and callcack here
206                 //  is now skipped for this case!
207 #if 0
208                 case LAN_REPLY_FORM_MESSAGE_CONTEXT:
209 //                      dioprintk((KERN_INFO MYNAM "/lan_reply: "
210 //                                "MessageContext turbo reply received\n"));
211                         FreeReqFrame = 1;
212                         break;
213 #endif
214
215                 case LAN_REPLY_FORM_SEND_SINGLE:
216 //                      dioprintk((MYNAM "/lan_reply: "
217 //                                "calling mpt_lan_send_reply (turbo)\n"));
218
219                         // Potential BUG here?
220                         //      FreeReqFrame = mpt_lan_send_turbo(dev, tmsg);
221                         //  If/when mpt_lan_send_turbo would return 1 here,
222                         //  calling routine (mptbase.c|mpt_interrupt)
223                         //  would Oops because mf has already been set
224                         //  to NULL.  So after return from this func,
225                         //  mpt_interrupt() will attempt to put (NULL) mf ptr
226                         //  item back onto its adapter FreeQ - Oops!:-(
227                         //  It's Ok, since mpt_lan_send_turbo() *currently*
228                         //  always returns 0, but..., just in case:
229
230                         (void) mpt_lan_send_turbo(dev, tmsg);
231                         FreeReqFrame = 0;
232
233                         break;
234
235                 case LAN_REPLY_FORM_RECEIVE_SINGLE:
236 //                      dioprintk((KERN_INFO MYNAM "@lan_reply: "
237 //                                "rcv-Turbo = %08x\n", tmsg));
238                         mpt_lan_receive_post_turbo(dev, tmsg);
239                         break;
240
241                 default:
242                         printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply "
243                                 "that I don't know what to do with\n");
244
245                         /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
246
247                         break;
248                 }
249
250                 return FreeReqFrame;
251         }
252
253 //      msg = (u32 *) reply;
254 //      dioprintk((KERN_INFO MYNAM "@lan_reply: msg = %08x %08x %08x %08x\n",
255 //                le32_to_cpu(msg[0]), le32_to_cpu(msg[1]),
256 //                le32_to_cpu(msg[2]), le32_to_cpu(msg[3])));
257 //      dioprintk((KERN_INFO MYNAM "@lan_reply: Function = %02xh\n",
258 //                reply->u.hdr.Function));
259
260         switch (reply->u.hdr.Function) {
261
262         case MPI_FUNCTION_LAN_SEND:
263         {
264                 LANSendReply_t *pSendRep;
265
266                 pSendRep = (LANSendReply_t *) reply;
267                 FreeReqFrame = mpt_lan_send_reply(dev, pSendRep);
268                 break;
269         }
270
271         case MPI_FUNCTION_LAN_RECEIVE:
272         {
273                 LANReceivePostReply_t *pRecvRep;
274
275                 pRecvRep = (LANReceivePostReply_t *) reply;
276                 if (pRecvRep->NumberOfContexts) {
277                         mpt_lan_receive_post_reply(dev, pRecvRep);
278                         if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
279                                 FreeReqFrame = 1;
280                 } else
281                         dioprintk((KERN_INFO MYNAM "@lan_reply: zero context "
282                                   "ReceivePostReply received.\n"));
283                 break;
284         }
285
286         case MPI_FUNCTION_LAN_RESET:
287                 /* Just a default reply. Might want to check it to
288                  * make sure that everything went ok.
289                  */
290                 FreeReqFrame = 1;
291                 break;
292
293         case MPI_FUNCTION_EVENT_NOTIFICATION:
294         case MPI_FUNCTION_EVENT_ACK:
295                 /*  _EVENT_NOTIFICATION should NOT come down this path any more.
296                  *  Should be routed to mpt_lan_event_process(), but just in case...
297                  */
298                 FreeReqFrame = 1;
299                 break;
300
301         default:
302                 printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo "
303                         "reply that I don't know what to do with\n");
304
305                 /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
306                 FreeReqFrame = 1;
307
308                 break;
309         }
310
311         return FreeReqFrame;
312 }
313
314 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
315 static int
316 mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
317 {
318         struct net_device *dev = ioc->netdev;
319         struct mpt_lan_priv *priv;
320
321         if (dev == NULL)
322                 return(1);
323         else
324                 priv = netdev_priv(dev);
325
326         dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!\n",
327                         reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
328                         reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
329
330         if (priv->mpt_rxfidx == NULL)
331                 return (1);
332
333         if (reset_phase == MPT_IOC_SETUP_RESET) {
334                 ;
335         } else if (reset_phase == MPT_IOC_PRE_RESET) {
336                 int i;
337                 unsigned long flags;
338
339                 netif_stop_queue(dev);
340
341                 dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.\n", dev->name));
342
343                 atomic_set(&priv->buckets_out, 0);
344
345                 /* Reset Rx Free Tail index and re-populate the queue. */
346                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
347                 priv->mpt_rxfidx_tail = -1;
348                 for (i = 0; i < priv->max_buckets_out; i++)
349                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
350                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
351         } else {
352                 mpt_lan_post_receive_buckets(priv);
353                 netif_wake_queue(dev);
354         }
355
356         return 1;
357 }
358
359 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
360 static int
361 mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
362 {
363         dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!\n"));
364
365         switch (le32_to_cpu(pEvReply->Event)) {
366         case MPI_EVENT_NONE:                            /* 00 */
367         case MPI_EVENT_LOG_DATA:                        /* 01 */
368         case MPI_EVENT_STATE_CHANGE:                    /* 02 */
369         case MPI_EVENT_UNIT_ATTENTION:                  /* 03 */
370         case MPI_EVENT_IOC_BUS_RESET:                   /* 04 */
371         case MPI_EVENT_EXT_BUS_RESET:                   /* 05 */
372         case MPI_EVENT_RESCAN:                          /* 06 */
373                 /* Ok, do we need to do anything here? As far as
374                    I can tell, this is when a new device gets added
375                    to the loop. */
376         case MPI_EVENT_LINK_STATUS_CHANGE:              /* 07 */
377         case MPI_EVENT_LOOP_STATE_CHANGE:               /* 08 */
378         case MPI_EVENT_LOGOUT:                          /* 09 */
379         case MPI_EVENT_EVENT_CHANGE:                    /* 0A */
380         default:
381                 break;
382         }
383
384         /*
385          *  NOTE: pEvent->AckRequired handling now done in mptbase.c;
386          *  Do NOT do it here now!
387          */
388
389         return 1;
390 }
391
392 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
393 static int
394 mpt_lan_open(struct net_device *dev)
395 {
396         struct mpt_lan_priv *priv = netdev_priv(dev);
397         int i;
398
399         if (mpt_lan_reset(dev) != 0) {
400                 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
401
402                 printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed.");
403
404                 if (mpt_dev->active)
405                         printk ("The ioc is active. Perhaps it needs to be"
406                                 " reset?\n");
407                 else
408                         printk ("The ioc in inactive, most likely in the "
409                                 "process of being reset. Please try again in "
410                                 "a moment.\n");
411         }
412
413         priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL);
414         if (priv->mpt_txfidx == NULL)
415                 goto out;
416         priv->mpt_txfidx_tail = -1;
417
418         priv->SendCtl = kcalloc(priv->tx_max_out, sizeof(struct BufferControl),
419                                 GFP_KERNEL);
420         if (priv->SendCtl == NULL)
421                 goto out_mpt_txfidx;
422         for (i = 0; i < priv->tx_max_out; i++)
423                 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
424
425         dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
426
427         priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int),
428                                    GFP_KERNEL);
429         if (priv->mpt_rxfidx == NULL)
430                 goto out_SendCtl;
431         priv->mpt_rxfidx_tail = -1;
432
433         priv->RcvCtl = kcalloc(priv->max_buckets_out,
434                                sizeof(struct BufferControl),
435                                GFP_KERNEL);
436         if (priv->RcvCtl == NULL)
437                 goto out_mpt_rxfidx;
438         for (i = 0; i < priv->max_buckets_out; i++)
439                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
440
441 /**/    dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - "));
442 /**/    for (i = 0; i < priv->tx_max_out; i++)
443 /**/            dlprintk((" %xh", priv->mpt_txfidx[i]));
444 /**/    dlprintk(("\n"));
445
446         dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n"));
447
448         mpt_lan_post_receive_buckets(priv);
449         printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n",
450                         IOC_AND_NETDEV_NAMES_s_s(dev));
451
452         if (mpt_event_register(LanCtx, mpt_lan_event_process) != 0) {
453                 printk (KERN_WARNING MYNAM "/lo: Unable to register for Event"
454                         " Notifications. This is a bad thing! We're not going "
455                         "to go ahead, but I'd be leery of system stability at "
456                         "this point.\n");
457         }
458
459         netif_start_queue(dev);
460         dlprintk((KERN_INFO MYNAM "/lo: Done.\n"));
461
462         return 0;
463 out_mpt_rxfidx:
464         kfree(priv->mpt_rxfidx);
465         priv->mpt_rxfidx = NULL;
466 out_SendCtl:
467         kfree(priv->SendCtl);
468         priv->SendCtl = NULL;
469 out_mpt_txfidx:
470         kfree(priv->mpt_txfidx);
471         priv->mpt_txfidx = NULL;
472 out:    return -ENOMEM;
473 }
474
475 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
476 /* Send a LanReset message to the FW. This should result in the FW returning
477    any buckets it still has. */
478 static int
479 mpt_lan_reset(struct net_device *dev)
480 {
481         MPT_FRAME_HDR *mf;
482         LANResetRequest_t *pResetReq;
483         struct mpt_lan_priv *priv = netdev_priv(dev);
484
485         mf = mpt_get_msg_frame(LanCtx, priv->mpt_dev);
486
487         if (mf == NULL) {
488 /*              dlprintk((KERN_ERR MYNAM "/reset: Evil funkiness abounds! "
489                 "Unable to allocate a request frame.\n"));
490 */
491                 return -1;
492         }
493
494         pResetReq = (LANResetRequest_t *) mf;
495
496         pResetReq->Function     = MPI_FUNCTION_LAN_RESET;
497         pResetReq->ChainOffset  = 0;
498         pResetReq->Reserved     = 0;
499         pResetReq->PortNumber   = priv->pnum;
500         pResetReq->MsgFlags     = 0;
501         pResetReq->Reserved2    = 0;
502
503         mpt_put_msg_frame(LanCtx, priv->mpt_dev, mf);
504
505         return 0;
506 }
507
508 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
509 static int
510 mpt_lan_close(struct net_device *dev)
511 {
512         struct mpt_lan_priv *priv = netdev_priv(dev);
513         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
514         unsigned long timeout;
515         int i;
516
517         dlprintk((KERN_INFO MYNAM ": mpt_lan_close called\n"));
518
519         mpt_event_deregister(LanCtx);
520
521         dlprintk((KERN_INFO MYNAM ":lan_close: Posted %d buckets "
522                   "since driver was loaded, %d still out\n",
523                   priv->total_posted,atomic_read(&priv->buckets_out)));
524
525         netif_stop_queue(dev);
526
527         mpt_lan_reset(dev);
528
529         timeout = jiffies + 2 * HZ;
530         while (atomic_read(&priv->buckets_out) && time_before(jiffies, timeout))
531                 schedule_timeout_interruptible(1);
532
533         for (i = 0; i < priv->max_buckets_out; i++) {
534                 if (priv->RcvCtl[i].skb != NULL) {
535 /**/                    dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
536 /**/                              "is still out\n", i));
537                         pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma,
538                                          priv->RcvCtl[i].len,
539                                          PCI_DMA_FROMDEVICE);
540                         dev_kfree_skb(priv->RcvCtl[i].skb);
541                 }
542         }
543
544         kfree(priv->RcvCtl);
545         kfree(priv->mpt_rxfidx);
546
547         for (i = 0; i < priv->tx_max_out; i++) {
548                 if (priv->SendCtl[i].skb != NULL) {
549                         pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma,
550                                          priv->SendCtl[i].len,
551                                          PCI_DMA_TODEVICE);
552                         dev_kfree_skb(priv->SendCtl[i].skb);
553                 }
554         }
555
556         kfree(priv->SendCtl);
557         kfree(priv->mpt_txfidx);
558
559         atomic_set(&priv->buckets_out, 0);
560
561         printk(KERN_INFO MYNAM ": %s/%s: interface down & inactive\n",
562                         IOC_AND_NETDEV_NAMES_s_s(dev));
563
564         return 0;
565 }
566
567 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
568 static struct net_device_stats *
569 mpt_lan_get_stats(struct net_device *dev)
570 {
571         struct mpt_lan_priv *priv = netdev_priv(dev);
572
573         return (struct net_device_stats *) &priv->stats;
574 }
575
576 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
577 static int
578 mpt_lan_change_mtu(struct net_device *dev, int new_mtu)
579 {
580         if ((new_mtu < MPT_LAN_MIN_MTU) || (new_mtu > MPT_LAN_MAX_MTU))
581                 return -EINVAL;
582         dev->mtu = new_mtu;
583         return 0;
584 }
585
586 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
587 /* Tx timeout handler. */
588 static void
589 mpt_lan_tx_timeout(struct net_device *dev)
590 {
591         struct mpt_lan_priv *priv = netdev_priv(dev);
592         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
593
594         if (mpt_dev->active) {
595                 dlprintk (("mptlan/tx_timeout: calling netif_wake_queue for %s.\n", dev->name));
596                 netif_wake_queue(dev);
597         }
598 }
599
600 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
601 //static inline int
602 static int
603 mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
604 {
605         struct mpt_lan_priv *priv = netdev_priv(dev);
606         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
607         struct sk_buff *sent;
608         unsigned long flags;
609         u32 ctx;
610
611         ctx = GET_LAN_BUFFER_CONTEXT(tmsg);
612         sent = priv->SendCtl[ctx].skb;
613
614         priv->stats.tx_packets++;
615         priv->stats.tx_bytes += sent->len;
616
617         dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
618                         IOC_AND_NETDEV_NAMES_s_s(dev),
619                         __FUNCTION__, sent));
620
621         priv->SendCtl[ctx].skb = NULL;
622         pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
623                          priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
624         dev_kfree_skb_irq(sent);
625
626         spin_lock_irqsave(&priv->txfidx_lock, flags);
627         priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
628         spin_unlock_irqrestore(&priv->txfidx_lock, flags);
629
630         netif_wake_queue(dev);
631         return 0;
632 }
633
634 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
635 static int
636 mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
637 {
638         struct mpt_lan_priv *priv = netdev_priv(dev);
639         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
640         struct sk_buff *sent;
641         unsigned long flags;
642         int FreeReqFrame = 0;
643         u32 *pContext;
644         u32 ctx;
645         u8 count;
646
647         count = pSendRep->NumberOfContexts;
648
649         dioprintk((KERN_INFO MYNAM ": send_reply: IOCStatus: %04x\n",
650                  le16_to_cpu(pSendRep->IOCStatus)));
651
652         /* Add check for Loginfo Flag in IOCStatus */
653
654         switch (le16_to_cpu(pSendRep->IOCStatus) & MPI_IOCSTATUS_MASK) {
655         case MPI_IOCSTATUS_SUCCESS:
656                 priv->stats.tx_packets += count;
657                 break;
658
659         case MPI_IOCSTATUS_LAN_CANCELED:
660         case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED:
661                 break;
662
663         case MPI_IOCSTATUS_INVALID_SGL:
664                 priv->stats.tx_errors += count;
665                 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Invalid SGL sent to IOC!\n",
666                                 IOC_AND_NETDEV_NAMES_s_s(dev));
667                 goto out;
668
669         default:
670                 priv->stats.tx_errors += count;
671                 break;
672         }
673
674         pContext = &pSendRep->BufferContext;
675
676         spin_lock_irqsave(&priv->txfidx_lock, flags);
677         while (count > 0) {
678                 ctx = GET_LAN_BUFFER_CONTEXT(le32_to_cpu(*pContext));
679
680                 sent = priv->SendCtl[ctx].skb;
681                 priv->stats.tx_bytes += sent->len;
682
683                 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
684                                 IOC_AND_NETDEV_NAMES_s_s(dev),
685                                 __FUNCTION__, sent));
686
687                 priv->SendCtl[ctx].skb = NULL;
688                 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
689                                  priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
690                 dev_kfree_skb_irq(sent);
691
692                 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
693
694                 pContext++;
695                 count--;
696         }
697         spin_unlock_irqrestore(&priv->txfidx_lock, flags);
698
699 out:
700         if (!(pSendRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
701                 FreeReqFrame = 1;
702
703         netif_wake_queue(dev);
704         return FreeReqFrame;
705 }
706
707 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
708 static int
709 mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
710 {
711         struct mpt_lan_priv *priv = netdev_priv(dev);
712         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
713         MPT_FRAME_HDR *mf;
714         LANSendRequest_t *pSendReq;
715         SGETransaction32_t *pTrans;
716         SGESimple64_t *pSimple;
717         dma_addr_t dma;
718         unsigned long flags;
719         int ctx;
720         u16 cur_naa = 0x1000;
721
722         dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
723                         __FUNCTION__, skb));
724
725         spin_lock_irqsave(&priv->txfidx_lock, flags);
726         if (priv->mpt_txfidx_tail < 0) {
727                 netif_stop_queue(dev);
728                 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
729
730                 printk (KERN_ERR "%s: no tx context available: %u\n",
731                         __FUNCTION__, priv->mpt_txfidx_tail);
732                 return 1;
733         }
734
735         mf = mpt_get_msg_frame(LanCtx, mpt_dev);
736         if (mf == NULL) {
737                 netif_stop_queue(dev);
738                 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
739
740                 printk (KERN_ERR "%s: Unable to alloc request frame\n",
741                         __FUNCTION__);
742                 return 1;
743         }
744
745         ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
746         spin_unlock_irqrestore(&priv->txfidx_lock, flags);
747
748 //      dioprintk((KERN_INFO MYNAM ": %s/%s: Creating new msg frame (send).\n",
749 //                      IOC_AND_NETDEV_NAMES_s_s(dev)));
750
751         pSendReq = (LANSendRequest_t *) mf;
752
753         /* Set the mac.raw pointer, since this apparently isn't getting
754          * done before we get the skb. Pull the data pointer past the mac data.
755          */
756         skb->mac.raw = skb->data;
757         skb_pull(skb, 12);
758
759         dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
760                              PCI_DMA_TODEVICE);
761
762         priv->SendCtl[ctx].skb = skb;
763         priv->SendCtl[ctx].dma = dma;
764         priv->SendCtl[ctx].len = skb->len;
765
766         /* Message Header */
767         pSendReq->Reserved    = 0;
768         pSendReq->Function    = MPI_FUNCTION_LAN_SEND;
769         pSendReq->ChainOffset = 0;
770         pSendReq->Reserved2   = 0;
771         pSendReq->MsgFlags    = 0;
772         pSendReq->PortNumber  = priv->pnum;
773
774         /* Transaction Context Element */
775         pTrans = (SGETransaction32_t *) pSendReq->SG_List;
776
777         /* No Flags, 8 bytes of Details, 32bit Context (bloody turbo replies) */
778         pTrans->ContextSize   = sizeof(u32);
779         pTrans->DetailsLength = 2 * sizeof(u32);
780         pTrans->Flags         = 0;
781         pTrans->TransactionContext[0] = cpu_to_le32(ctx);
782
783 //      dioprintk((KERN_INFO MYNAM ": %s/%s: BC = %08x, skb = %p, buff = %p\n",
784 //                      IOC_AND_NETDEV_NAMES_s_s(dev),
785 //                      ctx, skb, skb->data));
786
787 #ifdef QLOGIC_NAA_WORKAROUND
788 {
789         struct NAA_Hosed *nh;
790
791         /* Munge the NAA for Tx packets to QLogic boards, which don't follow
792            RFC 2625. The longer I look at this, the more my opinion of Qlogic
793            drops. */
794         read_lock_irq(&bad_naa_lock);
795         for (nh = mpt_bad_naa; nh != NULL; nh=nh->next) {
796                 if ((nh->ieee[0] == skb->mac.raw[0]) &&
797                     (nh->ieee[1] == skb->mac.raw[1]) &&
798                     (nh->ieee[2] == skb->mac.raw[2]) &&
799                     (nh->ieee[3] == skb->mac.raw[3]) &&
800                     (nh->ieee[4] == skb->mac.raw[4]) &&
801                     (nh->ieee[5] == skb->mac.raw[5])) {
802                         cur_naa = nh->NAA;
803                         dlprintk ((KERN_INFO "mptlan/sdu_send: using NAA value "
804                                   "= %04x.\n", cur_naa));
805                         break;
806                 }
807         }
808         read_unlock_irq(&bad_naa_lock);
809 }
810 #endif
811
812         pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa         << 16) |
813                                                     (skb->mac.raw[0] <<  8) |
814                                                     (skb->mac.raw[1] <<  0));
815         pTrans->TransactionDetails[1] = cpu_to_le32((skb->mac.raw[2] << 24) |
816                                                     (skb->mac.raw[3] << 16) |
817                                                     (skb->mac.raw[4] <<  8) |
818                                                     (skb->mac.raw[5] <<  0));
819
820         pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
821
822         /* If we ever decide to send more than one Simple SGE per LANSend, then
823            we will need to make sure that LAST_ELEMENT only gets set on the
824            last one. Otherwise, bad voodoo and evil funkiness will commence. */
825         pSimple->FlagsLength = cpu_to_le32(
826                         ((MPI_SGE_FLAGS_LAST_ELEMENT |
827                           MPI_SGE_FLAGS_END_OF_BUFFER |
828                           MPI_SGE_FLAGS_SIMPLE_ELEMENT |
829                           MPI_SGE_FLAGS_SYSTEM_ADDRESS |
830                           MPI_SGE_FLAGS_HOST_TO_IOC |
831                           MPI_SGE_FLAGS_64_BIT_ADDRESSING |
832                           MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
833                         skb->len);
834         pSimple->Address.Low = cpu_to_le32((u32) dma);
835         if (sizeof(dma_addr_t) > sizeof(u32))
836                 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
837         else
838                 pSimple->Address.High = 0;
839
840         mpt_put_msg_frame (LanCtx, mpt_dev, mf);
841         dev->trans_start = jiffies;
842
843         dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.\n",
844                         IOC_AND_NETDEV_NAMES_s_s(dev),
845                         le32_to_cpu(pSimple->FlagsLength)));
846
847         return 0;
848 }
849
850 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
851 static void
852 mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
853 /*
854  * @priority: 0 = put it on the timer queue, 1 = put it on the immediate queue
855  */
856 {
857         struct mpt_lan_priv *priv = dev->priv;
858         
859         if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
860                 if (priority) {
861                         schedule_delayed_work(&priv->post_buckets_task, 0);
862                 } else {
863                         schedule_delayed_work(&priv->post_buckets_task, 1);
864                         dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
865                                    "timer.\n"));
866                 }
867                 dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.\n",
868                            IOC_AND_NETDEV_NAMES_s_s(dev) ));
869         }
870 }
871
872 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
873 static int
874 mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
875 {
876         struct mpt_lan_priv *priv = dev->priv;
877
878         skb->protocol = mpt_lan_type_trans(skb, dev);
879
880         dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
881                  "delivered to upper level.\n",
882                         IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
883
884         priv->stats.rx_bytes += skb->len;
885         priv->stats.rx_packets++;
886
887         skb->dev = dev;
888         netif_rx(skb);
889
890         dioprintk((MYNAM "/receive_skb: %d buckets remaining\n",
891                  atomic_read(&priv->buckets_out)));
892
893         if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
894                 mpt_lan_wake_post_buckets_task(dev, 1);
895
896         dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
897                   "remaining, %d received back since sod\n",
898                   atomic_read(&priv->buckets_out), priv->total_received));
899
900         return 0;
901 }
902
903 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
904 //static inline int
905 static int
906 mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
907 {
908         struct mpt_lan_priv *priv = dev->priv;
909         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
910         struct sk_buff *skb, *old_skb;
911         unsigned long flags;
912         u32 ctx, len;
913
914         ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
915         skb = priv->RcvCtl[ctx].skb;
916
917         len = GET_LAN_PACKET_LENGTH(tmsg);
918
919         if (len < MPT_LAN_RX_COPYBREAK) {
920                 old_skb = skb;
921
922                 skb = (struct sk_buff *)dev_alloc_skb(len);
923                 if (!skb) {
924                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
925                                         IOC_AND_NETDEV_NAMES_s_s(dev),
926                                         __FILE__, __LINE__);
927                         return -ENOMEM;
928                 }
929
930                 pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
931                                             priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
932
933                 memcpy(skb_put(skb, len), old_skb->data, len);
934
935                 pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
936                                                priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
937                 goto out;
938         }
939
940         skb_put(skb, len);
941
942         priv->RcvCtl[ctx].skb = NULL;
943
944         pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
945                          priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
946
947 out:
948         spin_lock_irqsave(&priv->rxfidx_lock, flags);
949         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
950         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
951
952         atomic_dec(&priv->buckets_out);
953         priv->total_received++;
954
955         return mpt_lan_receive_skb(dev, skb);
956 }
957
958 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
959 static int
960 mpt_lan_receive_post_free(struct net_device *dev,
961                           LANReceivePostReply_t *pRecvRep)
962 {
963         struct mpt_lan_priv *priv = dev->priv;
964         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
965         unsigned long flags;
966         struct sk_buff *skb;
967         u32 ctx;
968         int count;
969         int i;
970
971         count = pRecvRep->NumberOfContexts;
972
973 /**/    dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
974                   "IOC returned %d buckets, freeing them...\n", count));
975
976         spin_lock_irqsave(&priv->rxfidx_lock, flags);
977         for (i = 0; i < count; i++) {
978                 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
979
980                 skb = priv->RcvCtl[ctx].skb;
981
982 //              dlprintk((KERN_INFO MYNAM ": %s: dev_name = %s\n",
983 //                              IOC_AND_NETDEV_NAMES_s_s(dev)));
984 //              dlprintk((KERN_INFO MYNAM "@rpr[2], priv = %p, buckets_out addr = %p",
985 //                              priv, &(priv->buckets_out)));
986 //              dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3\n"));
987
988                 priv->RcvCtl[ctx].skb = NULL;
989                 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
990                                  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
991                 dev_kfree_skb_any(skb);
992
993                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
994         }
995         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
996
997         atomic_sub(count, &priv->buckets_out);
998
999 //      for (i = 0; i < priv->max_buckets_out; i++)
1000 //              if (priv->RcvCtl[i].skb != NULL)
1001 //                      dlprintk((KERN_INFO MYNAM "@rpr: bucket %03x "
1002 //                                "is still out\n", i));
1003
1004 /*      dlprintk((KERN_INFO MYNAM "/receive_post_reply: freed %d buckets\n",
1005                   count));
1006 */
1007 /**/    dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
1008 /**/              "remaining, %d received back since sod.\n",
1009 /**/              atomic_read(&priv->buckets_out), priv->total_received));
1010         return 0;
1011 }
1012
1013 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1014 static int
1015 mpt_lan_receive_post_reply(struct net_device *dev,
1016                            LANReceivePostReply_t *pRecvRep)
1017 {
1018         struct mpt_lan_priv *priv = dev->priv;
1019         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1020         struct sk_buff *skb, *old_skb;
1021         unsigned long flags;
1022         u32 len, ctx, offset;
1023         u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
1024         int count;
1025         int i, l;
1026
1027         dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply called\n"));
1028         dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04x\n",
1029                  le16_to_cpu(pRecvRep->IOCStatus)));
1030
1031         if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
1032                                                 MPI_IOCSTATUS_LAN_CANCELED)
1033                 return mpt_lan_receive_post_free(dev, pRecvRep);
1034
1035         len = le32_to_cpu(pRecvRep->PacketLength);
1036         if (len == 0) {
1037                 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
1038                         "ReceivePostReply w/ PacketLength zero!\n",
1039                                 IOC_AND_NETDEV_NAMES_s_s(dev));
1040                 printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04x\n",
1041                                 pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
1042                 return -1;
1043         }
1044
1045         ctx    = le32_to_cpu(pRecvRep->BucketContext[0]);
1046         count  = pRecvRep->NumberOfContexts;
1047         skb    = priv->RcvCtl[ctx].skb;
1048
1049         offset = le32_to_cpu(pRecvRep->PacketOffset);
1050 //      if (offset != 0) {
1051 //              printk (KERN_INFO MYNAM ": %s/%s: Got a ReceivePostReply "
1052 //                      "w/ PacketOffset %u\n",
1053 //                              IOC_AND_NETDEV_NAMES_s_s(dev),
1054 //                              offset);
1055 //      }
1056
1057         dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %d\n",
1058                         IOC_AND_NETDEV_NAMES_s_s(dev),
1059                         offset, len));
1060
1061         if (count > 1) {
1062                 int szrem = len;
1063
1064 //              dioprintk((KERN_INFO MYNAM ": %s/%s: Multiple buckets returned "
1065 //                      "for single packet, concatenating...\n",
1066 //                              IOC_AND_NETDEV_NAMES_s_s(dev)));
1067
1068                 skb = (struct sk_buff *)dev_alloc_skb(len);
1069                 if (!skb) {
1070                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1071                                         IOC_AND_NETDEV_NAMES_s_s(dev),
1072                                         __FILE__, __LINE__);
1073                         return -ENOMEM;
1074                 }
1075
1076                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1077                 for (i = 0; i < count; i++) {
1078
1079                         ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
1080                         old_skb = priv->RcvCtl[ctx].skb;
1081
1082                         l = priv->RcvCtl[ctx].len;
1083                         if (szrem < l)
1084                                 l = szrem;
1085
1086 //                      dioprintk((KERN_INFO MYNAM ": %s/%s: Buckets = %d, len = %u\n",
1087 //                                      IOC_AND_NETDEV_NAMES_s_s(dev),
1088 //                                      i, l));
1089
1090                         pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1091                                                     priv->RcvCtl[ctx].dma,
1092                                                     priv->RcvCtl[ctx].len,
1093                                                     PCI_DMA_FROMDEVICE);
1094                         memcpy(skb_put(skb, l), old_skb->data, l);
1095
1096                         pci_dma_sync_single_for_device(mpt_dev->pcidev,
1097                                                        priv->RcvCtl[ctx].dma,
1098                                                        priv->RcvCtl[ctx].len,
1099                                                        PCI_DMA_FROMDEVICE);
1100
1101                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1102                         szrem -= l;
1103                 }
1104                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1105
1106         } else if (len < MPT_LAN_RX_COPYBREAK) {
1107
1108                 old_skb = skb;
1109
1110                 skb = (struct sk_buff *)dev_alloc_skb(len);
1111                 if (!skb) {
1112                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1113                                         IOC_AND_NETDEV_NAMES_s_s(dev),
1114                                         __FILE__, __LINE__);
1115                         return -ENOMEM;
1116                 }
1117
1118                 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1119                                             priv->RcvCtl[ctx].dma,
1120                                             priv->RcvCtl[ctx].len,
1121                                             PCI_DMA_FROMDEVICE);
1122
1123                 memcpy(skb_put(skb, len), old_skb->data, len);
1124
1125                 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1126                                                priv->RcvCtl[ctx].dma,
1127                                                priv->RcvCtl[ctx].len,
1128                                                PCI_DMA_FROMDEVICE);
1129
1130                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1131                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1132                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1133
1134         } else {
1135                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1136
1137                 priv->RcvCtl[ctx].skb = NULL;
1138
1139                 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
1140                                  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
1141                 priv->RcvCtl[ctx].dma = 0;
1142
1143                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1144                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1145
1146                 skb_put(skb,len);
1147         }
1148
1149         atomic_sub(count, &priv->buckets_out);
1150         priv->total_received += count;
1151
1152         if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
1153                 printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
1154                         "MPT_LAN_MAX_BUCKETS_OUT = %d\n",
1155                                 IOC_AND_NETDEV_NAMES_s_s(dev),
1156                                 priv->mpt_rxfidx_tail,
1157                                 MPT_LAN_MAX_BUCKETS_OUT);
1158
1159                 return -1;
1160         }
1161
1162         if (remaining == 0)
1163                 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1164                         "(priv->buckets_out = %d)\n",
1165                         IOC_AND_NETDEV_NAMES_s_s(dev),
1166                         atomic_read(&priv->buckets_out));
1167         else if (remaining < 10)
1168                 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1169                         "(priv->buckets_out = %d)\n",
1170                         IOC_AND_NETDEV_NAMES_s_s(dev),
1171                         remaining, atomic_read(&priv->buckets_out));
1172         
1173         if ((remaining < priv->bucketthresh) &&
1174             ((atomic_read(&priv->buckets_out) - remaining) >
1175              MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1176                 
1177                 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1178                         "buckets_out count and fw's BucketsRemaining "
1179                         "count has crossed the threshold, issuing a "
1180                         "LanReset to clear the fw's hashtable. You may "
1181                         "want to check your /var/log/messages for \"CRC "
1182                         "error\" event notifications.\n");
1183                 
1184                 mpt_lan_reset(dev);
1185                 mpt_lan_wake_post_buckets_task(dev, 0);
1186         }
1187         
1188         return mpt_lan_receive_skb(dev, skb);
1189 }
1190
1191 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1192 /* Simple SGE's only at the moment */
1193
1194 static void
1195 mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
1196 {
1197         struct net_device *dev = priv->dev;
1198         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1199         MPT_FRAME_HDR *mf;
1200         LANReceivePostRequest_t *pRecvReq;
1201         SGETransaction32_t *pTrans;
1202         SGESimple64_t *pSimple;
1203         struct sk_buff *skb;
1204         dma_addr_t dma;
1205         u32 curr, buckets, count, max;
1206         u32 len = (dev->mtu + dev->hard_header_len + 4);
1207         unsigned long flags;
1208         int i;
1209
1210         curr = atomic_read(&priv->buckets_out);
1211         buckets = (priv->max_buckets_out - curr);
1212
1213         dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
1214                         IOC_AND_NETDEV_NAMES_s_s(dev),
1215                         __FUNCTION__, buckets, curr));
1216
1217         max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
1218                         (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
1219
1220         while (buckets) {
1221                 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
1222                 if (mf == NULL) {
1223                         printk (KERN_ERR "%s: Unable to alloc request frame\n",
1224                                 __FUNCTION__);
1225                         dioprintk((KERN_ERR "%s: %u buckets remaining\n",
1226                                  __FUNCTION__, buckets));
1227                         goto out;
1228                 }
1229                 pRecvReq = (LANReceivePostRequest_t *) mf;
1230
1231                 count = buckets;
1232                 if (count > max)
1233                         count = max;
1234
1235                 pRecvReq->Function    = MPI_FUNCTION_LAN_RECEIVE;
1236                 pRecvReq->ChainOffset = 0;
1237                 pRecvReq->MsgFlags    = 0;
1238                 pRecvReq->PortNumber  = priv->pnum;
1239
1240                 pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
1241                 pSimple = NULL;
1242
1243                 for (i = 0; i < count; i++) {
1244                         int ctx;
1245
1246                         spin_lock_irqsave(&priv->rxfidx_lock, flags);
1247                         if (priv->mpt_rxfidx_tail < 0) {
1248                                 printk (KERN_ERR "%s: Can't alloc context\n",
1249                                         __FUNCTION__);
1250                                 spin_unlock_irqrestore(&priv->rxfidx_lock,
1251                                                        flags);
1252                                 break;
1253                         }
1254
1255                         ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
1256
1257                         skb = priv->RcvCtl[ctx].skb;
1258                         if (skb && (priv->RcvCtl[ctx].len != len)) {
1259                                 pci_unmap_single(mpt_dev->pcidev,
1260                                                  priv->RcvCtl[ctx].dma,
1261                                                  priv->RcvCtl[ctx].len,
1262                                                  PCI_DMA_FROMDEVICE);
1263                                 dev_kfree_skb(priv->RcvCtl[ctx].skb);
1264                                 skb = priv->RcvCtl[ctx].skb = NULL;
1265                         }
1266
1267                         if (skb == NULL) {
1268                                 skb = dev_alloc_skb(len);
1269                                 if (skb == NULL) {
1270                                         printk (KERN_WARNING
1271                                                 MYNAM "/%s: Can't alloc skb\n",
1272                                                 __FUNCTION__);
1273                                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1274                                         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1275                                         break;
1276                                 }
1277
1278                                 dma = pci_map_single(mpt_dev->pcidev, skb->data,
1279                                                      len, PCI_DMA_FROMDEVICE);
1280
1281                                 priv->RcvCtl[ctx].skb = skb;
1282                                 priv->RcvCtl[ctx].dma = dma;
1283                                 priv->RcvCtl[ctx].len = len;
1284                         }
1285
1286                         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1287
1288                         pTrans->ContextSize   = sizeof(u32);
1289                         pTrans->DetailsLength = 0;
1290                         pTrans->Flags         = 0;
1291                         pTrans->TransactionContext[0] = cpu_to_le32(ctx);
1292
1293                         pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
1294
1295                         pSimple->FlagsLength = cpu_to_le32(
1296                                 ((MPI_SGE_FLAGS_END_OF_BUFFER |
1297                                   MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1298                                   MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
1299                         pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
1300                         if (sizeof(dma_addr_t) > sizeof(u32))
1301                                 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
1302                         else
1303                                 pSimple->Address.High = 0;
1304
1305                         pTrans = (SGETransaction32_t *) (pSimple + 1);
1306                 }
1307
1308                 if (pSimple == NULL) {
1309 /**/                    printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
1310 /**/                            __FUNCTION__);
1311                         mpt_free_msg_frame(mpt_dev, mf);
1312                         goto out;
1313                 }
1314
1315                 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
1316
1317                 pRecvReq->BucketCount = cpu_to_le32(i);
1318
1319 /*      printk(KERN_INFO MYNAM ": posting buckets\n   ");
1320  *      for (i = 0; i < j + 2; i ++)
1321  *          printk (" %08x", le32_to_cpu(msg[i]));
1322  *      printk ("\n");
1323  */
1324
1325                 mpt_put_msg_frame(LanCtx, mpt_dev, mf);
1326
1327                 priv->total_posted += i;
1328                 buckets -= i;
1329                 atomic_add(i, &priv->buckets_out);
1330         }
1331
1332 out:
1333         dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
1334                   __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
1335         dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
1336         __FUNCTION__, priv->total_posted, priv->total_received));
1337
1338         clear_bit(0, &priv->post_buckets_active);
1339 }
1340
1341 static void
1342 mpt_lan_post_receive_buckets_work(struct work_struct *work)
1343 {
1344         mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
1345                                                   post_buckets_task.work));
1346 }
1347
1348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1349 static struct net_device *
1350 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1351 {
1352         struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1353         struct mpt_lan_priv *priv = NULL;
1354         u8 HWaddr[FC_ALEN], *a;
1355
1356         if (!dev)
1357                 return NULL;
1358
1359         dev->mtu = MPT_LAN_MTU;
1360
1361         priv = netdev_priv(dev);
1362
1363         priv->dev = dev;
1364         priv->mpt_dev = mpt_dev;
1365         priv->pnum = pnum;
1366
1367         memset(&priv->post_buckets_task, 0, sizeof(priv->post_buckets_task));
1368         INIT_DELAYED_WORK(&priv->post_buckets_task,
1369                           mpt_lan_post_receive_buckets_work);
1370         priv->post_buckets_active = 0;
1371
1372         dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
1373                         __LINE__, dev->mtu + dev->hard_header_len + 4));
1374
1375         atomic_set(&priv->buckets_out, 0);
1376         priv->total_posted = 0;
1377         priv->total_received = 0;
1378         priv->max_buckets_out = max_buckets_out;
1379         if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
1380                 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
1381
1382         dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n",
1383                         __LINE__,
1384                         mpt_dev->pfacts[0].MaxLanBuckets,
1385                         max_buckets_out,
1386                         priv->max_buckets_out));
1387
1388         priv->bucketthresh = priv->max_buckets_out * 2 / 3;
1389         spin_lock_init(&priv->txfidx_lock);
1390         spin_lock_init(&priv->rxfidx_lock);
1391
1392         memset(&priv->stats, 0, sizeof(priv->stats));
1393
1394         /*  Grab pre-fetched LANPage1 stuff. :-) */
1395         a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
1396
1397         HWaddr[0] = a[5];
1398         HWaddr[1] = a[4];
1399         HWaddr[2] = a[3];
1400         HWaddr[3] = a[2];
1401         HWaddr[4] = a[1];
1402         HWaddr[5] = a[0];
1403
1404         dev->addr_len = FC_ALEN;
1405         memcpy(dev->dev_addr, HWaddr, FC_ALEN);
1406         memset(dev->broadcast, 0xff, FC_ALEN);
1407
1408         /* The Tx queue is 127 deep on the 909.
1409          * Give ourselves some breathing room.
1410          */
1411         priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
1412                             tx_max_out_p : MPT_TX_MAX_OUT_LIM;
1413
1414         dev->open = mpt_lan_open;
1415         dev->stop = mpt_lan_close;
1416         dev->get_stats = mpt_lan_get_stats;
1417         dev->set_multicast_list = NULL;
1418         dev->change_mtu = mpt_lan_change_mtu;
1419         dev->hard_start_xmit = mpt_lan_sdu_send;
1420
1421 /* Not in 2.3.42. Need 2.3.45+ */
1422         dev->tx_timeout = mpt_lan_tx_timeout;
1423         dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
1424
1425         dlprintk((KERN_INFO MYNAM ": Finished registering dev "
1426                 "and setting initial values\n"));
1427
1428         SET_MODULE_OWNER(dev);
1429
1430         if (register_netdev(dev) != 0) {
1431                 free_netdev(dev);
1432                 dev = NULL;
1433         }
1434         return dev;
1435 }
1436
1437 static int
1438 mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1439 {
1440         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1441         struct net_device       *dev;
1442         int                     i;
1443
1444         for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1445                 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1446                        "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1447                        ioc->name, ioc->pfacts[i].PortNumber,
1448                        ioc->pfacts[i].ProtocolFlags,
1449                        MPT_PROTOCOL_FLAGS_c_c_c_c(
1450                                ioc->pfacts[i].ProtocolFlags));
1451
1452                 if (!(ioc->pfacts[i].ProtocolFlags &
1453                                         MPI_PORTFACTS_PROTOCOL_LAN)) {
1454                         printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1455                                "seems to be disabled on this adapter port!\n",
1456                                ioc->name);
1457                         continue;
1458                 }
1459
1460                 dev = mpt_register_lan_device(ioc, i);
1461                 if (!dev) {
1462                         printk(KERN_ERR MYNAM ": %s: Unable to register "
1463                                "port%d as a LAN device\n", ioc->name,
1464                                ioc->pfacts[i].PortNumber);
1465                         continue;
1466                 }
1467                 
1468                 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1469                        "registered as '%s'\n", ioc->name, dev->name);
1470                 printk(KERN_INFO MYNAM ": %s/%s: "
1471                        "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1472                        IOC_AND_NETDEV_NAMES_s_s(dev),
1473                        dev->dev_addr[0], dev->dev_addr[1],
1474                        dev->dev_addr[2], dev->dev_addr[3],
1475                        dev->dev_addr[4], dev->dev_addr[5]);
1476         
1477                 ioc->netdev = dev;
1478
1479                 return 0;
1480         }
1481
1482         return -ENODEV;
1483 }
1484
1485 static void
1486 mptlan_remove(struct pci_dev *pdev)
1487 {
1488         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1489         struct net_device       *dev = ioc->netdev;
1490
1491         if(dev != NULL) {
1492                 unregister_netdev(dev);
1493                 free_netdev(dev);
1494         }
1495 }
1496
1497 static struct mpt_pci_driver mptlan_driver = {
1498         .probe          = mptlan_probe,
1499         .remove         = mptlan_remove,
1500 };
1501
1502 static int __init mpt_lan_init (void)
1503 {
1504         show_mptmod_ver(LANAME, LANVER);
1505
1506         if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) {
1507                 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1508                 return -EBUSY;
1509         }
1510
1511         /* Set the callback index to be used by driver core for turbo replies */
1512         mpt_lan_index = LanCtx;
1513
1514         dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1515
1516         if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1517                 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1518                        "handler with mptbase! The world is at an end! "
1519                        "Everything is fading to black! Goodbye.\n");
1520                 return -EBUSY;
1521         }
1522
1523         dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1524         
1525         if (mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER))
1526                 dprintk((KERN_INFO MYNAM ": failed to register dd callbacks\n"));
1527         return 0;
1528 }
1529
1530 static void __exit mpt_lan_exit(void)
1531 {
1532         mpt_device_driver_deregister(MPTLAN_DRIVER);
1533         mpt_reset_deregister(LanCtx);
1534
1535         if (LanCtx >= 0) {
1536                 mpt_deregister(LanCtx);
1537                 LanCtx = -1;
1538                 mpt_lan_index = 0;
1539         }
1540 }
1541
1542 module_init(mpt_lan_init);
1543 module_exit(mpt_lan_exit);
1544
1545 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1546 static unsigned short
1547 mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1548 {
1549         struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1550         struct fcllc *fcllc;
1551
1552         skb->mac.raw = skb->data;
1553         skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1554
1555         if (fch->dtype == htons(0xffff)) {
1556                 u32 *p = (u32 *) fch;
1557
1558                 swab32s(p + 0);
1559                 swab32s(p + 1);
1560                 swab32s(p + 2);
1561                 swab32s(p + 3);
1562
1563                 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1564                                 NETDEV_PTR_TO_IOC_NAME_s(dev));
1565                 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
1566                                 fch->saddr[0], fch->saddr[1], fch->saddr[2],
1567                                 fch->saddr[3], fch->saddr[4], fch->saddr[5]);
1568         }
1569
1570         if (*fch->daddr & 1) {
1571                 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1572                         skb->pkt_type = PACKET_BROADCAST;
1573                 } else {
1574                         skb->pkt_type = PACKET_MULTICAST;
1575                 }
1576         } else {
1577                 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1578                         skb->pkt_type = PACKET_OTHERHOST;
1579                 } else {
1580                         skb->pkt_type = PACKET_HOST;
1581                 }
1582         }
1583
1584         fcllc = (struct fcllc *)skb->data;
1585
1586 #ifdef QLOGIC_NAA_WORKAROUND
1587 {
1588         u16 source_naa = fch->stype, found = 0;
1589
1590         /* Workaround for QLogic not following RFC 2625 in regards to the NAA
1591            value. */
1592
1593         if ((source_naa & 0xF000) == 0)
1594                 source_naa = swab16(source_naa);
1595
1596         if (fcllc->ethertype == htons(ETH_P_ARP))
1597             dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of "
1598                       "%04x.\n", source_naa));
1599
1600         if ((fcllc->ethertype == htons(ETH_P_ARP)) &&
1601            ((source_naa >> 12) !=  MPT_LAN_NAA_RFC2625)){
1602                 struct NAA_Hosed *nh, *prevnh;
1603                 int i;
1604
1605                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from "
1606                           "system with non-RFC 2625 NAA value (%04x).\n",
1607                           source_naa));
1608
1609                 write_lock_irq(&bad_naa_lock);
1610                 for (prevnh = nh = mpt_bad_naa; nh != NULL;
1611                      prevnh=nh, nh=nh->next) {
1612                         if ((nh->ieee[0] == fch->saddr[0]) &&
1613                             (nh->ieee[1] == fch->saddr[1]) &&
1614                             (nh->ieee[2] == fch->saddr[2]) &&
1615                             (nh->ieee[3] == fch->saddr[3]) &&
1616                             (nh->ieee[4] == fch->saddr[4]) &&
1617                             (nh->ieee[5] == fch->saddr[5])) {
1618                                 found = 1;
1619                                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re"
1620                                          "q/Rep w/ bad NAA from system already"
1621                                          " in DB.\n"));
1622                                 break;
1623                         }
1624                 }
1625
1626                 if ((!found) && (nh == NULL)) {
1627
1628                         nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL);
1629                         dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/"
1630                                  " bad NAA from system not yet in DB.\n"));
1631
1632                         if (nh != NULL) {
1633                                 nh->next = NULL;
1634                                 if (!mpt_bad_naa)
1635                                         mpt_bad_naa = nh;
1636                                 if (prevnh)
1637                                         prevnh->next = nh;
1638
1639                                 nh->NAA = source_naa; /* Set the S_NAA value. */
1640                                 for (i = 0; i < FC_ALEN; i++)
1641                                         nh->ieee[i] = fch->saddr[i];
1642                                 dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:"
1643                                           "%02x:%02x with non-compliant S_NAA value.\n",
1644                                           fch->saddr[0], fch->saddr[1], fch->saddr[2],
1645                                           fch->saddr[3], fch->saddr[4],fch->saddr[5]));
1646                         } else {
1647                                 printk (KERN_ERR "mptlan/type_trans: Unable to"
1648                                         " kmalloc a NAA_Hosed struct.\n");
1649                         }
1650                 } else if (!found) {
1651                         printk (KERN_ERR "mptlan/type_trans: found not"
1652                                 " set, but nh isn't null. Evil "
1653                                 "funkiness abounds.\n");
1654                 }
1655                 write_unlock_irq(&bad_naa_lock);
1656         }
1657 }
1658 #endif
1659
1660         /* Strip the SNAP header from ARP packets since we don't
1661          * pass them through to the 802.2/SNAP layers.
1662          */
1663         if (fcllc->dsap == EXTENDED_SAP &&
1664                 (fcllc->ethertype == htons(ETH_P_IP) ||
1665                  fcllc->ethertype == htons(ETH_P_ARP))) {
1666                 skb_pull(skb, sizeof(struct fcllc));
1667                 return fcllc->ethertype;
1668         }
1669
1670         return htons(ETH_P_802_2);
1671 }
1672
1673 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/