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