?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlwifi: introduce host commands callbacks
[linux/fpc-iii.git] / drivers / message / fusion / mptlan.c
blob7950fc678ed17c281e826529b290c76efa8cca11
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 if (register_netdev(dev) != 0) {
1425 free_netdev(dev);
1426 dev = NULL;
1427 }
1428 return dev;
1429 }
1430
1431 static int
1432 mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1433 {
1434 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1435 struct net_device *dev;
1436 int i;
1437
1438 for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1439 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1440 "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1441 ioc->name, ioc->pfacts[i].PortNumber,
1442 ioc->pfacts[i].ProtocolFlags,
1443 MPT_PROTOCOL_FLAGS_c_c_c_c(
1444 ioc->pfacts[i].ProtocolFlags));
1445
1446 if (!(ioc->pfacts[i].ProtocolFlags &
1447 MPI_PORTFACTS_PROTOCOL_LAN)) {
1448 printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1449 "seems to be disabled on this adapter port!\n",
1450 ioc->name);
1451 continue;
1452 }
1453
1454 dev = mpt_register_lan_device(ioc, i);
1455 if (!dev) {
1456 printk(KERN_ERR MYNAM ": %s: Unable to register "
1457 "port%d as a LAN device\n", ioc->name,
1458 ioc->pfacts[i].PortNumber);
1459 continue;
1460 }
1461
1462 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1463 "registered as '%s'\n", ioc->name, dev->name);
1464 printk(KERN_INFO MYNAM ": %s/%s: "
1465 "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1466 IOC_AND_NETDEV_NAMES_s_s(dev),
1467 dev->dev_addr[0], dev->dev_addr[1],
1468 dev->dev_addr[2], dev->dev_addr[3],
1469 dev->dev_addr[4], dev->dev_addr[5]);
1470
1471 ioc->netdev = dev;
1472
1473 return 0;
1474 }
1475
1476 return -ENODEV;
1477 }
1478
1479 static void
1480 mptlan_remove(struct pci_dev *pdev)
1481 {
1482 MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1483 struct net_device *dev = ioc->netdev;
1484
1485 if(dev != NULL) {
1486 unregister_netdev(dev);
1487 free_netdev(dev);
1488 }
1489 }
1490
1491 static struct mpt_pci_driver mptlan_driver = {
1492 .probe = mptlan_probe,
1493 .remove = mptlan_remove,
1494 };
1495
1496 static int __init mpt_lan_init (void)
1497 {
1498 show_mptmod_ver(LANAME, LANVER);
1499
1500 if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) {
1501 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1502 return -EBUSY;
1503 }
1504
1505 dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1506
1507 if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1508 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1509 "handler with mptbase! The world is at an end! "
1510 "Everything is fading to black! Goodbye.\n");
1511 return -EBUSY;
1512 }
1513
1514 dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1515
1516 mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER);
1517 return 0;
1518 }
1519
1520 static void __exit mpt_lan_exit(void)
1521 {
1522 mpt_device_driver_deregister(MPTLAN_DRIVER);
1523 mpt_reset_deregister(LanCtx);
1524
1525 if (LanCtx) {
1526 mpt_deregister(LanCtx);
1527 LanCtx = MPT_MAX_PROTOCOL_DRIVERS;
1528 }
1529 }
1530
1531 module_init(mpt_lan_init);
1532 module_exit(mpt_lan_exit);
1533
1534 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1535 static unsigned short
1536 mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1537 {
1538 struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1539 struct fcllc *fcllc;
1540
1541 skb_reset_mac_header(skb);
1542 skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1543
1544 if (fch->dtype == htons(0xffff)) {
1545 u32 *p = (u32 *) fch;
1546
1547 swab32s(p + 0);
1548 swab32s(p + 1);
1549 swab32s(p + 2);
1550 swab32s(p + 3);
1551
1552 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1553 NETDEV_PTR_TO_IOC_NAME_s(dev));
1554 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
1555 fch->saddr[0], fch->saddr[1], fch->saddr[2],
1556 fch->saddr[3], fch->saddr[4], fch->saddr[5]);
1557 }
1558
1559 if (*fch->daddr & 1) {
1560 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1561 skb->pkt_type = PACKET_BROADCAST;
1562 } else {
1563 skb->pkt_type = PACKET_MULTICAST;
1564 }
1565 } else {
1566 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1567 skb->pkt_type = PACKET_OTHERHOST;
1568 } else {
1569 skb->pkt_type = PACKET_HOST;
1570 }
1571 }
1572
1573 fcllc = (struct fcllc *)skb->data;
1574
1575 #ifdef QLOGIC_NAA_WORKAROUND
1576 {
1577 u16 source_naa = fch->stype, found = 0;
1578
1579 /* Workaround for QLogic not following RFC 2625 in regards to the NAA
1580 value. */
1581
1582 if ((source_naa & 0xF000) == 0)
1583 source_naa = swab16(source_naa);
1584
1585 if (fcllc->ethertype == htons(ETH_P_ARP))
1586 dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of "
1587 "%04x.\n", source_naa));
1588
1589 if ((fcllc->ethertype == htons(ETH_P_ARP)) &&
1590 ((source_naa >> 12) != MPT_LAN_NAA_RFC2625)){
1591 struct NAA_Hosed *nh, *prevnh;
1592 int i;
1593
1594 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from "
1595 "system with non-RFC 2625 NAA value (%04x).\n",
1596 source_naa));
1597
1598 write_lock_irq(&bad_naa_lock);
1599 for (prevnh = nh = mpt_bad_naa; nh != NULL;
1600 prevnh=nh, nh=nh->next) {
1601 if ((nh->ieee[0] == fch->saddr[0]) &&
1602 (nh->ieee[1] == fch->saddr[1]) &&
1603 (nh->ieee[2] == fch->saddr[2]) &&
1604 (nh->ieee[3] == fch->saddr[3]) &&
1605 (nh->ieee[4] == fch->saddr[4]) &&
1606 (nh->ieee[5] == fch->saddr[5])) {
1607 found = 1;
1608 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re"
1609 "q/Rep w/ bad NAA from system already"
1610 " in DB.\n"));
1611 break;
1612 }
1613 }
1614
1615 if ((!found) && (nh == NULL)) {
1616
1617 nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL);
1618 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/"
1619 " bad NAA from system not yet in DB.\n"));
1620
1621 if (nh != NULL) {
1622 nh->next = NULL;
1623 if (!mpt_bad_naa)
1624 mpt_bad_naa = nh;
1625 if (prevnh)
1626 prevnh->next = nh;
1627
1628 nh->NAA = source_naa; /* Set the S_NAA value. */
1629 for (i = 0; i < FC_ALEN; i++)
1630 nh->ieee[i] = fch->saddr[i];
1631 dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:"
1632 "%02x:%02x with non-compliant S_NAA value.\n",
1633 fch->saddr[0], fch->saddr[1], fch->saddr[2],
1634 fch->saddr[3], fch->saddr[4],fch->saddr[5]));
1635 } else {
1636 printk (KERN_ERR "mptlan/type_trans: Unable to"
1637 " kmalloc a NAA_Hosed struct.\n");
1638 }
1639 } else if (!found) {
1640 printk (KERN_ERR "mptlan/type_trans: found not"
1641 " set, but nh isn't null. Evil "
1642 "funkiness abounds.\n");
1643 }
1644 write_unlock_irq(&bad_naa_lock);
1645 }
1646 }
1647 #endif
1648
1649 /* Strip the SNAP header from ARP packets since we don't
1650 * pass them through to the 802.2/SNAP layers.
1651 */
1652 if (fcllc->dsap == EXTENDED_SAP &&
1653 (fcllc->ethertype == htons(ETH_P_IP) ||
1654 fcllc->ethertype == htons(ETH_P_ARP))) {
1655 skb_pull(skb, sizeof(struct fcllc));
1656 return fcllc->ethertype;
1657 }
1658
1659 return htons(ETH_P_802_2);
1660 }
1661
1662 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
Linux with added FPC-III support