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