drivers/message/fusion/mptlan.c

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