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