?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[libata] change ata_qc_complete() to take error mask as second arg
[linux-2.6/kvm.git] / drivers / message / fusion / mptlan.c
blobed3c891e388f9ee3c73184dc0b445202bb208ab8
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 work_struct post_buckets_task;
115 unsigned long post_buckets_active;
116 };
117
118 struct mpt_lan_ohdr {
119 u16 dtype;
120 u8 daddr[FC_ALEN];
121 u16 stype;
122 u8 saddr[FC_ALEN];
123 };
124
125 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
126
127 /*
128 * Forward protos...
129 */
130 static int lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
131 MPT_FRAME_HDR *reply);
132 static int mpt_lan_open(struct net_device *dev);
133 static int mpt_lan_reset(struct net_device *dev);
134 static int mpt_lan_close(struct net_device *dev);
135 static void mpt_lan_post_receive_buckets(void *dev_id);
136 static void mpt_lan_wake_post_buckets_task(struct net_device *dev,
137 int priority);
138 static int mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg);
139 static int mpt_lan_receive_post_reply(struct net_device *dev,
140 LANReceivePostReply_t *pRecvRep);
141 static int mpt_lan_send_turbo(struct net_device *dev, u32 tmsg);
142 static int mpt_lan_send_reply(struct net_device *dev,
143 LANSendReply_t *pSendRep);
144 static int mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
145 static int mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
146 static unsigned short mpt_lan_type_trans(struct sk_buff *skb,
147 struct net_device *dev);
148
149 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
150 /*
151 * Fusion MPT LAN private data
152 */
153 static int LanCtx = -1;
154
155 static u32 max_buckets_out = 127;
156 static u32 tx_max_out_p = 127 - 16;
157
158 #ifdef QLOGIC_NAA_WORKAROUND
159 static struct NAA_Hosed *mpt_bad_naa = NULL;
160 DEFINE_RWLOCK(bad_naa_lock);
161 #endif
162
163 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
164 /*
165 * Fusion MPT LAN external data
166 */
167 extern int mpt_lan_index;
168
169 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
170 /**
171 * lan_reply - Handle all data sent from the hardware.
172 * @ioc: Pointer to MPT_ADAPTER structure
173 * @mf: Pointer to original MPT request frame (NULL if TurboReply)
174 * @reply: Pointer to MPT reply frame
175 *
176 * Returns 1 indicating original alloc'd request frame ptr
177 * should be freed, or 0 if it shouldn't.
178 */
179 static int
180 lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
181 {
182 struct net_device *dev = ioc->netdev;
183 int FreeReqFrame = 0;
184
185 dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.\n",
186 IOC_AND_NETDEV_NAMES_s_s(dev)));
187
188 // dioprintk((KERN_INFO MYNAM "@lan_reply: mf = %p, reply = %p\n",
189 // mf, reply));
190
191 if (mf == NULL) {
192 u32 tmsg = CAST_PTR_TO_U32(reply);
193
194 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
195 IOC_AND_NETDEV_NAMES_s_s(dev),
196 tmsg));
197
198 switch (GET_LAN_FORM(tmsg)) {
199
200 // NOTE! (Optimization) First case here is now caught in
201 // mptbase.c::mpt_interrupt() routine and callcack here
202 // is now skipped for this case!
203 #if 0
204 case LAN_REPLY_FORM_MESSAGE_CONTEXT:
205 // dioprintk((KERN_INFO MYNAM "/lan_reply: "
206 // "MessageContext turbo reply received\n"));
207 FreeReqFrame = 1;
208 break;
209 #endif
210
211 case LAN_REPLY_FORM_SEND_SINGLE:
212 // dioprintk((MYNAM "/lan_reply: "
213 // "calling mpt_lan_send_reply (turbo)\n"));
214
215 // Potential BUG here?
216 // FreeReqFrame = mpt_lan_send_turbo(dev, tmsg);
217 // If/when mpt_lan_send_turbo would return 1 here,
218 // calling routine (mptbase.c|mpt_interrupt)
219 // would Oops because mf has already been set
220 // to NULL. So after return from this func,
221 // mpt_interrupt() will attempt to put (NULL) mf ptr
222 // item back onto its adapter FreeQ - Oops!:-(
223 // It's Ok, since mpt_lan_send_turbo() *currently*
224 // always returns 0, but..., just in case:
225
226 (void) mpt_lan_send_turbo(dev, tmsg);
227 FreeReqFrame = 0;
228
229 break;
230
231 case LAN_REPLY_FORM_RECEIVE_SINGLE:
232 // dioprintk((KERN_INFO MYNAM "@lan_reply: "
233 // "rcv-Turbo = %08x\n", tmsg));
234 mpt_lan_receive_post_turbo(dev, tmsg);
235 break;
236
237 default:
238 printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply "
239 "that I don't know what to do with\n");
240
241 /* CHECKME! Hmmm... FreeReqFrame is 0 here; is that right? */
242
243 break;
244 }
245
246 return FreeReqFrame;
247 }
248
249 // msg = (u32 *) reply;
250 // dioprintk((KERN_INFO MYNAM "@lan_reply: msg = %08x %08x %08x %08x\n",
251 // le32_to_cpu(msg[0]), le32_to_cpu(msg[1]),
252 // le32_to_cpu(msg[2]), le32_to_cpu(msg[3])));
253 // dioprintk((KERN_INFO MYNAM "@lan_reply: Function = %02xh\n",
254 // reply->u.hdr.Function));
255
256 switch (reply->u.hdr.Function) {
257
258 case MPI_FUNCTION_LAN_SEND:
259 {
260 LANSendReply_t *pSendRep;
261
262 pSendRep = (LANSendReply_t *) reply;
263 FreeReqFrame = mpt_lan_send_reply(dev, pSendRep);
264 break;
265 }
266
267 case MPI_FUNCTION_LAN_RECEIVE:
268 {
269 LANReceivePostReply_t *pRecvRep;
270
271 pRecvRep = (LANReceivePostReply_t *) reply;
272 if (pRecvRep->NumberOfContexts) {
273 mpt_lan_receive_post_reply(dev, pRecvRep);
274 if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
275 FreeReqFrame = 1;
276 } else
277 dioprintk((KERN_INFO MYNAM "@lan_reply: zero context "
278 "ReceivePostReply received.\n"));
279 break;
280 }
281
282 case MPI_FUNCTION_LAN_RESET:
283 /* Just a default reply. Might want to check it to
284 * make sure that everything went ok.
285 */
286 FreeReqFrame = 1;
287 break;
288
289 case MPI_FUNCTION_EVENT_NOTIFICATION:
290 case MPI_FUNCTION_EVENT_ACK:
291 /* _EVENT_NOTIFICATION should NOT come down this path any more.
292 * Should be routed to mpt_lan_event_process(), but just in case...
293 */
294 FreeReqFrame = 1;
295 break;
296
297 default:
298 printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo "
299 "reply that I don't know what to do with\n");
300
301 /* CHECKME! Hmmm... FreeReqFrame is 0 here; is that right? */
302 FreeReqFrame = 1;
303
304 break;
305 }
306
307 return FreeReqFrame;
308 }
309
310 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
311 static int
312 mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
313 {
314 struct net_device *dev = ioc->netdev;
315 struct mpt_lan_priv *priv;
316
317 if (dev == NULL)
318 return(1);
319 else
320 priv = netdev_priv(dev);
321
322 dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!\n",
323 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
324 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
325
326 if (priv->mpt_rxfidx == NULL)
327 return (1);
328
329 if (reset_phase == MPT_IOC_SETUP_RESET) {
330 ;
331 } else if (reset_phase == MPT_IOC_PRE_RESET) {
332 int i;
333 unsigned long flags;
334
335 netif_stop_queue(dev);
336
337 dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.\n", dev->name));
338
339 atomic_set(&priv->buckets_out, 0);
340
341 /* Reset Rx Free Tail index and re-populate the queue. */
342 spin_lock_irqsave(&priv->rxfidx_lock, flags);
343 priv->mpt_rxfidx_tail = -1;
344 for (i = 0; i < priv->max_buckets_out; i++)
345 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
346 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
347 } else {
348 mpt_lan_post_receive_buckets(dev);
349 netif_wake_queue(dev);
350 }
351
352 return 1;
353 }
354
355 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
356 static int
357 mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
358 {
359 dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!\n"));
360
361 switch (le32_to_cpu(pEvReply->Event)) {
362 case MPI_EVENT_NONE: /* 00 */
363 case MPI_EVENT_LOG_DATA: /* 01 */
364 case MPI_EVENT_STATE_CHANGE: /* 02 */
365 case MPI_EVENT_UNIT_ATTENTION: /* 03 */
366 case MPI_EVENT_IOC_BUS_RESET: /* 04 */
367 case MPI_EVENT_EXT_BUS_RESET: /* 05 */
368 case MPI_EVENT_RESCAN: /* 06 */
369 /* Ok, do we need to do anything here? As far as
370 I can tell, this is when a new device gets added
371 to the loop. */
372 case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */
373 case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */
374 case MPI_EVENT_LOGOUT: /* 09 */
375 case MPI_EVENT_EVENT_CHANGE: /* 0A */
376 default:
377 break;
378 }
379
380 /*
381 * NOTE: pEvent->AckRequired handling now done in mptbase.c;
382 * Do NOT do it here now!
383 */
384
385 return 1;
386 }
387
388 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
389 static int
390 mpt_lan_open(struct net_device *dev)
391 {
392 struct mpt_lan_priv *priv = netdev_priv(dev);
393 int i;
394
395 if (mpt_lan_reset(dev) != 0) {
396 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
397
398 printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed.");
399
400 if (mpt_dev->active)
401 printk ("The ioc is active. Perhaps it needs to be"
402 " reset?\n");
403 else
404 printk ("The ioc in inactive, most likely in the "
405 "process of being reset. Please try again in "
406 "a moment.\n");
407 }
408
409 priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL);
410 if (priv->mpt_txfidx == NULL)
411 goto out;
412 priv->mpt_txfidx_tail = -1;
413
414 priv->SendCtl = kmalloc(priv->tx_max_out * sizeof(struct BufferControl),
415 GFP_KERNEL);
416 if (priv->SendCtl == NULL)
417 goto out_mpt_txfidx;
418 for (i = 0; i < priv->tx_max_out; i++) {
419 memset(&priv->SendCtl[i], 0, sizeof(struct BufferControl));
420 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
421 }
422
423 dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
424
425 priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int),
426 GFP_KERNEL);
427 if (priv->mpt_rxfidx == NULL)
428 goto out_SendCtl;
429 priv->mpt_rxfidx_tail = -1;
430
431 priv->RcvCtl = kmalloc(priv->max_buckets_out *
432 sizeof(struct BufferControl),
433 GFP_KERNEL);
434 if (priv->RcvCtl == NULL)
435 goto out_mpt_rxfidx;
436 for (i = 0; i < priv->max_buckets_out; i++) {
437 memset(&priv->RcvCtl[i], 0, sizeof(struct BufferControl));
438 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
439 }
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(dev);
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 int 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 = 2 * HZ;
530 while (atomic_read(&priv->buckets_out) && --timeout) {
531 set_current_state(TASK_INTERRUPTIBLE);
532 schedule_timeout(1);
533 }
534
535 for (i = 0; i < priv->max_buckets_out; i++) {
536 if (priv->RcvCtl[i].skb != NULL) {
537 /**/ dlprintk((KERN_INFO MYNAM "/lan_close: bucket %05x "
538 /**/ "is still out\n", i));
539 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[i].dma,
540 priv->RcvCtl[i].len,
541 PCI_DMA_FROMDEVICE);
542 dev_kfree_skb(priv->RcvCtl[i].skb);
543 }
544 }
545
546 kfree(priv->RcvCtl);
547 kfree(priv->mpt_rxfidx);
548
549 for (i = 0; i < priv->tx_max_out; i++) {
550 if (priv->SendCtl[i].skb != NULL) {
551 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[i].dma,
552 priv->SendCtl[i].len,
553 PCI_DMA_TODEVICE);
554 dev_kfree_skb(priv->SendCtl[i].skb);
555 }
556 }
557
558 kfree(priv->SendCtl);
559 kfree(priv->mpt_txfidx);
560
561 atomic_set(&priv->buckets_out, 0);
562
563 printk(KERN_INFO MYNAM ": %s/%s: interface down & inactive\n",
564 IOC_AND_NETDEV_NAMES_s_s(dev));
565
566 return 0;
567 }
568
569 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
570 static struct net_device_stats *
571 mpt_lan_get_stats(struct net_device *dev)
572 {
573 struct mpt_lan_priv *priv = netdev_priv(dev);
574
575 return (struct net_device_stats *) &priv->stats;
576 }
577
578 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
579 static int
580 mpt_lan_change_mtu(struct net_device *dev, int new_mtu)
581 {
582 if ((new_mtu < MPT_LAN_MIN_MTU) || (new_mtu > MPT_LAN_MAX_MTU))
583 return -EINVAL;
584 dev->mtu = new_mtu;
585 return 0;
586 }
587
588 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
589 /* Tx timeout handler. */
590 static void
591 mpt_lan_tx_timeout(struct net_device *dev)
592 {
593 struct mpt_lan_priv *priv = netdev_priv(dev);
594 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
595
596 if (mpt_dev->active) {
597 dlprintk (("mptlan/tx_timeout: calling netif_wake_queue for %s.\n", dev->name));
598 netif_wake_queue(dev);
599 }
600 }
601
602 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
603 //static inline int
604 static int
605 mpt_lan_send_turbo(struct net_device *dev, u32 tmsg)
606 {
607 struct mpt_lan_priv *priv = netdev_priv(dev);
608 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
609 struct sk_buff *sent;
610 unsigned long flags;
611 u32 ctx;
612
613 ctx = GET_LAN_BUFFER_CONTEXT(tmsg);
614 sent = priv->SendCtl[ctx].skb;
615
616 priv->stats.tx_packets++;
617 priv->stats.tx_bytes += sent->len;
618
619 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
620 IOC_AND_NETDEV_NAMES_s_s(dev),
621 __FUNCTION__, sent));
622
623 priv->SendCtl[ctx].skb = NULL;
624 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
625 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
626 dev_kfree_skb_irq(sent);
627
628 spin_lock_irqsave(&priv->txfidx_lock, flags);
629 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
630 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
631
632 netif_wake_queue(dev);
633 return 0;
634 }
635
636 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
637 static int
638 mpt_lan_send_reply(struct net_device *dev, LANSendReply_t *pSendRep)
639 {
640 struct mpt_lan_priv *priv = netdev_priv(dev);
641 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
642 struct sk_buff *sent;
643 unsigned long flags;
644 int FreeReqFrame = 0;
645 u32 *pContext;
646 u32 ctx;
647 u8 count;
648
649 count = pSendRep->NumberOfContexts;
650
651 dioprintk((KERN_INFO MYNAM ": send_reply: IOCStatus: %04x\n",
652 le16_to_cpu(pSendRep->IOCStatus)));
653
654 /* Add check for Loginfo Flag in IOCStatus */
655
656 switch (le16_to_cpu(pSendRep->IOCStatus) & MPI_IOCSTATUS_MASK) {
657 case MPI_IOCSTATUS_SUCCESS:
658 priv->stats.tx_packets += count;
659 break;
660
661 case MPI_IOCSTATUS_LAN_CANCELED:
662 case MPI_IOCSTATUS_LAN_TRANSMIT_ABORTED:
663 break;
664
665 case MPI_IOCSTATUS_INVALID_SGL:
666 priv->stats.tx_errors += count;
667 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Invalid SGL sent to IOC!\n",
668 IOC_AND_NETDEV_NAMES_s_s(dev));
669 goto out;
670
671 default:
672 priv->stats.tx_errors += count;
673 break;
674 }
675
676 pContext = &pSendRep->BufferContext;
677
678 spin_lock_irqsave(&priv->txfidx_lock, flags);
679 while (count > 0) {
680 ctx = GET_LAN_BUFFER_CONTEXT(le32_to_cpu(*pContext));
681
682 sent = priv->SendCtl[ctx].skb;
683 priv->stats.tx_bytes += sent->len;
684
685 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, skb %p sent.\n",
686 IOC_AND_NETDEV_NAMES_s_s(dev),
687 __FUNCTION__, sent));
688
689 priv->SendCtl[ctx].skb = NULL;
690 pci_unmap_single(mpt_dev->pcidev, priv->SendCtl[ctx].dma,
691 priv->SendCtl[ctx].len, PCI_DMA_TODEVICE);
692 dev_kfree_skb_irq(sent);
693
694 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = ctx;
695
696 pContext++;
697 count--;
698 }
699 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
700
701 out:
702 if (!(pSendRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
703 FreeReqFrame = 1;
704
705 netif_wake_queue(dev);
706 return FreeReqFrame;
707 }
708
709 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
710 static int
711 mpt_lan_sdu_send (struct sk_buff *skb, struct net_device *dev)
712 {
713 struct mpt_lan_priv *priv = netdev_priv(dev);
714 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
715 MPT_FRAME_HDR *mf;
716 LANSendRequest_t *pSendReq;
717 SGETransaction32_t *pTrans;
718 SGESimple64_t *pSimple;
719 dma_addr_t dma;
720 unsigned long flags;
721 int ctx;
722 u16 cur_naa = 0x1000;
723
724 dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
725 __FUNCTION__, skb));
726
727 spin_lock_irqsave(&priv->txfidx_lock, flags);
728 if (priv->mpt_txfidx_tail < 0) {
729 netif_stop_queue(dev);
730 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
731
732 printk (KERN_ERR "%s: no tx context available: %u\n",
733 __FUNCTION__, priv->mpt_txfidx_tail);
734 return 1;
735 }
736
737 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
738 if (mf == NULL) {
739 netif_stop_queue(dev);
740 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
741
742 printk (KERN_ERR "%s: Unable to alloc request frame\n",
743 __FUNCTION__);
744 return 1;
745 }
746
747 ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
748 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
749
750 // dioprintk((KERN_INFO MYNAM ": %s/%s: Creating new msg frame (send).\n",
751 // IOC_AND_NETDEV_NAMES_s_s(dev)));
752
753 pSendReq = (LANSendRequest_t *) mf;
754
755 /* Set the mac.raw pointer, since this apparently isn't getting
756 * done before we get the skb. Pull the data pointer past the mac data.
757 */
758 skb->mac.raw = skb->data;
759 skb_pull(skb, 12);
760
761 dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
762 PCI_DMA_TODEVICE);
763
764 priv->SendCtl[ctx].skb = skb;
765 priv->SendCtl[ctx].dma = dma;
766 priv->SendCtl[ctx].len = skb->len;
767
768 /* Message Header */
769 pSendReq->Reserved = 0;
770 pSendReq->Function = MPI_FUNCTION_LAN_SEND;
771 pSendReq->ChainOffset = 0;
772 pSendReq->Reserved2 = 0;
773 pSendReq->MsgFlags = 0;
774 pSendReq->PortNumber = priv->pnum;
775
776 /* Transaction Context Element */
777 pTrans = (SGETransaction32_t *) pSendReq->SG_List;
778
779 /* No Flags, 8 bytes of Details, 32bit Context (bloody turbo replies) */
780 pTrans->ContextSize = sizeof(u32);
781 pTrans->DetailsLength = 2 * sizeof(u32);
782 pTrans->Flags = 0;
783 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
784
785 // dioprintk((KERN_INFO MYNAM ": %s/%s: BC = %08x, skb = %p, buff = %p\n",
786 // IOC_AND_NETDEV_NAMES_s_s(dev),
787 // ctx, skb, skb->data));
788
789 #ifdef QLOGIC_NAA_WORKAROUND
790 {
791 struct NAA_Hosed *nh;
792
793 /* Munge the NAA for Tx packets to QLogic boards, which don't follow
794 RFC 2625. The longer I look at this, the more my opinion of Qlogic
795 drops. */
796 read_lock_irq(&bad_naa_lock);
797 for (nh = mpt_bad_naa; nh != NULL; nh=nh->next) {
798 if ((nh->ieee[0] == skb->mac.raw[0]) &&
799 (nh->ieee[1] == skb->mac.raw[1]) &&
800 (nh->ieee[2] == skb->mac.raw[2]) &&
801 (nh->ieee[3] == skb->mac.raw[3]) &&
802 (nh->ieee[4] == skb->mac.raw[4]) &&
803 (nh->ieee[5] == skb->mac.raw[5])) {
804 cur_naa = nh->NAA;
805 dlprintk ((KERN_INFO "mptlan/sdu_send: using NAA value "
806 "= %04x.\n", cur_naa));
807 break;
808 }
809 }
810 read_unlock_irq(&bad_naa_lock);
811 }
812 #endif
813
814 pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa << 16) |
815 (skb->mac.raw[0] << 8) |
816 (skb->mac.raw[1] << 0));
817 pTrans->TransactionDetails[1] = cpu_to_le32((skb->mac.raw[2] << 24) |
818 (skb->mac.raw[3] << 16) |
819 (skb->mac.raw[4] << 8) |
820 (skb->mac.raw[5] << 0));
821
822 pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
823
824 /* If we ever decide to send more than one Simple SGE per LANSend, then
825 we will need to make sure that LAST_ELEMENT only gets set on the
826 last one. Otherwise, bad voodoo and evil funkiness will commence. */
827 pSimple->FlagsLength = cpu_to_le32(
828 ((MPI_SGE_FLAGS_LAST_ELEMENT |
829 MPI_SGE_FLAGS_END_OF_BUFFER |
830 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
831 MPI_SGE_FLAGS_SYSTEM_ADDRESS |
832 MPI_SGE_FLAGS_HOST_TO_IOC |
833 MPI_SGE_FLAGS_64_BIT_ADDRESSING |
834 MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
835 skb->len);
836 pSimple->Address.Low = cpu_to_le32((u32) dma);
837 if (sizeof(dma_addr_t) > sizeof(u32))
838 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
839 else
840 pSimple->Address.High = 0;
841
842 mpt_put_msg_frame (LanCtx, mpt_dev, mf);
843 dev->trans_start = jiffies;
844
845 dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.\n",
846 IOC_AND_NETDEV_NAMES_s_s(dev),
847 le32_to_cpu(pSimple->FlagsLength)));
848
849 return 0;
850 }
851
852 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
853 static inline void
854 mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
855 /*
856 * @priority: 0 = put it on the timer queue, 1 = put it on the immediate queue
857 */
858 {
859 struct mpt_lan_priv *priv = dev->priv;
860
861 if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
862 if (priority) {
863 schedule_work(&priv->post_buckets_task);
864 } else {
865 schedule_delayed_work(&priv->post_buckets_task, 1);
866 dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
867 "timer.\n"));
868 }
869 dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.\n",
870 IOC_AND_NETDEV_NAMES_s_s(dev) ));
871 }
872 }
873
874 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
875 static inline int
876 mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
877 {
878 struct mpt_lan_priv *priv = dev->priv;
879
880 skb->protocol = mpt_lan_type_trans(skb, dev);
881
882 dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
883 "delivered to upper level.\n",
884 IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
885
886 priv->stats.rx_bytes += skb->len;
887 priv->stats.rx_packets++;
888
889 skb->dev = dev;
890 netif_rx(skb);
891
892 dioprintk((MYNAM "/receive_skb: %d buckets remaining\n",
893 atomic_read(&priv->buckets_out)));
894
895 if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
896 mpt_lan_wake_post_buckets_task(dev, 1);
897
898 dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
899 "remaining, %d received back since sod\n",
900 atomic_read(&priv->buckets_out), priv->total_received));
901
902 return 0;
903 }
904
905 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
906 //static inline int
907 static int
908 mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
909 {
910 struct mpt_lan_priv *priv = dev->priv;
911 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
912 struct sk_buff *skb, *old_skb;
913 unsigned long flags;
914 u32 ctx, len;
915
916 ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
917 skb = priv->RcvCtl[ctx].skb;
918
919 len = GET_LAN_PACKET_LENGTH(tmsg);
920
921 if (len < MPT_LAN_RX_COPYBREAK) {
922 old_skb = skb;
923
924 skb = (struct sk_buff *)dev_alloc_skb(len);
925 if (!skb) {
926 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
927 IOC_AND_NETDEV_NAMES_s_s(dev),
928 __FILE__, __LINE__);
929 return -ENOMEM;
930 }
931
932 pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
933 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
934
935 memcpy(skb_put(skb, len), old_skb->data, len);
936
937 pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
938 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
939 goto out;
940 }
941
942 skb_put(skb, len);
943
944 priv->RcvCtl[ctx].skb = NULL;
945
946 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
947 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
948
949 out:
950 spin_lock_irqsave(&priv->rxfidx_lock, flags);
951 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
952 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
953
954 atomic_dec(&priv->buckets_out);
955 priv->total_received++;
956
957 return mpt_lan_receive_skb(dev, skb);
958 }
959
960 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
961 static int
962 mpt_lan_receive_post_free(struct net_device *dev,
963 LANReceivePostReply_t *pRecvRep)
964 {
965 struct mpt_lan_priv *priv = dev->priv;
966 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
967 unsigned long flags;
968 struct sk_buff *skb;
969 u32 ctx;
970 int count;
971 int i;
972
973 count = pRecvRep->NumberOfContexts;
974
975 /**/ dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
976 "IOC returned %d buckets, freeing them...\n", count));
977
978 spin_lock_irqsave(&priv->rxfidx_lock, flags);
979 for (i = 0; i < count; i++) {
980 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
981
982 skb = priv->RcvCtl[ctx].skb;
983
984 // dlprintk((KERN_INFO MYNAM ": %s: dev_name = %s\n",
985 // IOC_AND_NETDEV_NAMES_s_s(dev)));
986 // dlprintk((KERN_INFO MYNAM "@rpr[2], priv = %p, buckets_out addr = %p",
987 // priv, &(priv->buckets_out)));
988 // dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3\n"));
989
990 priv->RcvCtl[ctx].skb = NULL;
991 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
992 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
993 dev_kfree_skb_any(skb);
994
995 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
996 }
997 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
998
999 atomic_sub(count, &priv->buckets_out);
1000
1001 // for (i = 0; i < priv->max_buckets_out; i++)
1002 // if (priv->RcvCtl[i].skb != NULL)
1003 // dlprintk((KERN_INFO MYNAM "@rpr: bucket %03x "
1004 // "is still out\n", i));
1005
1006 /* dlprintk((KERN_INFO MYNAM "/receive_post_reply: freed %d buckets\n",
1007 count));
1008 */
1009 /**/ dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
1010 /**/ "remaining, %d received back since sod.\n",
1011 /**/ atomic_read(&priv->buckets_out), priv->total_received));
1012 return 0;
1013 }
1014
1015 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1016 static int
1017 mpt_lan_receive_post_reply(struct net_device *dev,
1018 LANReceivePostReply_t *pRecvRep)
1019 {
1020 struct mpt_lan_priv *priv = dev->priv;
1021 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1022 struct sk_buff *skb, *old_skb;
1023 unsigned long flags;
1024 u32 len, ctx, offset;
1025 u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
1026 int count;
1027 int i, l;
1028
1029 dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply called\n"));
1030 dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04x\n",
1031 le16_to_cpu(pRecvRep->IOCStatus)));
1032
1033 if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
1034 MPI_IOCSTATUS_LAN_CANCELED)
1035 return mpt_lan_receive_post_free(dev, pRecvRep);
1036
1037 len = le32_to_cpu(pRecvRep->PacketLength);
1038 if (len == 0) {
1039 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
1040 "ReceivePostReply w/ PacketLength zero!\n",
1041 IOC_AND_NETDEV_NAMES_s_s(dev));
1042 printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04x\n",
1043 pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
1044 return -1;
1045 }
1046
1047 ctx = le32_to_cpu(pRecvRep->BucketContext[0]);
1048 count = pRecvRep->NumberOfContexts;
1049 skb = priv->RcvCtl[ctx].skb;
1050
1051 offset = le32_to_cpu(pRecvRep->PacketOffset);
1052 // if (offset != 0) {
1053 // printk (KERN_INFO MYNAM ": %s/%s: Got a ReceivePostReply "
1054 // "w/ PacketOffset %u\n",
1055 // IOC_AND_NETDEV_NAMES_s_s(dev),
1056 // offset);
1057 // }
1058
1059 dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %d\n",
1060 IOC_AND_NETDEV_NAMES_s_s(dev),
1061 offset, len));
1062
1063 if (count > 1) {
1064 int szrem = len;
1065
1066 // dioprintk((KERN_INFO MYNAM ": %s/%s: Multiple buckets returned "
1067 // "for single packet, concatenating...\n",
1068 // IOC_AND_NETDEV_NAMES_s_s(dev)));
1069
1070 skb = (struct sk_buff *)dev_alloc_skb(len);
1071 if (!skb) {
1072 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1073 IOC_AND_NETDEV_NAMES_s_s(dev),
1074 __FILE__, __LINE__);
1075 return -ENOMEM;
1076 }
1077
1078 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1079 for (i = 0; i < count; i++) {
1080
1081 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
1082 old_skb = priv->RcvCtl[ctx].skb;
1083
1084 l = priv->RcvCtl[ctx].len;
1085 if (szrem < l)
1086 l = szrem;
1087
1088 // dioprintk((KERN_INFO MYNAM ": %s/%s: Buckets = %d, len = %u\n",
1089 // IOC_AND_NETDEV_NAMES_s_s(dev),
1090 // i, l));
1091
1092 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1093 priv->RcvCtl[ctx].dma,
1094 priv->RcvCtl[ctx].len,
1095 PCI_DMA_FROMDEVICE);
1096 memcpy(skb_put(skb, l), old_skb->data, l);
1097
1098 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1099 priv->RcvCtl[ctx].dma,
1100 priv->RcvCtl[ctx].len,
1101 PCI_DMA_FROMDEVICE);
1102
1103 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1104 szrem -= l;
1105 }
1106 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1107
1108 } else if (len < MPT_LAN_RX_COPYBREAK) {
1109
1110 old_skb = skb;
1111
1112 skb = (struct sk_buff *)dev_alloc_skb(len);
1113 if (!skb) {
1114 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1115 IOC_AND_NETDEV_NAMES_s_s(dev),
1116 __FILE__, __LINE__);
1117 return -ENOMEM;
1118 }
1119
1120 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1121 priv->RcvCtl[ctx].dma,
1122 priv->RcvCtl[ctx].len,
1123 PCI_DMA_FROMDEVICE);
1124
1125 memcpy(skb_put(skb, len), old_skb->data, len);
1126
1127 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1128 priv->RcvCtl[ctx].dma,
1129 priv->RcvCtl[ctx].len,
1130 PCI_DMA_FROMDEVICE);
1131
1132 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1133 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1134 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1135
1136 } else {
1137 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1138
1139 priv->RcvCtl[ctx].skb = NULL;
1140
1141 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
1142 priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
1143 priv->RcvCtl[ctx].dma = 0;
1144
1145 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1146 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1147
1148 skb_put(skb,len);
1149 }
1150
1151 atomic_sub(count, &priv->buckets_out);
1152 priv->total_received += count;
1153
1154 if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
1155 printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
1156 "MPT_LAN_MAX_BUCKETS_OUT = %d\n",
1157 IOC_AND_NETDEV_NAMES_s_s(dev),
1158 priv->mpt_rxfidx_tail,
1159 MPT_LAN_MAX_BUCKETS_OUT);
1160
1161 panic("Damn it Jim! I'm a doctor, not a programmer! "
1162 "Oh, wait a sec, I am a programmer. "
1163 "And, who's Jim?!?!\n"
1164 "Arrgghh! We've done it again!\n");
1165 }
1166
1167 if (remaining == 0)
1168 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1169 "(priv->buckets_out = %d)\n",
1170 IOC_AND_NETDEV_NAMES_s_s(dev),
1171 atomic_read(&priv->buckets_out));
1172 else if (remaining < 10)
1173 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1174 "(priv->buckets_out = %d)\n",
1175 IOC_AND_NETDEV_NAMES_s_s(dev),
1176 remaining, atomic_read(&priv->buckets_out));
1177
1178 if ((remaining < priv->bucketthresh) &&
1179 ((atomic_read(&priv->buckets_out) - remaining) >
1180 MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1181
1182 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1183 "buckets_out count and fw's BucketsRemaining "
1184 "count has crossed the threshold, issuing a "
1185 "LanReset to clear the fw's hashtable. You may "
1186 "want to check your /var/log/messages for \"CRC "
1187 "error\" event notifications.\n");
1188
1189 mpt_lan_reset(dev);
1190 mpt_lan_wake_post_buckets_task(dev, 0);
1191 }
1192
1193 return mpt_lan_receive_skb(dev, skb);
1194 }
1195
1196 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1197 /* Simple SGE's only at the moment */
1198
1199 static void
1200 mpt_lan_post_receive_buckets(void *dev_id)
1201 {
1202 struct net_device *dev = dev_id;
1203 struct mpt_lan_priv *priv = dev->priv;
1204 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1205 MPT_FRAME_HDR *mf;
1206 LANReceivePostRequest_t *pRecvReq;
1207 SGETransaction32_t *pTrans;
1208 SGESimple64_t *pSimple;
1209 struct sk_buff *skb;
1210 dma_addr_t dma;
1211 u32 curr, buckets, count, max;
1212 u32 len = (dev->mtu + dev->hard_header_len + 4);
1213 unsigned long flags;
1214 int i;
1215
1216 curr = atomic_read(&priv->buckets_out);
1217 buckets = (priv->max_buckets_out - curr);
1218
1219 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
1220 IOC_AND_NETDEV_NAMES_s_s(dev),
1221 __FUNCTION__, buckets, curr));
1222
1223 max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
1224 (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
1225
1226 while (buckets) {
1227 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
1228 if (mf == NULL) {
1229 printk (KERN_ERR "%s: Unable to alloc request frame\n",
1230 __FUNCTION__);
1231 dioprintk((KERN_ERR "%s: %u buckets remaining\n",
1232 __FUNCTION__, buckets));
1233 goto out;
1234 }
1235 pRecvReq = (LANReceivePostRequest_t *) mf;
1236
1237 count = buckets;
1238 if (count > max)
1239 count = max;
1240
1241 pRecvReq->Function = MPI_FUNCTION_LAN_RECEIVE;
1242 pRecvReq->ChainOffset = 0;
1243 pRecvReq->MsgFlags = 0;
1244 pRecvReq->PortNumber = priv->pnum;
1245
1246 pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
1247 pSimple = NULL;
1248
1249 for (i = 0; i < count; i++) {
1250 int ctx;
1251
1252 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1253 if (priv->mpt_rxfidx_tail < 0) {
1254 printk (KERN_ERR "%s: Can't alloc context\n",
1255 __FUNCTION__);
1256 spin_unlock_irqrestore(&priv->rxfidx_lock,
1257 flags);
1258 break;
1259 }
1260
1261 ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
1262
1263 skb = priv->RcvCtl[ctx].skb;
1264 if (skb && (priv->RcvCtl[ctx].len != len)) {
1265 pci_unmap_single(mpt_dev->pcidev,
1266 priv->RcvCtl[ctx].dma,
1267 priv->RcvCtl[ctx].len,
1268 PCI_DMA_FROMDEVICE);
1269 dev_kfree_skb(priv->RcvCtl[ctx].skb);
1270 skb = priv->RcvCtl[ctx].skb = NULL;
1271 }
1272
1273 if (skb == NULL) {
1274 skb = dev_alloc_skb(len);
1275 if (skb == NULL) {
1276 printk (KERN_WARNING
1277 MYNAM "/%s: Can't alloc skb\n",
1278 __FUNCTION__);
1279 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1280 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1281 break;
1282 }
1283
1284 dma = pci_map_single(mpt_dev->pcidev, skb->data,
1285 len, PCI_DMA_FROMDEVICE);
1286
1287 priv->RcvCtl[ctx].skb = skb;
1288 priv->RcvCtl[ctx].dma = dma;
1289 priv->RcvCtl[ctx].len = len;
1290 }
1291
1292 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1293
1294 pTrans->ContextSize = sizeof(u32);
1295 pTrans->DetailsLength = 0;
1296 pTrans->Flags = 0;
1297 pTrans->TransactionContext[0] = cpu_to_le32(ctx);
1298
1299 pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
1300
1301 pSimple->FlagsLength = cpu_to_le32(
1302 ((MPI_SGE_FLAGS_END_OF_BUFFER |
1303 MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1304 MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
1305 pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
1306 if (sizeof(dma_addr_t) > sizeof(u32))
1307 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
1308 else
1309 pSimple->Address.High = 0;
1310
1311 pTrans = (SGETransaction32_t *) (pSimple + 1);
1312 }
1313
1314 if (pSimple == NULL) {
1315 /**/ printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
1316 /**/ __FUNCTION__);
1317 mpt_free_msg_frame(mpt_dev, mf);
1318 goto out;
1319 }
1320
1321 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
1322
1323 pRecvReq->BucketCount = cpu_to_le32(i);
1324
1325 /* printk(KERN_INFO MYNAM ": posting buckets\n ");
1326 * for (i = 0; i < j + 2; i ++)
1327 * printk (" %08x", le32_to_cpu(msg[i]));
1328 * printk ("\n");
1329 */
1330
1331 mpt_put_msg_frame(LanCtx, mpt_dev, mf);
1332
1333 priv->total_posted += i;
1334 buckets -= i;
1335 atomic_add(i, &priv->buckets_out);
1336 }
1337
1338 out:
1339 dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
1340 __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
1341 dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
1342 __FUNCTION__, priv->total_posted, priv->total_received));
1343
1344 clear_bit(0, &priv->post_buckets_active);
1345 }
1346
1347 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1348 static struct net_device *
1349 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1350 {
1351 struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1352 struct mpt_lan_priv *priv = NULL;
1353 u8 HWaddr[FC_ALEN], *a;
1354
1355 if (!dev)
1356 return NULL;
1357
1358 dev->mtu = MPT_LAN_MTU;
1359
1360 priv = netdev_priv(dev);
1361
1362 priv->mpt_dev = mpt_dev;
1363 priv->pnum = pnum;
1364
1365 memset(&priv->post_buckets_task, 0, sizeof(struct work_struct));
1366 INIT_WORK(&priv->post_buckets_task, mpt_lan_post_receive_buckets, dev);
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 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
kernel-based virtual machine