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