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