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