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 work_struct post_buckets_task; 115 unsigned long post_buckets_active; 116 }; 117 118 struct mpt_lan_ohdr { 119 u16 dtype; 120 u8 daddr[FC_ALEN]; 121 u16 stype; 122 u8 saddr[FC_ALEN]; 123 }; 124 125 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 126 127 /* 128 * Forward protos... 129 */ 130 static int lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, 131 MPT_FRAME_HDR *reply); 132 static int mpt_lan_open(struct net_device *dev); 133 static int mpt_lan_reset(struct net_device *dev); 134 static int mpt_lan_close(struct net_device *dev); 135 static void mpt_lan_post_receive_buckets(void *dev_id); 136 static void mpt_lan_wake_post_buckets_task(struct net_device *dev, 137 int priority); 138 static int mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg); 139 static int mpt_lan_receive_post_reply(struct net_device *dev, 140 LANReceivePostReply_t *pRecvRep); 141 static int mpt_lan_send_turbo(struct net_device *dev, u32 tmsg); 142 static int mpt_lan_send_reply(struct net_device *dev, 143 LANSendReply_t *pSendRep); 144 static int mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase); 145 static int mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply); 146 static unsigned short mpt_lan_type_trans(struct sk_buff *skb, 147 struct net_device *dev); 148 149 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 150 /* 151 * Fusion MPT LAN private data 152 */ 153 static int LanCtx = -1; 154 155 static u32 max_buckets_out = 127; 156 static u32 tx_max_out_p = 127 - 16; 157 158 #ifdef QLOGIC_NAA_WORKAROUND 159 static struct NAA_Hosed *mpt_bad_naa = NULL; 160 DEFINE_RWLOCK(bad_naa_lock); 161 #endif 162 163 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 164 /* 165 * Fusion MPT LAN external data 166 */ 167 extern int mpt_lan_index; 168 169 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 170 /** 171 * lan_reply - Handle all data sent from the hardware. 172 * @ioc: Pointer to MPT_ADAPTER structure 173 * @mf: Pointer to original MPT request frame (NULL if TurboReply) 174 * @reply: Pointer to MPT reply frame 175 * 176 * Returns 1 indicating original alloc'd request frame ptr 177 * should be freed, or 0 if it shouldn't. 178 */ 179 static int 180 lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply) 181 { 182 struct net_device *dev = ioc->netdev; 183 int FreeReqFrame = 0; 184 185 dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.\n", 186 IOC_AND_NETDEV_NAMES_s_s(dev))); 187 188 // dioprintk((KERN_INFO MYNAM "@lan_reply: mf = %p, reply = %p\n", 189 // mf, reply)); 190 191 if (mf == NULL) { 192 u32 tmsg = CAST_PTR_TO_U32(reply); 193 194 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n", 195 IOC_AND_NETDEV_NAMES_s_s(dev), 196 tmsg)); 197 198 switch (GET_LAN_FORM(tmsg)) { 199 200 // NOTE! (Optimization) First case here is now caught in 201 // mptbase.c::mpt_interrupt() routine and callcack here 202 // is now skipped for this case! 203 #if 0 204 case LAN_REPLY_FORM_MESSAGE_CONTEXT: 205 // dioprintk((KERN_INFO MYNAM "/lan_reply: " 206 // "MessageContext turbo reply received\n")); 207 FreeReqFrame = 1; 208 break; 209 #endif 210 211 case LAN_REPLY_FORM_SEND_SINGLE: 212 // dioprintk((MYNAM "/lan_reply: " 213 // "calling mpt_lan_send_reply (turbo)\n")); 214 215 // Potential BUG here? 216 // FreeReqFrame = mpt_lan_send_turbo(dev, tmsg); 217 // If/when mpt_lan_send_turbo would return 1 here, 218 // calling routine (mptbase.c|mpt_interrupt) 219 // would Oops because mf has already been set 220 // to NULL. So after return from this func, 221 // mpt_interrupt() will attempt to put (NULL) mf ptr 222 // item back onto its adapter FreeQ - Oops!:-( 223 // It's Ok, since mpt_lan_send_turbo() *currently* 224 // always returns 0, but..., just in case: 225 226 (void) mpt_lan_send_turbo(dev, tmsg); 227 FreeReqFrame = 0; 228 229 break; 230 231 case LAN_REPLY_FORM_RECEIVE_SINGLE: 232 // dioprintk((KERN_INFO MYNAM "@lan_reply: " 233 // "rcv-Turbo = %08x\n", tmsg)); 234 mpt_lan_receive_post_turbo(dev, tmsg); 235 break; 236 237 default: 238 printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply " 239 "that I don't know what to do with\n"); 240 241 /* CHECKME! Hmmm... FreeReqFrame is 0 here; is that right? */ 242 243 break; 244 } 245 246 return FreeReqFrame; 247 } 248 249 // msg = (u32 *) reply; 250 // dioprintk((KERN_INFO MYNAM "@lan_reply: msg = %08x %08x %08x %08x\n", 251 // le32_to_cpu(msg[0]), le32_to_cpu(msg[1]), 252 // le32_to_cpu(msg[2]), le32_to_cpu(msg[3]))); 253 // dioprintk((KERN_INFO MYNAM "@lan_reply: Function = %02xh\n", 254 // reply->u.hdr.Function)); 255 256 switch (reply->u.hdr.Function) { 257 258 case MPI_FUNCTION_LAN_SEND: 259 { 260 LANSendReply_t *pSendRep; 261 262 pSendRep = (LANSendReply_t *) reply; 263 FreeReqFrame = mpt_lan_send_reply(dev, pSendRep); 264 break; 265 } 266 267 case MPI_FUNCTION_LAN_RECEIVE: 268 { 269 LANReceivePostReply_t *pRecvRep; 270 271 pRecvRep = (LANReceivePostReply_t *) reply; 272 if (pRecvRep->NumberOfContexts) { 273 mpt_lan_receive_post_reply(dev, pRecvRep); 274 if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY)) 275 FreeReqFrame = 1; 276 } else 277 dioprintk((KERN_INFO MYNAM "@lan_reply: zero context " 278 "ReceivePostReply received.\n")); 279 break; 280 } 281 282 case MPI_FUNCTION_LAN_RESET: 283 /* Just a default reply. Might want to check it to 284 * make sure that everything went ok. 285 */ 286 FreeReqFrame = 1; 287 break; 288 289 case MPI_FUNCTION_EVENT_NOTIFICATION: 290 case MPI_FUNCTION_EVENT_ACK: 291 /* _EVENT_NOTIFICATION should NOT come down this path any more. 292 * Should be routed to mpt_lan_event_process(), but just in case... 293 */ 294 FreeReqFrame = 1; 295 break; 296 297 default: 298 printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo " 299 "reply that I don't know what to do with\n"); 300 301 /* CHECKME! Hmmm... FreeReqFrame is 0 here; is that right? */ 302 FreeReqFrame = 1; 303 304 break; 305 } 306 307 return FreeReqFrame; 308 } 309 310 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 311 static int 312 mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 313 { 314 struct net_device *dev = ioc->netdev; 315 struct mpt_lan_priv *priv = netdev_priv(dev); 316 317 dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!\n", 318 reset_phase==MPT_IOC_SETUP_RESET ? "setup" : ( 319 reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post"))); 320 321 if (priv->mpt_rxfidx == NULL) 322 return (1); 323 324 if (reset_phase == MPT_IOC_SETUP_RESET) { 325 ; 326 } else if (reset_phase == MPT_IOC_PRE_RESET) { 327 int i; 328 unsigned long flags; 329 330 netif_stop_queue(dev); 331 332 dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.\n", dev->name)); 333 334 atomic_set(&priv->buckets_out, 0); 335 336 /* Reset Rx Free Tail index and re-populate the queue. */ 337 spin_lock_irqsave(&priv->rxfidx_lock, flags); 338 priv->mpt_rxfidx_tail = -1; 339 for (i = 0; i < priv->max_buckets_out; i++) 340 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i; 341 spin_unlock_irqrestore(&priv->rxfidx_lock, flags); 342 } else { 343 mpt_lan_post_receive_buckets(dev); 344 netif_wake_queue(dev); 345 } 346 347 return 1; 348 } 349 350 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 351 static int 352 mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply) 353 { 354 dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!\n")); 355 356 switch (le32_to_cpu(pEvReply->Event)) { 357 case MPI_EVENT_NONE: /* 00 */ 358 case MPI_EVENT_LOG_DATA: /* 01 */ 359 case MPI_EVENT_STATE_CHANGE: /* 02 */ 360 case MPI_EVENT_UNIT_ATTENTION: /* 03 */ 361 case MPI_EVENT_IOC_BUS_RESET: /* 04 */ 362 case MPI_EVENT_EXT_BUS_RESET: /* 05 */ 363 case MPI_EVENT_RESCAN: /* 06 */ 364 /* Ok, do we need to do anything here? As far as 365 I can tell, this is when a new device gets added 366 to the loop. */ 367 case MPI_EVENT_LINK_STATUS_CHANGE: /* 07 */ 368 case MPI_EVENT_LOOP_STATE_CHANGE: /* 08 */ 369 case MPI_EVENT_LOGOUT: /* 09 */ 370 case MPI_EVENT_EVENT_CHANGE: /* 0A */ 371 default: 372 break; 373 } 374 375 /* 376 * NOTE: pEvent->AckRequired handling now done in mptbase.c; 377 * Do NOT do it here now! 378 */ 379 380 return 1; 381 } 382 383 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 384 static int 385 mpt_lan_open(struct net_device *dev) 386 { 387 struct mpt_lan_priv *priv = netdev_priv(dev); 388 int i; 389 390 if (mpt_lan_reset(dev) != 0) { 391 MPT_ADAPTER *mpt_dev = priv->mpt_dev; 392 393 printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed."); 394 395 if (mpt_dev->active) 396 printk ("The ioc is active. Perhaps it needs to be" 397 " reset?\n"); 398 else 399 printk ("The ioc in inactive, most likely in the " 400 "process of being reset. Please try again in " 401 "a moment.\n"); 402 } 403 404 priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL); 405 if (priv->mpt_txfidx == NULL) 406 goto out; 407 priv->mpt_txfidx_tail = -1; 408 409 priv->SendCtl = kmalloc(priv->tx_max_out * sizeof(struct BufferControl), 410 GFP_KERNEL); 411 if (priv->SendCtl == NULL) 412 goto out_mpt_txfidx; 413 for (i = 0; i < priv->tx_max_out; i++) { 414 memset(&priv->SendCtl[i], 0, sizeof(struct BufferControl)); 415 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i; 416 } 417 418 dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n")); 419 420 priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int), 421 GFP_KERNEL); 422 if (priv->mpt_rxfidx == NULL) 423 goto out_SendCtl; 424 priv->mpt_rxfidx_tail = -1; 425 426 priv->RcvCtl = kmalloc(priv->max_buckets_out * 427 sizeof(struct BufferControl), 428 GFP_KERNEL); 429 if (priv->RcvCtl == NULL) 430 goto out_mpt_rxfidx; 431 for (i = 0; i < priv->max_buckets_out; i++) { 432 memset(&priv->RcvCtl[i], 0, sizeof(struct BufferControl)); 433 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i; 434 } 435 436 /**/ dlprintk((KERN_INFO MYNAM "/lo: txfidx contains - ")); 437 /**/ for (i = 0; i < priv->tx_max_out; i++) 438 /**/ dlprintk((" %xh", priv->mpt_txfidx[i])); 439 /**/ dlprintk(("\n")); 440 441 dlprintk((KERN_INFO MYNAM "/lo: Finished initializing RcvCtl\n")); 442 443 mpt_lan_post_receive_buckets(dev); 444 printk(KERN_INFO MYNAM ": %s/%s: interface up & active\n", 445 IOC_AND_NETDEV_NAMES_s_s(dev)); 446 447 if (mpt_event_register(LanCtx, mpt_lan_event_process) != 0) { 448 printk (KERN_WARNING MYNAM "/lo: Unable to register for Event" 449 " Notifications. This is a bad thing! We're not going " 450 "to go ahead, but I'd be leery of system stability at " 451 "this point.\n"); 452 } 453 454 netif_start_queue(dev); 455 dlprintk((KERN_INFO MYNAM "/lo: Done.\n")); 456 457 return 0; 458 out_mpt_rxfidx: 459 kfree(priv->mpt_rxfidx); 460 priv->mpt_rxfidx = NULL; 461 out_SendCtl: 462 kfree(priv->SendCtl); 463 priv->SendCtl = NULL; 464 out_mpt_txfidx: 465 kfree(priv->mpt_txfidx); 466 priv->mpt_txfidx = NULL; 467 out: return -ENOMEM; 468 } 469 470 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 471 /* Send a LanReset message to the FW. This should result in the FW returning 472 any buckets it still has. */ 473 static int 474 mpt_lan_reset(struct net_device *dev) 475 { 476 MPT_FRAME_HDR *mf; 477 LANResetRequest_t *pResetReq; 478 struct mpt_lan_priv *priv = netdev_priv(dev); 479 480 mf = mpt_get_msg_frame(LanCtx, priv->mpt_dev); 481 482 if (mf == NULL) { 483 /* dlprintk((KERN_ERR MYNAM "/reset: Evil funkiness abounds! " 484 "Unable to allocate a request frame.\n")); 485 */ 486 return -1; 487 } 488 489 pResetReq = (LANResetRequest_t *) mf; 490 491 pResetReq->Function = MPI_FUNCTION_LAN_RESET; 492 pResetReq->ChainOffset = 0; 493 pResetReq->Reserved = 0; 494 pResetReq->PortNumber = priv->pnum; 495 pResetReq->MsgFlags = 0; 496 pResetReq->Reserved2 = 0; 497 498 mpt_put_msg_frame(LanCtx, priv->mpt_dev, mf); 499 500 return 0; 501 } 502 503 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 504 static int 505 mpt_lan_close(struct net_device *dev) 506 { 507 struct mpt_lan_priv *priv = netdev_priv(dev); 508 MPT_ADAPTER *mpt_dev = priv->mpt_dev; 509 unsigned int timeout; 510 int i; 511 512 dlprintk((KERN_INFO MYNAM ": mpt_lan_close called\n")); 513 514 mpt_event_deregister(LanCtx); 515 516 dlprintk((KERN_INFO MYNAM ":lan_close: Posted %d buckets " 517 "since driver was loaded, %d still out\n", 518 priv->total_posted,atomic_read(&priv->buckets_out))); 519 520 netif_stop_queue(dev); 521 522 mpt_lan_reset(dev); 523 524 timeout = 2 * HZ; 525 while (atomic_read(&priv->buckets_out) && --timeout) { 526 set_current_state(TASK_INTERRUPTIBLE); 527 schedule_timeout(1); 528 } 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 inline 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_work(&priv->post_buckets_task); 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 inline 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 panic("Damn it Jim! I'm a doctor, not a programmer! " 1157 "Oh, wait a sec, I am a programmer. " 1158 "And, who's Jim?!?!\n" 1159 "Arrgghh! We've done it again!\n"); 1160 } 1161 1162 if (remaining == 0) 1163 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! " 1164 "(priv->buckets_out = %d)\n", 1165 IOC_AND_NETDEV_NAMES_s_s(dev), 1166 atomic_read(&priv->buckets_out)); 1167 else if (remaining < 10) 1168 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. " 1169 "(priv->buckets_out = %d)\n", 1170 IOC_AND_NETDEV_NAMES_s_s(dev), 1171 remaining, atomic_read(&priv->buckets_out)); 1172 1173 if ((remaining < priv->bucketthresh) && 1174 ((atomic_read(&priv->buckets_out) - remaining) > 1175 MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) { 1176 1177 printk (KERN_WARNING MYNAM " Mismatch between driver's " 1178 "buckets_out count and fw's BucketsRemaining " 1179 "count has crossed the threshold, issuing a " 1180 "LanReset to clear the fw's hashtable. You may " 1181 "want to check your /var/log/messages for \"CRC " 1182 "error\" event notifications.\n"); 1183 1184 mpt_lan_reset(dev); 1185 mpt_lan_wake_post_buckets_task(dev, 0); 1186 } 1187 1188 return mpt_lan_receive_skb(dev, skb); 1189 } 1190 1191 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1192 /* Simple SGE's only at the moment */ 1193 1194 static void 1195 mpt_lan_post_receive_buckets(void *dev_id) 1196 { 1197 struct net_device *dev = dev_id; 1198 struct mpt_lan_priv *priv = dev->priv; 1199 MPT_ADAPTER *mpt_dev = priv->mpt_dev; 1200 MPT_FRAME_HDR *mf; 1201 LANReceivePostRequest_t *pRecvReq; 1202 SGETransaction32_t *pTrans; 1203 SGESimple64_t *pSimple; 1204 struct sk_buff *skb; 1205 dma_addr_t dma; 1206 u32 curr, buckets, count, max; 1207 u32 len = (dev->mtu + dev->hard_header_len + 4); 1208 unsigned long flags; 1209 int i; 1210 1211 curr = atomic_read(&priv->buckets_out); 1212 buckets = (priv->max_buckets_out - curr); 1213 1214 dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n", 1215 IOC_AND_NETDEV_NAMES_s_s(dev), 1216 __FUNCTION__, buckets, curr)); 1217 1218 max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) / 1219 (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t)); 1220 1221 while (buckets) { 1222 mf = mpt_get_msg_frame(LanCtx, mpt_dev); 1223 if (mf == NULL) { 1224 printk (KERN_ERR "%s: Unable to alloc request frame\n", 1225 __FUNCTION__); 1226 dioprintk((KERN_ERR "%s: %u buckets remaining\n", 1227 __FUNCTION__, buckets)); 1228 goto out; 1229 } 1230 pRecvReq = (LANReceivePostRequest_t *) mf; 1231 1232 count = buckets; 1233 if (count > max) 1234 count = max; 1235 1236 pRecvReq->Function = MPI_FUNCTION_LAN_RECEIVE; 1237 pRecvReq->ChainOffset = 0; 1238 pRecvReq->MsgFlags = 0; 1239 pRecvReq->PortNumber = priv->pnum; 1240 1241 pTrans = (SGETransaction32_t *) pRecvReq->SG_List; 1242 pSimple = NULL; 1243 1244 for (i = 0; i < count; i++) { 1245 int ctx; 1246 1247 spin_lock_irqsave(&priv->rxfidx_lock, flags); 1248 if (priv->mpt_rxfidx_tail < 0) { 1249 printk (KERN_ERR "%s: Can't alloc context\n", 1250 __FUNCTION__); 1251 spin_unlock_irqrestore(&priv->rxfidx_lock, 1252 flags); 1253 break; 1254 } 1255 1256 ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--]; 1257 1258 skb = priv->RcvCtl[ctx].skb; 1259 if (skb && (priv->RcvCtl[ctx].len != len)) { 1260 pci_unmap_single(mpt_dev->pcidev, 1261 priv->RcvCtl[ctx].dma, 1262 priv->RcvCtl[ctx].len, 1263 PCI_DMA_FROMDEVICE); 1264 dev_kfree_skb(priv->RcvCtl[ctx].skb); 1265 skb = priv->RcvCtl[ctx].skb = NULL; 1266 } 1267 1268 if (skb == NULL) { 1269 skb = dev_alloc_skb(len); 1270 if (skb == NULL) { 1271 printk (KERN_WARNING 1272 MYNAM "/%s: Can't alloc skb\n", 1273 __FUNCTION__); 1274 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx; 1275 spin_unlock_irqrestore(&priv->rxfidx_lock, flags); 1276 break; 1277 } 1278 1279 dma = pci_map_single(mpt_dev->pcidev, skb->data, 1280 len, PCI_DMA_FROMDEVICE); 1281 1282 priv->RcvCtl[ctx].skb = skb; 1283 priv->RcvCtl[ctx].dma = dma; 1284 priv->RcvCtl[ctx].len = len; 1285 } 1286 1287 spin_unlock_irqrestore(&priv->rxfidx_lock, flags); 1288 1289 pTrans->ContextSize = sizeof(u32); 1290 pTrans->DetailsLength = 0; 1291 pTrans->Flags = 0; 1292 pTrans->TransactionContext[0] = cpu_to_le32(ctx); 1293 1294 pSimple = (SGESimple64_t *) pTrans->TransactionDetails; 1295 1296 pSimple->FlagsLength = cpu_to_le32( 1297 ((MPI_SGE_FLAGS_END_OF_BUFFER | 1298 MPI_SGE_FLAGS_SIMPLE_ELEMENT | 1299 MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len); 1300 pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma); 1301 if (sizeof(dma_addr_t) > sizeof(u32)) 1302 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32)); 1303 else 1304 pSimple->Address.High = 0; 1305 1306 pTrans = (SGETransaction32_t *) (pSimple + 1); 1307 } 1308 1309 if (pSimple == NULL) { 1310 /**/ printk (KERN_WARNING MYNAM "/%s: No buckets posted\n", 1311 /**/ __FUNCTION__); 1312 mpt_free_msg_frame(mpt_dev, mf); 1313 goto out; 1314 } 1315 1316 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT); 1317 1318 pRecvReq->BucketCount = cpu_to_le32(i); 1319 1320 /* printk(KERN_INFO MYNAM ": posting buckets\n "); 1321 * for (i = 0; i < j + 2; i ++) 1322 * printk (" %08x", le32_to_cpu(msg[i])); 1323 * printk ("\n"); 1324 */ 1325 1326 mpt_put_msg_frame(LanCtx, mpt_dev, mf); 1327 1328 priv->total_posted += i; 1329 buckets -= i; 1330 atomic_add(i, &priv->buckets_out); 1331 } 1332 1333 out: 1334 dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n", 1335 __FUNCTION__, buckets, atomic_read(&priv->buckets_out))); 1336 dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n", 1337 __FUNCTION__, priv->total_posted, priv->total_received)); 1338 1339 clear_bit(0, &priv->post_buckets_active); 1340 } 1341 1342 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1343 static struct net_device * 1344 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum) 1345 { 1346 struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv)); 1347 struct mpt_lan_priv *priv = NULL; 1348 u8 HWaddr[FC_ALEN], *a; 1349 1350 if (!dev) 1351 return NULL; 1352 1353 dev->mtu = MPT_LAN_MTU; 1354 1355 priv = netdev_priv(dev); 1356 1357 priv->mpt_dev = mpt_dev; 1358 priv->pnum = pnum; 1359 1360 memset(&priv->post_buckets_task, 0, sizeof(struct work_struct)); 1361 INIT_WORK(&priv->post_buckets_task, mpt_lan_post_receive_buckets, dev); 1362 priv->post_buckets_active = 0; 1363 1364 dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n", 1365 __LINE__, dev->mtu + dev->hard_header_len + 4)); 1366 1367 atomic_set(&priv->buckets_out, 0); 1368 priv->total_posted = 0; 1369 priv->total_received = 0; 1370 priv->max_buckets_out = max_buckets_out; 1371 if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out) 1372 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets; 1373 1374 dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n", 1375 __LINE__, 1376 mpt_dev->pfacts[0].MaxLanBuckets, 1377 max_buckets_out, 1378 priv->max_buckets_out)); 1379 1380 priv->bucketthresh = priv->max_buckets_out * 2 / 3; 1381 spin_lock_init(&priv->txfidx_lock); 1382 spin_lock_init(&priv->rxfidx_lock); 1383 1384 memset(&priv->stats, 0, sizeof(priv->stats)); 1385 1386 /* Grab pre-fetched LANPage1 stuff. :-) */ 1387 a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow; 1388 1389 HWaddr[0] = a[5]; 1390 HWaddr[1] = a[4]; 1391 HWaddr[2] = a[3]; 1392 HWaddr[3] = a[2]; 1393 HWaddr[4] = a[1]; 1394 HWaddr[5] = a[0]; 1395 1396 dev->addr_len = FC_ALEN; 1397 memcpy(dev->dev_addr, HWaddr, FC_ALEN); 1398 memset(dev->broadcast, 0xff, FC_ALEN); 1399 1400 /* The Tx queue is 127 deep on the 909. 1401 * Give ourselves some breathing room. 1402 */ 1403 priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ? 1404 tx_max_out_p : MPT_TX_MAX_OUT_LIM; 1405 1406 dev->open = mpt_lan_open; 1407 dev->stop = mpt_lan_close; 1408 dev->get_stats = mpt_lan_get_stats; 1409 dev->set_multicast_list = NULL; 1410 dev->change_mtu = mpt_lan_change_mtu; 1411 dev->hard_start_xmit = mpt_lan_sdu_send; 1412 1413 /* Not in 2.3.42. Need 2.3.45+ */ 1414 dev->tx_timeout = mpt_lan_tx_timeout; 1415 dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT; 1416 1417 dlprintk((KERN_INFO MYNAM ": Finished registering dev " 1418 "and setting initial values\n")); 1419 1420 SET_MODULE_OWNER(dev); 1421 1422 if (register_netdev(dev) != 0) { 1423 free_netdev(dev); 1424 dev = NULL; 1425 } 1426 return dev; 1427 } 1428 1429 static int 1430 mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id) 1431 { 1432 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1433 struct net_device *dev; 1434 int i; 1435 1436 for (i = 0; i < ioc->facts.NumberOfPorts; i++) { 1437 printk(KERN_INFO MYNAM ": %s: PortNum=%x, " 1438 "ProtocolFlags=%02Xh (%c%c%c%c)\n", 1439 ioc->name, ioc->pfacts[i].PortNumber, 1440 ioc->pfacts[i].ProtocolFlags, 1441 MPT_PROTOCOL_FLAGS_c_c_c_c( 1442 ioc->pfacts[i].ProtocolFlags)); 1443 1444 if (!(ioc->pfacts[i].ProtocolFlags & 1445 MPI_PORTFACTS_PROTOCOL_LAN)) { 1446 printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol " 1447 "seems to be disabled on this adapter port!\n", 1448 ioc->name); 1449 continue; 1450 } 1451 1452 dev = mpt_register_lan_device(ioc, i); 1453 if (!dev) { 1454 printk(KERN_ERR MYNAM ": %s: Unable to register " 1455 "port%d as a LAN device\n", ioc->name, 1456 ioc->pfacts[i].PortNumber); 1457 continue; 1458 } 1459 1460 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device " 1461 "registered as '%s'\n", ioc->name, dev->name); 1462 printk(KERN_INFO MYNAM ": %s/%s: " 1463 "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n", 1464 IOC_AND_NETDEV_NAMES_s_s(dev), 1465 dev->dev_addr[0], dev->dev_addr[1], 1466 dev->dev_addr[2], dev->dev_addr[3], 1467 dev->dev_addr[4], dev->dev_addr[5]); 1468 1469 ioc->netdev = dev; 1470 1471 return 0; 1472 } 1473 1474 return -ENODEV; 1475 } 1476 1477 static void 1478 mptlan_remove(struct pci_dev *pdev) 1479 { 1480 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 1481 struct net_device *dev = ioc->netdev; 1482 1483 if(dev != NULL) { 1484 unregister_netdev(dev); 1485 free_netdev(dev); 1486 } 1487 } 1488 1489 static struct mpt_pci_driver mptlan_driver = { 1490 .probe = mptlan_probe, 1491 .remove = mptlan_remove, 1492 }; 1493 1494 static int __init mpt_lan_init (void) 1495 { 1496 show_mptmod_ver(LANAME, LANVER); 1497 1498 if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) { 1499 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n"); 1500 return -EBUSY; 1501 } 1502 1503 /* Set the callback index to be used by driver core for turbo replies */ 1504 mpt_lan_index = LanCtx; 1505 1506 dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx)); 1507 1508 if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) { 1509 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset " 1510 "handler with mptbase! The world is at an end! " 1511 "Everything is fading to black! Goodbye.\n"); 1512 return -EBUSY; 1513 } 1514 1515 dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n")); 1516 1517 if (mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER)) 1518 dprintk((KERN_INFO MYNAM ": failed to register dd callbacks\n")); 1519 return 0; 1520 } 1521 1522 static void __exit mpt_lan_exit(void) 1523 { 1524 mpt_device_driver_deregister(MPTLAN_DRIVER); 1525 mpt_reset_deregister(LanCtx); 1526 1527 if (LanCtx >= 0) { 1528 mpt_deregister(LanCtx); 1529 LanCtx = -1; 1530 mpt_lan_index = 0; 1531 } 1532 } 1533 1534 module_init(mpt_lan_init); 1535 module_exit(mpt_lan_exit); 1536 1537 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1538 static unsigned short 1539 mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev) 1540 { 1541 struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data; 1542 struct fcllc *fcllc; 1543 1544 skb->mac.raw = skb->data; 1545 skb_pull(skb, sizeof(struct mpt_lan_ohdr)); 1546 1547 if (fch->dtype == htons(0xffff)) { 1548 u32 *p = (u32 *) fch; 1549 1550 swab32s(p + 0); 1551 swab32s(p + 1); 1552 swab32s(p + 2); 1553 swab32s(p + 3); 1554 1555 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n", 1556 NETDEV_PTR_TO_IOC_NAME_s(dev)); 1557 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02x\n", 1558 fch->saddr[0], fch->saddr[1], fch->saddr[2], 1559 fch->saddr[3], fch->saddr[4], fch->saddr[5]); 1560 } 1561 1562 if (*fch->daddr & 1) { 1563 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) { 1564 skb->pkt_type = PACKET_BROADCAST; 1565 } else { 1566 skb->pkt_type = PACKET_MULTICAST; 1567 } 1568 } else { 1569 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) { 1570 skb->pkt_type = PACKET_OTHERHOST; 1571 } else { 1572 skb->pkt_type = PACKET_HOST; 1573 } 1574 } 1575 1576 fcllc = (struct fcllc *)skb->data; 1577 1578 #ifdef QLOGIC_NAA_WORKAROUND 1579 { 1580 u16 source_naa = fch->stype, found = 0; 1581 1582 /* Workaround for QLogic not following RFC 2625 in regards to the NAA 1583 value. */ 1584 1585 if ((source_naa & 0xF000) == 0) 1586 source_naa = swab16(source_naa); 1587 1588 if (fcllc->ethertype == htons(ETH_P_ARP)) 1589 dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of " 1590 "%04x.\n", source_naa)); 1591 1592 if ((fcllc->ethertype == htons(ETH_P_ARP)) && 1593 ((source_naa >> 12) != MPT_LAN_NAA_RFC2625)){ 1594 struct NAA_Hosed *nh, *prevnh; 1595 int i; 1596 1597 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from " 1598 "system with non-RFC 2625 NAA value (%04x).\n", 1599 source_naa)); 1600 1601 write_lock_irq(&bad_naa_lock); 1602 for (prevnh = nh = mpt_bad_naa; nh != NULL; 1603 prevnh=nh, nh=nh->next) { 1604 if ((nh->ieee[0] == fch->saddr[0]) && 1605 (nh->ieee[1] == fch->saddr[1]) && 1606 (nh->ieee[2] == fch->saddr[2]) && 1607 (nh->ieee[3] == fch->saddr[3]) && 1608 (nh->ieee[4] == fch->saddr[4]) && 1609 (nh->ieee[5] == fch->saddr[5])) { 1610 found = 1; 1611 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re" 1612 "q/Rep w/ bad NAA from system already" 1613 " in DB.\n")); 1614 break; 1615 } 1616 } 1617 1618 if ((!found) && (nh == NULL)) { 1619 1620 nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL); 1621 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/" 1622 " bad NAA from system not yet in DB.\n")); 1623 1624 if (nh != NULL) { 1625 nh->next = NULL; 1626 if (!mpt_bad_naa) 1627 mpt_bad_naa = nh; 1628 if (prevnh) 1629 prevnh->next = nh; 1630 1631 nh->NAA = source_naa; /* Set the S_NAA value. */ 1632 for (i = 0; i < FC_ALEN; i++) 1633 nh->ieee[i] = fch->saddr[i]; 1634 dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:" 1635 "%02x:%02x with non-compliant S_NAA value.\n", 1636 fch->saddr[0], fch->saddr[1], fch->saddr[2], 1637 fch->saddr[3], fch->saddr[4],fch->saddr[5])); 1638 } else { 1639 printk (KERN_ERR "mptlan/type_trans: Unable to" 1640 " kmalloc a NAA_Hosed struct.\n"); 1641 } 1642 } else if (!found) { 1643 printk (KERN_ERR "mptlan/type_trans: found not" 1644 " set, but nh isn't null. Evil " 1645 "funkiness abounds.\n"); 1646 } 1647 write_unlock_irq(&bad_naa_lock); 1648 } 1649 } 1650 #endif 1651 1652 /* Strip the SNAP header from ARP packets since we don't 1653 * pass them through to the 802.2/SNAP layers. 1654 */ 1655 if (fcllc->dsap == EXTENDED_SAP && 1656 (fcllc->ethertype == htons(ETH_P_IP) || 1657 fcllc->ethertype == htons(ETH_P_ARP))) { 1658 skb_pull(skb, sizeof(struct fcllc)); 1659 return fcllc->ethertype; 1660 } 1661 1662 return htons(ETH_P_802_2); 1663 } 1664 1665 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 1666