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