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