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