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