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-2007 LSI Logic Corporation
   8  *  (mailto:mpt_linux_developer@lsi.com)
   9  *
  10  */
  11 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  12 /*
  13     This program is free software; you can redistribute it and/or modify
  14     it under the terms of the GNU General Public License as published by
  15     the Free Software Foundation; version 2 of the License.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20     GNU General Public License for more details.
  21
  22     NO WARRANTY
  23     THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  24     CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  25     LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  26     MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  27     solely responsible for determining the appropriateness of using and
  28     distributing the Program and assumes all risks associated with its
  29     exercise of rights under this Agreement, including but not limited to
  30     the risks and costs of program errors, damage to or loss of data,
  31     programs or equipment, and unavailability or interruption of operations.
  32
  33     DISCLAIMER OF LIABILITY
  34     NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  35     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36     DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  37     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  38     TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  39     USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  40     HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  41
  42     You should have received a copy of the GNU General Public License
  43     along with this program; if not, write to the Free Software
  44     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  45 */
  46
  47 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  48 /*
  49  * Define statements used for debugging
  50  */
  51 //#define MPT_LAN_IO_DEBUG
  52
  53 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  54
  55 #include "mptlan.h"
  56 #include <linux/init.h>
  57 #include <linux/module.h>
  58 #include <linux/fs.h>
  59
  60 #define my_VERSION      MPT_LINUX_VERSION_COMMON
  61 #define MYNAM           "mptlan"
  62
  63 MODULE_LICENSE("GPL");
  64 MODULE_VERSION(my_VERSION);
  65
  66 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  67 /*
  68  * MPT LAN message sizes without variable part.
  69  */
  70 #define MPT_LAN_RECEIVE_POST_REQUEST_SIZE \
  71         (sizeof(LANReceivePostRequest_t) - sizeof(SGE_MPI_UNION))
  72
  73 #define MPT_LAN_TRANSACTION32_SIZE \
  74         (sizeof(SGETransaction32_t) - sizeof(u32))
  75
  76 /*
  77  *  Fusion MPT LAN private structures
  78  */
  79
  80 struct NAA_Hosed {
  81         u16 NAA;
  82         u8 ieee[FC_ALEN];
  83         struct NAA_Hosed *next;
  84 };
  85
  86 struct BufferControl {
  87         struct sk_buff  *skb;
  88         dma_addr_t      dma;
  89         unsigned int    len;
  90 };
  91
  92 struct mpt_lan_priv {
  93         MPT_ADAPTER *mpt_dev;
  94         u8 pnum; /* Port number in the IOC. This is not a Unix network port! */
  95
  96         atomic_t buckets_out;           /* number of unused buckets on IOC */
  97         int bucketthresh;               /* Send more when this many left */
  98
  99         int *mpt_txfidx; /* Free Tx Context list */
 100         int mpt_txfidx_tail;
 101         spinlock_t txfidx_lock;
 102
 103         int *mpt_rxfidx; /* Free Rx Context list */
 104         int mpt_rxfidx_tail;
 105         spinlock_t rxfidx_lock;
 106
 107         struct BufferControl *RcvCtl;   /* Receive BufferControl structs */
 108         struct BufferControl *SendCtl;  /* Send BufferControl structs */
 109
 110         int max_buckets_out;            /* Max buckets to send to IOC */
 111         int tx_max_out;                 /* IOC's Tx queue len */
 112
 113         u32 total_posted;
 114         u32 total_received;
 115         struct net_device_stats stats;  /* Per device statistics */
 116
 117         struct delayed_work post_buckets_task;
 118         struct net_device *dev;
 119         unsigned long post_buckets_active;
 120 };
 121
 122 struct mpt_lan_ohdr {
 123         u16     dtype;
 124         u8      daddr[FC_ALEN];
 125         u16     stype;
 126         u8      saddr[FC_ALEN];
 127 };
 128
 129 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 130
 131 /*
 132  *  Forward protos...
 133  */
 134 static int  lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf,
 135                        MPT_FRAME_HDR *reply);
 136 static int  mpt_lan_open(struct net_device *dev);
 137 static int  mpt_lan_reset(struct net_device *dev);
 138 static int  mpt_lan_close(struct net_device *dev);
 139 static void mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv);
 140 static void mpt_lan_wake_post_buckets_task(struct net_device *dev,
 141                                            int priority);
 142 static int  mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg);
 143 static int  mpt_lan_receive_post_reply(struct net_device *dev,
 144                                        LANReceivePostReply_t *pRecvRep);
 145 static int  mpt_lan_send_turbo(struct net_device *dev, u32 tmsg);
 146 static int  mpt_lan_send_reply(struct net_device *dev,
 147                                LANSendReply_t *pSendRep);
 148 static int  mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase);
 149 static int  mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply);
 150 static unsigned short mpt_lan_type_trans(struct sk_buff *skb,
 151                                          struct net_device *dev);
 152
 153 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 154 /*
 155  *  Fusion MPT LAN private data
 156  */
 157 static int LanCtx = -1;
 158
 159 static u32 max_buckets_out = 127;
 160 static u32 tx_max_out_p = 127 - 16;
 161
 162 #ifdef QLOGIC_NAA_WORKAROUND
 163 static struct NAA_Hosed *mpt_bad_naa = NULL;
 164 DEFINE_RWLOCK(bad_naa_lock);
 165 #endif
 166
 167 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 168 /*
 169  * Fusion MPT LAN external data
 170  */
 171 extern int mpt_lan_index;
 172
 173 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 174 /**
 175  *      lan_reply - Handle all data sent from the hardware.
 176  *      @ioc: Pointer to MPT_ADAPTER structure
 177  *      @mf: Pointer to original MPT request frame (NULL if TurboReply)
 178  *      @reply: Pointer to MPT reply frame
 179  *
 180  *      Returns 1 indicating original alloc'd request frame ptr
 181  *      should be freed, or 0 if it shouldn't.
 182  */
 183 static int
 184 lan_reply (MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *reply)
 185 {
 186         struct net_device *dev = ioc->netdev;
 187         int FreeReqFrame = 0;
 188
 189         dioprintk((KERN_INFO MYNAM ": %s/%s: Got reply.\n",
 190                   IOC_AND_NETDEV_NAMES_s_s(dev)));
 191
 192 //      dioprintk((KERN_INFO MYNAM "@lan_reply: mf = %p, reply = %p\n",
 193 //                      mf, reply));
 194
 195         if (mf == NULL) {
 196                 u32 tmsg = CAST_PTR_TO_U32(reply);
 197
 198                 dioprintk((KERN_INFO MYNAM ": %s/%s: @lan_reply, tmsg %08x\n",
 199                                 IOC_AND_NETDEV_NAMES_s_s(dev),
 200                                 tmsg));
 201
 202                 switch (GET_LAN_FORM(tmsg)) {
 203
 204                 // NOTE!  (Optimization) First case here is now caught in
 205                 //  mptbase.c::mpt_interrupt() routine and callcack here
 206                 //  is now skipped for this case!
 207 #if 0
 208                 case LAN_REPLY_FORM_MESSAGE_CONTEXT:
 209 //                      dioprintk((KERN_INFO MYNAM "/lan_reply: "
 210 //                                "MessageContext turbo reply received\n"));
 211                         FreeReqFrame = 1;
 212                         break;
 213 #endif
 214
 215                 case LAN_REPLY_FORM_SEND_SINGLE:
 216 //                      dioprintk((MYNAM "/lan_reply: "
 217 //                                "calling mpt_lan_send_reply (turbo)\n"));
 218
 219                         // Potential BUG here?
 220                         //      FreeReqFrame = mpt_lan_send_turbo(dev, tmsg);
 221                         //  If/when mpt_lan_send_turbo would return 1 here,
 222                         //  calling routine (mptbase.c|mpt_interrupt)
 223                         //  would Oops because mf has already been set
 224                         //  to NULL.  So after return from this func,
 225                         //  mpt_interrupt() will attempt to put (NULL) mf ptr
 226                         //  item back onto its adapter FreeQ - Oops!:-(
 227                         //  It's Ok, since mpt_lan_send_turbo() *currently*
 228                         //  always returns 0, but..., just in case:
 229
 230                         (void) mpt_lan_send_turbo(dev, tmsg);
 231                         FreeReqFrame = 0;
 232
 233                         break;
 234
 235                 case LAN_REPLY_FORM_RECEIVE_SINGLE:
 236 //                      dioprintk((KERN_INFO MYNAM "@lan_reply: "
 237 //                                "rcv-Turbo = %08x\n", tmsg));
 238                         mpt_lan_receive_post_turbo(dev, tmsg);
 239                         break;
 240
 241                 default:
 242                         printk (KERN_ERR MYNAM "/lan_reply: Got a turbo reply "
 243                                 "that I don't know what to do with\n");
 244
 245                         /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
 246
 247                         break;
 248                 }
 249
 250                 return FreeReqFrame;
 251         }
 252
 253 //      msg = (u32 *) reply;
 254 //      dioprintk((KERN_INFO MYNAM "@lan_reply: msg = %08x %08x %08x %08x\n",
 255 //                le32_to_cpu(msg[0]), le32_to_cpu(msg[1]),
 256 //                le32_to_cpu(msg[2]), le32_to_cpu(msg[3])));
 257 //      dioprintk((KERN_INFO MYNAM "@lan_reply: Function = %02xh\n",
 258 //                reply->u.hdr.Function));
 259
 260         switch (reply->u.hdr.Function) {
 261
 262         case MPI_FUNCTION_LAN_SEND:
 263         {
 264                 LANSendReply_t *pSendRep;
 265
 266                 pSendRep = (LANSendReply_t *) reply;
 267                 FreeReqFrame = mpt_lan_send_reply(dev, pSendRep);
 268                 break;
 269         }
 270
 271         case MPI_FUNCTION_LAN_RECEIVE:
 272         {
 273                 LANReceivePostReply_t *pRecvRep;
 274
 275                 pRecvRep = (LANReceivePostReply_t *) reply;
 276                 if (pRecvRep->NumberOfContexts) {
 277                         mpt_lan_receive_post_reply(dev, pRecvRep);
 278                         if (!(pRecvRep->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY))
 279                                 FreeReqFrame = 1;
 280                 } else
 281                         dioprintk((KERN_INFO MYNAM "@lan_reply: zero context "
 282                                   "ReceivePostReply received.\n"));
 283                 break;
 284         }
 285
 286         case MPI_FUNCTION_LAN_RESET:
 287                 /* Just a default reply. Might want to check it to
 288                  * make sure that everything went ok.
 289                  */
 290                 FreeReqFrame = 1;
 291                 break;
 292
 293         case MPI_FUNCTION_EVENT_NOTIFICATION:
 294         case MPI_FUNCTION_EVENT_ACK:
 295                 /*  _EVENT_NOTIFICATION should NOT come down this path any more.
 296                  *  Should be routed to mpt_lan_event_process(), but just in case...
 297                  */
 298                 FreeReqFrame = 1;
 299                 break;
 300
 301         default:
 302                 printk (KERN_ERR MYNAM "/lan_reply: Got a non-turbo "
 303                         "reply that I don't know what to do with\n");
 304
 305                 /* CHECKME!  Hmmm...  FreeReqFrame is 0 here; is that right? */
 306                 FreeReqFrame = 1;
 307
 308                 break;
 309         }
 310
 311         return FreeReqFrame;
 312 }
 313
 314 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 315 static int
 316 mpt_lan_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
 317 {
 318         struct net_device *dev = ioc->netdev;
 319         struct mpt_lan_priv *priv;
 320
 321         if (dev == NULL)
 322                 return(1);
 323         else
 324                 priv = netdev_priv(dev);
 325
 326         dlprintk((KERN_INFO MYNAM ": IOC %s_reset routed to LAN driver!\n",
 327                         reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
 328                         reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
 329
 330         if (priv->mpt_rxfidx == NULL)
 331                 return (1);
 332
 333         if (reset_phase == MPT_IOC_SETUP_RESET) {
 334                 ;
 335         } else if (reset_phase == MPT_IOC_PRE_RESET) {
 336                 int i;
 337                 unsigned long flags;
 338
 339                 netif_stop_queue(dev);
 340
 341                 dlprintk ((KERN_INFO "mptlan/ioc_reset: called netif_stop_queue for %s.\n", dev->name));
 342
 343                 atomic_set(&priv->buckets_out, 0);
 344
 345                 /* Reset Rx Free Tail index and re-populate the queue. */
 346                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
 347                 priv->mpt_rxfidx_tail = -1;
 348                 for (i = 0; i < priv->max_buckets_out; i++)
 349                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
 350                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
 351         } else {
 352                 mpt_lan_post_receive_buckets(priv);
 353                 netif_wake_queue(dev);
 354         }
 355
 356         return 1;
 357 }
 358
 359 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 360 static int
 361 mpt_lan_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
 362 {
 363         dlprintk((KERN_INFO MYNAM ": MPT event routed to LAN driver!\n"));
 364
 365         switch (le32_to_cpu(pEvReply->Event)) {
 366         case MPI_EVENT_NONE:                            /* 00 */
 367         case MPI_EVENT_LOG_DATA:                        /* 01 */
 368         case MPI_EVENT_STATE_CHANGE:                    /* 02 */
 369         case MPI_EVENT_UNIT_ATTENTION:                  /* 03 */
 370         case MPI_EVENT_IOC_BUS_RESET:                   /* 04 */
 371         case MPI_EVENT_EXT_BUS_RESET:                   /* 05 */
 372         case MPI_EVENT_RESCAN:                          /* 06 */
 373                 /* Ok, do we need to do anything here? As far as
 374                    I can tell, this is when a new device gets added
 375                    to the loop. */
 376         case MPI_EVENT_LINK_STATUS_CHANGE:              /* 07 */
 377         case MPI_EVENT_LOOP_STATE_CHANGE:               /* 08 */
 378         case MPI_EVENT_LOGOUT:                          /* 09 */
 379         case MPI_EVENT_EVENT_CHANGE:                    /* 0A */
 380         default:
 381                 break;
 382         }
 383
 384         /*
 385          *  NOTE: pEvent->AckRequired handling now done in mptbase.c;
 386          *  Do NOT do it here now!
 387          */
 388
 389         return 1;
 390 }
 391
 392 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 393 static int
 394 mpt_lan_open(struct net_device *dev)
 395 {
 396         struct mpt_lan_priv *priv = netdev_priv(dev);
 397         int i;
 398
 399         if (mpt_lan_reset(dev) != 0) {
 400                 MPT_ADAPTER *mpt_dev = priv->mpt_dev;
 401
 402                 printk (KERN_WARNING MYNAM "/lan_open: lan_reset failed.");
 403
 404                 if (mpt_dev->active)
 405                         printk ("The ioc is active. Perhaps it needs to be"
 406                                 " reset?\n");
 407                 else
 408                         printk ("The ioc in inactive, most likely in the "
 409                                 "process of being reset. Please try again in "
 410                                 "a moment.\n");
 411         }
 412
 413         priv->mpt_txfidx = kmalloc(priv->tx_max_out * sizeof(int), GFP_KERNEL);
 414         if (priv->mpt_txfidx == NULL)
 415                 goto out;
 416         priv->mpt_txfidx_tail = -1;
 417
 418         priv->SendCtl = kcalloc(priv->tx_max_out, sizeof(struct BufferControl),
 419                                 GFP_KERNEL);
 420         if (priv->SendCtl == NULL)
 421                 goto out_mpt_txfidx;
 422         for (i = 0; i < priv->tx_max_out; i++)
 423                 priv->mpt_txfidx[++priv->mpt_txfidx_tail] = i;
 424
 425         dlprintk((KERN_INFO MYNAM "@lo: Finished initializing SendCtl\n"));
 426
 427         priv->mpt_rxfidx = kmalloc(priv->max_buckets_out * sizeof(int),
 428                                    GFP_KERNEL);
 429         if (priv->mpt_rxfidx == NULL)
 430                 goto out_SendCtl;
 431         priv->mpt_rxfidx_tail = -1;
 432
 433         priv->RcvCtl = kcalloc(priv->max_buckets_out,
 434                                sizeof(struct BufferControl),
 435                                GFP_KERNEL);
 436         if (priv->RcvCtl == NULL)
 437                 goto out_mpt_rxfidx;
 438         for (i = 0; i < priv->max_buckets_out; i++)
 439                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = i;
 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(priv);
 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 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_delayed_work(&priv->post_buckets_task, 0);
 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 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                 return -1;
1160         }
1161
1162         if (remaining == 0)
1163                 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1164                         "(priv->buckets_out = %d)\n",
1165                         IOC_AND_NETDEV_NAMES_s_s(dev),
1166                         atomic_read(&priv->buckets_out));
1167         else if (remaining < 10)
1168                 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1169                         "(priv->buckets_out = %d)\n",
1170                         IOC_AND_NETDEV_NAMES_s_s(dev),
1171                         remaining, atomic_read(&priv->buckets_out));
1172
1173         if ((remaining < priv->bucketthresh) &&
1174             ((atomic_read(&priv->buckets_out) - remaining) >
1175              MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1176
1177                 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1178                         "buckets_out count and fw's BucketsRemaining "
1179                         "count has crossed the threshold, issuing a "
1180                         "LanReset to clear the fw's hashtable. You may "
1181                         "want to check your /var/log/messages for \"CRC "
1182                         "error\" event notifications.\n");
1183
1184                 mpt_lan_reset(dev);
1185                 mpt_lan_wake_post_buckets_task(dev, 0);
1186         }
1187
1188         return mpt_lan_receive_skb(dev, skb);
1189 }
1190
1191 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1192 /* Simple SGE's only at the moment */
1193
1194 static void
1195 mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
1196 {
1197         struct net_device *dev = priv->dev;
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 static void
1342 mpt_lan_post_receive_buckets_work(struct work_struct *work)
1343 {
1344         mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
1345                                                   post_buckets_task.work));
1346 }
1347
1348 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1349 static struct net_device *
1350 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1351 {
1352         struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1353         struct mpt_lan_priv *priv = NULL;
1354         u8 HWaddr[FC_ALEN], *a;
1355
1356         if (!dev)
1357                 return NULL;
1358
1359         dev->mtu = MPT_LAN_MTU;
1360
1361         priv = netdev_priv(dev);
1362
1363         priv->dev = dev;
1364         priv->mpt_dev = mpt_dev;
1365         priv->pnum = pnum;
1366
1367         memset(&priv->post_buckets_task, 0, sizeof(priv->post_buckets_task));
1368         INIT_DELAYED_WORK(&priv->post_buckets_task,
1369                           mpt_lan_post_receive_buckets_work);
1370         priv->post_buckets_active = 0;
1371
1372         dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
1373                         __LINE__, dev->mtu + dev->hard_header_len + 4));
1374
1375         atomic_set(&priv->buckets_out, 0);
1376         priv->total_posted = 0;
1377         priv->total_received = 0;
1378         priv->max_buckets_out = max_buckets_out;
1379         if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
1380                 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
1381
1382         dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n",
1383                         __LINE__,
1384                         mpt_dev->pfacts[0].MaxLanBuckets,
1385                         max_buckets_out,
1386                         priv->max_buckets_out));
1387
1388         priv->bucketthresh = priv->max_buckets_out * 2 / 3;
1389         spin_lock_init(&priv->txfidx_lock);
1390         spin_lock_init(&priv->rxfidx_lock);
1391
1392         memset(&priv->stats, 0, sizeof(priv->stats));
1393
1394         /*  Grab pre-fetched LANPage1 stuff. :-) */
1395         a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
1396
1397         HWaddr[0] = a[5];
1398         HWaddr[1] = a[4];
1399         HWaddr[2] = a[3];
1400         HWaddr[3] = a[2];
1401         HWaddr[4] = a[1];
1402         HWaddr[5] = a[0];
1403
1404         dev->addr_len = FC_ALEN;
1405         memcpy(dev->dev_addr, HWaddr, FC_ALEN);
1406         memset(dev->broadcast, 0xff, FC_ALEN);
1407
1408         /* The Tx queue is 127 deep on the 909.
1409          * Give ourselves some breathing room.
1410          */
1411         priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
1412                             tx_max_out_p : MPT_TX_MAX_OUT_LIM;
1413
1414         dev->open = mpt_lan_open;
1415         dev->stop = mpt_lan_close;
1416         dev->get_stats = mpt_lan_get_stats;
1417         dev->set_multicast_list = NULL;
1418         dev->change_mtu = mpt_lan_change_mtu;
1419         dev->hard_start_xmit = mpt_lan_sdu_send;
1420
1421 /* Not in 2.3.42. Need 2.3.45+ */
1422         dev->tx_timeout = mpt_lan_tx_timeout;
1423         dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
1424
1425         dlprintk((KERN_INFO MYNAM ": Finished registering dev "
1426                 "and setting initial values\n"));
1427
1428         SET_MODULE_OWNER(dev);
1429
1430         if (register_netdev(dev) != 0) {
1431                 free_netdev(dev);
1432                 dev = NULL;
1433         }
1434         return dev;
1435 }
1436
1437 static int
1438 mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1439 {
1440         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1441         struct net_device       *dev;
1442         int                     i;
1443
1444         for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1445                 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1446                        "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1447                        ioc->name, ioc->pfacts[i].PortNumber,
1448                        ioc->pfacts[i].ProtocolFlags,
1449                        MPT_PROTOCOL_FLAGS_c_c_c_c(
1450                                ioc->pfacts[i].ProtocolFlags));
1451
1452                 if (!(ioc->pfacts[i].ProtocolFlags &
1453                                         MPI_PORTFACTS_PROTOCOL_LAN)) {
1454                         printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1455                                "seems to be disabled on this adapter port!\n",
1456                                ioc->name);
1457                         continue;
1458                 }
1459
1460                 dev = mpt_register_lan_device(ioc, i);
1461                 if (!dev) {
1462                         printk(KERN_ERR MYNAM ": %s: Unable to register "
1463                                "port%d as a LAN device\n", ioc->name,
1464                                ioc->pfacts[i].PortNumber);
1465                         continue;
1466                 }
1467
1468                 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1469                        "registered as '%s'\n", ioc->name, dev->name);
1470                 printk(KERN_INFO MYNAM ": %s/%s: "
1471                        "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1472                        IOC_AND_NETDEV_NAMES_s_s(dev),
1473                        dev->dev_addr[0], dev->dev_addr[1],
1474                        dev->dev_addr[2], dev->dev_addr[3],
1475                        dev->dev_addr[4], dev->dev_addr[5]);
1476
1477                 ioc->netdev = dev;
1478
1479                 return 0;
1480         }
1481
1482         return -ENODEV;
1483 }
1484
1485 static void
1486 mptlan_remove(struct pci_dev *pdev)
1487 {
1488         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1489         struct net_device       *dev = ioc->netdev;
1490
1491         if(dev != NULL) {
1492                 unregister_netdev(dev);
1493                 free_netdev(dev);
1494         }
1495 }
1496
1497 static struct mpt_pci_driver mptlan_driver = {
1498         .probe          = mptlan_probe,
1499         .remove         = mptlan_remove,
1500 };
1501
1502 static int __init mpt_lan_init (void)
1503 {
1504         show_mptmod_ver(LANAME, LANVER);
1505
1506         if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) {
1507                 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1508                 return -EBUSY;
1509         }
1510
1511         /* Set the callback index to be used by driver core for turbo replies */
1512         mpt_lan_index = LanCtx;
1513
1514         dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1515
1516         if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1517                 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1518                        "handler with mptbase! The world is at an end! "
1519                        "Everything is fading to black! Goodbye.\n");
1520                 return -EBUSY;
1521         }
1522
1523         dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1524
1525         if (mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER))
1526                 dprintk((KERN_INFO MYNAM ": failed to register dd callbacks\n"));
1527         return 0;
1528 }
1529
1530 static void __exit mpt_lan_exit(void)
1531 {
1532         mpt_device_driver_deregister(MPTLAN_DRIVER);
1533         mpt_reset_deregister(LanCtx);
1534
1535         if (LanCtx >= 0) {
1536                 mpt_deregister(LanCtx);
1537                 LanCtx = -1;
1538                 mpt_lan_index = 0;
1539         }
1540 }
1541
1542 module_init(mpt_lan_init);
1543 module_exit(mpt_lan_exit);
1544
1545 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1546 static unsigned short
1547 mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1548 {
1549         struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1550         struct fcllc *fcllc;
1551
1552         skb->mac.raw = skb->data;
1553         skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1554
1555         if (fch->dtype == htons(0xffff)) {
1556                 u32 *p = (u32 *) fch;
1557
1558                 swab32s(p + 0);
1559                 swab32s(p + 1);
1560                 swab32s(p + 2);
1561                 swab32s(p + 3);
1562
1563                 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1564                                 NETDEV_PTR_TO_IOC_NAME_s(dev));
1565                 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
1566                                 fch->saddr[0], fch->saddr[1], fch->saddr[2],
1567                                 fch->saddr[3], fch->saddr[4], fch->saddr[5]);
1568         }
1569
1570         if (*fch->daddr & 1) {
1571                 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1572                         skb->pkt_type = PACKET_BROADCAST;
1573                 } else {
1574                         skb->pkt_type = PACKET_MULTICAST;
1575                 }
1576         } else {
1577                 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1578                         skb->pkt_type = PACKET_OTHERHOST;
1579                 } else {
1580                         skb->pkt_type = PACKET_HOST;
1581                 }
1582         }
1583
1584         fcllc = (struct fcllc *)skb->data;
1585
1586 #ifdef QLOGIC_NAA_WORKAROUND
1587 {
1588         u16 source_naa = fch->stype, found = 0;
1589
1590         /* Workaround for QLogic not following RFC 2625 in regards to the NAA
1591            value. */
1592
1593         if ((source_naa & 0xF000) == 0)
1594                 source_naa = swab16(source_naa);
1595
1596         if (fcllc->ethertype == htons(ETH_P_ARP))
1597             dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of "
1598                       "%04x.\n", source_naa));
1599
1600         if ((fcllc->ethertype == htons(ETH_P_ARP)) &&
1601            ((source_naa >> 12) !=  MPT_LAN_NAA_RFC2625)){
1602                 struct NAA_Hosed *nh, *prevnh;
1603                 int i;
1604
1605                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from "
1606                           "system with non-RFC 2625 NAA value (%04x).\n",
1607                           source_naa));
1608
1609                 write_lock_irq(&bad_naa_lock);
1610                 for (prevnh = nh = mpt_bad_naa; nh != NULL;
1611                      prevnh=nh, nh=nh->next) {
1612                         if ((nh->ieee[0] == fch->saddr[0]) &&
1613                             (nh->ieee[1] == fch->saddr[1]) &&
1614                             (nh->ieee[2] == fch->saddr[2]) &&
1615                             (nh->ieee[3] == fch->saddr[3]) &&
1616                             (nh->ieee[4] == fch->saddr[4]) &&
1617                             (nh->ieee[5] == fch->saddr[5])) {
1618                                 found = 1;
1619                                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re"
1620                                          "q/Rep w/ bad NAA from system already"
1621                                          " in DB.\n"));
1622                                 break;
1623                         }
1624                 }
1625
1626                 if ((!found) && (nh == NULL)) {
1627
1628                         nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL);
1629                         dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/"
1630                                  " bad NAA from system not yet in DB.\n"));
1631
1632                         if (nh != NULL) {
1633                                 nh->next = NULL;
1634                                 if (!mpt_bad_naa)
1635                                         mpt_bad_naa = nh;
1636                                 if (prevnh)
1637                                         prevnh->next = nh;
1638
1639                                 nh->NAA = source_naa; /* Set the S_NAA value. */
1640                                 for (i = 0; i < FC_ALEN; i++)
1641                                         nh->ieee[i] = fch->saddr[i];
1642                                 dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:"
1643                                           "%02x:%02x with non-compliant S_NAA value.\n",
1644                                           fch->saddr[0], fch->saddr[1], fch->saddr[2],
1645                                           fch->saddr[3], fch->saddr[4],fch->saddr[5]));
1646                         } else {
1647                                 printk (KERN_ERR "mptlan/type_trans: Unable to"
1648                                         " kmalloc a NAA_Hosed struct.\n");
1649                         }
1650                 } else if (!found) {
1651                         printk (KERN_ERR "mptlan/type_trans: found not"
1652                                 " set, but nh isn't null. Evil "
1653                                 "funkiness abounds.\n");
1654                 }
1655                 write_unlock_irq(&bad_naa_lock);
1656         }
1657 }
1658 #endif
1659
1660         /* Strip the SNAP header from ARP packets since we don't
1661          * pass them through to the 802.2/SNAP layers.
1662          */
1663         if (fcllc->dsap == EXTENDED_SAP &&
1664                 (fcllc->ethertype == htons(ETH_P_IP) ||
1665                  fcllc->ethertype == htons(ETH_P_ARP))) {
1666                 skb_pull(skb, sizeof(struct fcllc));
1667                 return fcllc->ethertype;
1668         }
1669
1670         return htons(ETH_P_802_2);
1671 }
1672
1673 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/