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