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