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