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