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