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