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:DL-MPTFusionLinux@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         const unsigned char *mac;
 718         dma_addr_t dma;
 719         unsigned long flags;
 720         int ctx;
 721         u16 cur_naa = 0x1000;
 722
 723         dioprintk((KERN_INFO MYNAM ": %s called, skb_addr = %p\n",
 724                         __FUNCTION__, skb));
 725
 726         spin_lock_irqsave(&priv->txfidx_lock, flags);
 727         if (priv->mpt_txfidx_tail < 0) {
 728                 netif_stop_queue(dev);
 729                 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
 730
 731                 printk (KERN_ERR "%s: no tx context available: %u\n",
 732                         __FUNCTION__, priv->mpt_txfidx_tail);
 733                 return 1;
 734         }
 735
 736         mf = mpt_get_msg_frame(LanCtx, mpt_dev);
 737         if (mf == NULL) {
 738                 netif_stop_queue(dev);
 739                 spin_unlock_irqrestore(&priv->txfidx_lock, flags);
 740
 741                 printk (KERN_ERR "%s: Unable to alloc request frame\n",
 742                         __FUNCTION__);
 743                 return 1;
 744         }
 745
 746         ctx = priv->mpt_txfidx[priv->mpt_txfidx_tail--];
 747         spin_unlock_irqrestore(&priv->txfidx_lock, flags);
 748
 749 //      dioprintk((KERN_INFO MYNAM ": %s/%s: Creating new msg frame (send).\n",
 750 //                      IOC_AND_NETDEV_NAMES_s_s(dev)));
 751
 752         pSendReq = (LANSendRequest_t *) mf;
 753
 754         /* Set the mac.raw pointer, since this apparently isn't getting
 755          * done before we get the skb. Pull the data pointer past the mac data.
 756          */
 757         skb_reset_mac_header(skb);
 758         skb_pull(skb, 12);
 759
 760         dma = pci_map_single(mpt_dev->pcidev, skb->data, skb->len,
 761                              PCI_DMA_TODEVICE);
 762
 763         priv->SendCtl[ctx].skb = skb;
 764         priv->SendCtl[ctx].dma = dma;
 765         priv->SendCtl[ctx].len = skb->len;
 766
 767         /* Message Header */
 768         pSendReq->Reserved    = 0;
 769         pSendReq->Function    = MPI_FUNCTION_LAN_SEND;
 770         pSendReq->ChainOffset = 0;
 771         pSendReq->Reserved2   = 0;
 772         pSendReq->MsgFlags    = 0;
 773         pSendReq->PortNumber  = priv->pnum;
 774
 775         /* Transaction Context Element */
 776         pTrans = (SGETransaction32_t *) pSendReq->SG_List;
 777
 778         /* No Flags, 8 bytes of Details, 32bit Context (bloody turbo replies) */
 779         pTrans->ContextSize   = sizeof(u32);
 780         pTrans->DetailsLength = 2 * sizeof(u32);
 781         pTrans->Flags         = 0;
 782         pTrans->TransactionContext[0] = cpu_to_le32(ctx);
 783
 784 //      dioprintk((KERN_INFO MYNAM ": %s/%s: BC = %08x, skb = %p, buff = %p\n",
 785 //                      IOC_AND_NETDEV_NAMES_s_s(dev),
 786 //                      ctx, skb, skb->data));
 787
 788         mac = skb_mac_header(skb);
 789 #ifdef QLOGIC_NAA_WORKAROUND
 790 {
 791         struct NAA_Hosed *nh;
 792
 793         /* Munge the NAA for Tx packets to QLogic boards, which don't follow
 794            RFC 2625. The longer I look at this, the more my opinion of Qlogic
 795            drops. */
 796         read_lock_irq(&bad_naa_lock);
 797         for (nh = mpt_bad_naa; nh != NULL; nh=nh->next) {
 798                 if ((nh->ieee[0] == mac[0]) &&
 799                     (nh->ieee[1] == mac[1]) &&
 800                     (nh->ieee[2] == mac[2]) &&
 801                     (nh->ieee[3] == mac[3]) &&
 802                     (nh->ieee[4] == mac[4]) &&
 803                     (nh->ieee[5] == mac[5])) {
 804                         cur_naa = nh->NAA;
 805                         dlprintk ((KERN_INFO "mptlan/sdu_send: using NAA value "
 806                                   "= %04x.\n", cur_naa));
 807                         break;
 808                 }
 809         }
 810         read_unlock_irq(&bad_naa_lock);
 811 }
 812 #endif
 813
 814         pTrans->TransactionDetails[0] = cpu_to_le32((cur_naa         << 16) |
 815                                                     (mac[0] <<  8) |
 816                                                     (mac[1] <<  0));
 817         pTrans->TransactionDetails[1] = cpu_to_le32((mac[2] << 24) |
 818                                                     (mac[3] << 16) |
 819                                                     (mac[4] <<  8) |
 820                                                     (mac[5] <<  0));
 821
 822         pSimple = (SGESimple64_t *) &pTrans->TransactionDetails[2];
 823
 824         /* If we ever decide to send more than one Simple SGE per LANSend, then
 825            we will need to make sure that LAST_ELEMENT only gets set on the
 826            last one. Otherwise, bad voodoo and evil funkiness will commence. */
 827         pSimple->FlagsLength = cpu_to_le32(
 828                         ((MPI_SGE_FLAGS_LAST_ELEMENT |
 829                           MPI_SGE_FLAGS_END_OF_BUFFER |
 830                           MPI_SGE_FLAGS_SIMPLE_ELEMENT |
 831                           MPI_SGE_FLAGS_SYSTEM_ADDRESS |
 832                           MPI_SGE_FLAGS_HOST_TO_IOC |
 833                           MPI_SGE_FLAGS_64_BIT_ADDRESSING |
 834                           MPI_SGE_FLAGS_END_OF_LIST) << MPI_SGE_FLAGS_SHIFT) |
 835                         skb->len);
 836         pSimple->Address.Low = cpu_to_le32((u32) dma);
 837         if (sizeof(dma_addr_t) > sizeof(u32))
 838                 pSimple->Address.High = cpu_to_le32((u32) ((u64) dma >> 32));
 839         else
 840                 pSimple->Address.High = 0;
 841
 842         mpt_put_msg_frame (LanCtx, mpt_dev, mf);
 843         dev->trans_start = jiffies;
 844
 845         dioprintk((KERN_INFO MYNAM ": %s/%s: Sending packet. FlagsLength = %08x.\n",
 846                         IOC_AND_NETDEV_NAMES_s_s(dev),
 847                         le32_to_cpu(pSimple->FlagsLength)));
 848
 849         return 0;
 850 }
 851
 852 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 853 static void
 854 mpt_lan_wake_post_buckets_task(struct net_device *dev, int priority)
 855 /*
 856  * @priority: 0 = put it on the timer queue, 1 = put it on the immediate queue
 857  */
 858 {
 859         struct mpt_lan_priv *priv = dev->priv;
 860
 861         if (test_and_set_bit(0, &priv->post_buckets_active) == 0) {
 862                 if (priority) {
 863                         schedule_delayed_work(&priv->post_buckets_task, 0);
 864                 } else {
 865                         schedule_delayed_work(&priv->post_buckets_task, 1);
 866                         dioprintk((KERN_INFO MYNAM ": post_buckets queued on "
 867                                    "timer.\n"));
 868                 }
 869                 dioprintk((KERN_INFO MYNAM ": %s/%s: Queued post_buckets task.\n",
 870                            IOC_AND_NETDEV_NAMES_s_s(dev) ));
 871         }
 872 }
 873
 874 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 875 static int
 876 mpt_lan_receive_skb(struct net_device *dev, struct sk_buff *skb)
 877 {
 878         struct mpt_lan_priv *priv = dev->priv;
 879
 880         skb->protocol = mpt_lan_type_trans(skb, dev);
 881
 882         dioprintk((KERN_INFO MYNAM ": %s/%s: Incoming packet (%d bytes) "
 883                  "delivered to upper level.\n",
 884                         IOC_AND_NETDEV_NAMES_s_s(dev), skb->len));
 885
 886         priv->stats.rx_bytes += skb->len;
 887         priv->stats.rx_packets++;
 888
 889         skb->dev = dev;
 890         netif_rx(skb);
 891
 892         dioprintk((MYNAM "/receive_skb: %d buckets remaining\n",
 893                  atomic_read(&priv->buckets_out)));
 894
 895         if (atomic_read(&priv->buckets_out) < priv->bucketthresh)
 896                 mpt_lan_wake_post_buckets_task(dev, 1);
 897
 898         dioprintk((KERN_INFO MYNAM "/receive_post_reply: %d buckets "
 899                   "remaining, %d received back since sod\n",
 900                   atomic_read(&priv->buckets_out), priv->total_received));
 901
 902         return 0;
 903 }
 904
 905 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 906 //static inline int
 907 static int
 908 mpt_lan_receive_post_turbo(struct net_device *dev, u32 tmsg)
 909 {
 910         struct mpt_lan_priv *priv = dev->priv;
 911         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
 912         struct sk_buff *skb, *old_skb;
 913         unsigned long flags;
 914         u32 ctx, len;
 915
 916         ctx = GET_LAN_BUCKET_CONTEXT(tmsg);
 917         skb = priv->RcvCtl[ctx].skb;
 918
 919         len = GET_LAN_PACKET_LENGTH(tmsg);
 920
 921         if (len < MPT_LAN_RX_COPYBREAK) {
 922                 old_skb = skb;
 923
 924                 skb = (struct sk_buff *)dev_alloc_skb(len);
 925                 if (!skb) {
 926                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
 927                                         IOC_AND_NETDEV_NAMES_s_s(dev),
 928                                         __FILE__, __LINE__);
 929                         return -ENOMEM;
 930                 }
 931
 932                 pci_dma_sync_single_for_cpu(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
 933                                             priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
 934
 935                 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
 936
 937                 pci_dma_sync_single_for_device(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
 938                                                priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
 939                 goto out;
 940         }
 941
 942         skb_put(skb, len);
 943
 944         priv->RcvCtl[ctx].skb = NULL;
 945
 946         pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
 947                          priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
 948
 949 out:
 950         spin_lock_irqsave(&priv->rxfidx_lock, flags);
 951         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
 952         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
 953
 954         atomic_dec(&priv->buckets_out);
 955         priv->total_received++;
 956
 957         return mpt_lan_receive_skb(dev, skb);
 958 }
 959
 960 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 961 static int
 962 mpt_lan_receive_post_free(struct net_device *dev,
 963                           LANReceivePostReply_t *pRecvRep)
 964 {
 965         struct mpt_lan_priv *priv = dev->priv;
 966         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
 967         unsigned long flags;
 968         struct sk_buff *skb;
 969         u32 ctx;
 970         int count;
 971         int i;
 972
 973         count = pRecvRep->NumberOfContexts;
 974
 975 /**/    dlprintk((KERN_INFO MYNAM "/receive_post_reply: "
 976                   "IOC returned %d buckets, freeing them...\n", count));
 977
 978         spin_lock_irqsave(&priv->rxfidx_lock, flags);
 979         for (i = 0; i < count; i++) {
 980                 ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
 981
 982                 skb = priv->RcvCtl[ctx].skb;
 983
 984 //              dlprintk((KERN_INFO MYNAM ": %s: dev_name = %s\n",
 985 //                              IOC_AND_NETDEV_NAMES_s_s(dev)));
 986 //              dlprintk((KERN_INFO MYNAM "@rpr[2], priv = %p, buckets_out addr = %p",
 987 //                              priv, &(priv->buckets_out)));
 988 //              dlprintk((KERN_INFO MYNAM "@rpr[2] TC + 3\n"));
 989
 990                 priv->RcvCtl[ctx].skb = NULL;
 991                 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
 992                                  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
 993                 dev_kfree_skb_any(skb);
 994
 995                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
 996         }
 997         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
 998
 999         atomic_sub(count, &priv->buckets_out);
1000
1001 //      for (i = 0; i < priv->max_buckets_out; i++)
1002 //              if (priv->RcvCtl[i].skb != NULL)
1003 //                      dlprintk((KERN_INFO MYNAM "@rpr: bucket %03x "
1004 //                                "is still out\n", i));
1005
1006 /*      dlprintk((KERN_INFO MYNAM "/receive_post_reply: freed %d buckets\n",
1007                   count));
1008 */
1009 /**/    dlprintk((KERN_INFO MYNAM "@receive_post_reply: %d buckets "
1010 /**/              "remaining, %d received back since sod.\n",
1011 /**/              atomic_read(&priv->buckets_out), priv->total_received));
1012         return 0;
1013 }
1014
1015 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1016 static int
1017 mpt_lan_receive_post_reply(struct net_device *dev,
1018                            LANReceivePostReply_t *pRecvRep)
1019 {
1020         struct mpt_lan_priv *priv = dev->priv;
1021         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1022         struct sk_buff *skb, *old_skb;
1023         unsigned long flags;
1024         u32 len, ctx, offset;
1025         u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);
1026         int count;
1027         int i, l;
1028
1029         dioprintk((KERN_INFO MYNAM ": mpt_lan_receive_post_reply called\n"));
1030         dioprintk((KERN_INFO MYNAM ": receive_post_reply: IOCStatus: %04x\n",
1031                  le16_to_cpu(pRecvRep->IOCStatus)));
1032
1033         if ((le16_to_cpu(pRecvRep->IOCStatus) & MPI_IOCSTATUS_MASK) ==
1034                                                 MPI_IOCSTATUS_LAN_CANCELED)
1035                 return mpt_lan_receive_post_free(dev, pRecvRep);
1036
1037         len = le32_to_cpu(pRecvRep->PacketLength);
1038         if (len == 0) {
1039                 printk (KERN_ERR MYNAM ": %s/%s: ERROR - Got a non-TURBO "
1040                         "ReceivePostReply w/ PacketLength zero!\n",
1041                                 IOC_AND_NETDEV_NAMES_s_s(dev));
1042                 printk (KERN_ERR MYNAM ": MsgFlags = %02x, IOCStatus = %04x\n",
1043                                 pRecvRep->MsgFlags, le16_to_cpu(pRecvRep->IOCStatus));
1044                 return -1;
1045         }
1046
1047         ctx    = le32_to_cpu(pRecvRep->BucketContext[0]);
1048         count  = pRecvRep->NumberOfContexts;
1049         skb    = priv->RcvCtl[ctx].skb;
1050
1051         offset = le32_to_cpu(pRecvRep->PacketOffset);
1052 //      if (offset != 0) {
1053 //              printk (KERN_INFO MYNAM ": %s/%s: Got a ReceivePostReply "
1054 //                      "w/ PacketOffset %u\n",
1055 //                              IOC_AND_NETDEV_NAMES_s_s(dev),
1056 //                              offset);
1057 //      }
1058
1059         dioprintk((KERN_INFO MYNAM ": %s/%s: @rpr, offset = %d, len = %d\n",
1060                         IOC_AND_NETDEV_NAMES_s_s(dev),
1061                         offset, len));
1062
1063         if (count > 1) {
1064                 int szrem = len;
1065
1066 //              dioprintk((KERN_INFO MYNAM ": %s/%s: Multiple buckets returned "
1067 //                      "for single packet, concatenating...\n",
1068 //                              IOC_AND_NETDEV_NAMES_s_s(dev)));
1069
1070                 skb = (struct sk_buff *)dev_alloc_skb(len);
1071                 if (!skb) {
1072                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1073                                         IOC_AND_NETDEV_NAMES_s_s(dev),
1074                                         __FILE__, __LINE__);
1075                         return -ENOMEM;
1076                 }
1077
1078                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1079                 for (i = 0; i < count; i++) {
1080
1081                         ctx = le32_to_cpu(pRecvRep->BucketContext[i]);
1082                         old_skb = priv->RcvCtl[ctx].skb;
1083
1084                         l = priv->RcvCtl[ctx].len;
1085                         if (szrem < l)
1086                                 l = szrem;
1087
1088 //                      dioprintk((KERN_INFO MYNAM ": %s/%s: Buckets = %d, len = %u\n",
1089 //                                      IOC_AND_NETDEV_NAMES_s_s(dev),
1090 //                                      i, l));
1091
1092                         pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1093                                                     priv->RcvCtl[ctx].dma,
1094                                                     priv->RcvCtl[ctx].len,
1095                                                     PCI_DMA_FROMDEVICE);
1096                         skb_copy_from_linear_data(old_skb, skb_put(skb, l), l);
1097
1098                         pci_dma_sync_single_for_device(mpt_dev->pcidev,
1099                                                        priv->RcvCtl[ctx].dma,
1100                                                        priv->RcvCtl[ctx].len,
1101                                                        PCI_DMA_FROMDEVICE);
1102
1103                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1104                         szrem -= l;
1105                 }
1106                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1107
1108         } else if (len < MPT_LAN_RX_COPYBREAK) {
1109
1110                 old_skb = skb;
1111
1112                 skb = (struct sk_buff *)dev_alloc_skb(len);
1113                 if (!skb) {
1114                         printk (KERN_ERR MYNAM ": %s/%s: ERROR - Can't allocate skb! (%s@%d)\n",
1115                                         IOC_AND_NETDEV_NAMES_s_s(dev),
1116                                         __FILE__, __LINE__);
1117                         return -ENOMEM;
1118                 }
1119
1120                 pci_dma_sync_single_for_cpu(mpt_dev->pcidev,
1121                                             priv->RcvCtl[ctx].dma,
1122                                             priv->RcvCtl[ctx].len,
1123                                             PCI_DMA_FROMDEVICE);
1124
1125                 skb_copy_from_linear_data(old_skb, skb_put(skb, len), len);
1126
1127                 pci_dma_sync_single_for_device(mpt_dev->pcidev,
1128                                                priv->RcvCtl[ctx].dma,
1129                                                priv->RcvCtl[ctx].len,
1130                                                PCI_DMA_FROMDEVICE);
1131
1132                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1133                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1134                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1135
1136         } else {
1137                 spin_lock_irqsave(&priv->rxfidx_lock, flags);
1138
1139                 priv->RcvCtl[ctx].skb = NULL;
1140
1141                 pci_unmap_single(mpt_dev->pcidev, priv->RcvCtl[ctx].dma,
1142                                  priv->RcvCtl[ctx].len, PCI_DMA_FROMDEVICE);
1143                 priv->RcvCtl[ctx].dma = 0;
1144
1145                 priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1146                 spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1147
1148                 skb_put(skb,len);
1149         }
1150
1151         atomic_sub(count, &priv->buckets_out);
1152         priv->total_received += count;
1153
1154         if (priv->mpt_rxfidx_tail >= MPT_LAN_MAX_BUCKETS_OUT) {
1155                 printk (KERN_ERR MYNAM ": %s/%s: Yoohoo! mpt_rxfidx_tail = %d, "
1156                         "MPT_LAN_MAX_BUCKETS_OUT = %d\n",
1157                                 IOC_AND_NETDEV_NAMES_s_s(dev),
1158                                 priv->mpt_rxfidx_tail,
1159                                 MPT_LAN_MAX_BUCKETS_OUT);
1160
1161                 return -1;
1162         }
1163
1164         if (remaining == 0)
1165                 printk (KERN_WARNING MYNAM ": %s/%s: WARNING - IOC out of buckets! "
1166                         "(priv->buckets_out = %d)\n",
1167                         IOC_AND_NETDEV_NAMES_s_s(dev),
1168                         atomic_read(&priv->buckets_out));
1169         else if (remaining < 10)
1170                 printk (KERN_INFO MYNAM ": %s/%s: IOC says %d buckets left. "
1171                         "(priv->buckets_out = %d)\n",
1172                         IOC_AND_NETDEV_NAMES_s_s(dev),
1173                         remaining, atomic_read(&priv->buckets_out));
1174
1175         if ((remaining < priv->bucketthresh) &&
1176             ((atomic_read(&priv->buckets_out) - remaining) >
1177              MPT_LAN_BUCKETS_REMAIN_MISMATCH_THRESH)) {
1178
1179                 printk (KERN_WARNING MYNAM " Mismatch between driver's "
1180                         "buckets_out count and fw's BucketsRemaining "
1181                         "count has crossed the threshold, issuing a "
1182                         "LanReset to clear the fw's hashtable. You may "
1183                         "want to check your /var/log/messages for \"CRC "
1184                         "error\" event notifications.\n");
1185
1186                 mpt_lan_reset(dev);
1187                 mpt_lan_wake_post_buckets_task(dev, 0);
1188         }
1189
1190         return mpt_lan_receive_skb(dev, skb);
1191 }
1192
1193 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1194 /* Simple SGE's only at the moment */
1195
1196 static void
1197 mpt_lan_post_receive_buckets(struct mpt_lan_priv *priv)
1198 {
1199         struct net_device *dev = priv->dev;
1200         MPT_ADAPTER *mpt_dev = priv->mpt_dev;
1201         MPT_FRAME_HDR *mf;
1202         LANReceivePostRequest_t *pRecvReq;
1203         SGETransaction32_t *pTrans;
1204         SGESimple64_t *pSimple;
1205         struct sk_buff *skb;
1206         dma_addr_t dma;
1207         u32 curr, buckets, count, max;
1208         u32 len = (dev->mtu + dev->hard_header_len + 4);
1209         unsigned long flags;
1210         int i;
1211
1212         curr = atomic_read(&priv->buckets_out);
1213         buckets = (priv->max_buckets_out - curr);
1214
1215         dioprintk((KERN_INFO MYNAM ": %s/%s: @%s, Start_buckets = %u, buckets_out = %u\n",
1216                         IOC_AND_NETDEV_NAMES_s_s(dev),
1217                         __FUNCTION__, buckets, curr));
1218
1219         max = (mpt_dev->req_sz - MPT_LAN_RECEIVE_POST_REQUEST_SIZE) /
1220                         (MPT_LAN_TRANSACTION32_SIZE + sizeof(SGESimple64_t));
1221
1222         while (buckets) {
1223                 mf = mpt_get_msg_frame(LanCtx, mpt_dev);
1224                 if (mf == NULL) {
1225                         printk (KERN_ERR "%s: Unable to alloc request frame\n",
1226                                 __FUNCTION__);
1227                         dioprintk((KERN_ERR "%s: %u buckets remaining\n",
1228                                  __FUNCTION__, buckets));
1229                         goto out;
1230                 }
1231                 pRecvReq = (LANReceivePostRequest_t *) mf;
1232
1233                 count = buckets;
1234                 if (count > max)
1235                         count = max;
1236
1237                 pRecvReq->Function    = MPI_FUNCTION_LAN_RECEIVE;
1238                 pRecvReq->ChainOffset = 0;
1239                 pRecvReq->MsgFlags    = 0;
1240                 pRecvReq->PortNumber  = priv->pnum;
1241
1242                 pTrans = (SGETransaction32_t *) pRecvReq->SG_List;
1243                 pSimple = NULL;
1244
1245                 for (i = 0; i < count; i++) {
1246                         int ctx;
1247
1248                         spin_lock_irqsave(&priv->rxfidx_lock, flags);
1249                         if (priv->mpt_rxfidx_tail < 0) {
1250                                 printk (KERN_ERR "%s: Can't alloc context\n",
1251                                         __FUNCTION__);
1252                                 spin_unlock_irqrestore(&priv->rxfidx_lock,
1253                                                        flags);
1254                                 break;
1255                         }
1256
1257                         ctx = priv->mpt_rxfidx[priv->mpt_rxfidx_tail--];
1258
1259                         skb = priv->RcvCtl[ctx].skb;
1260                         if (skb && (priv->RcvCtl[ctx].len != len)) {
1261                                 pci_unmap_single(mpt_dev->pcidev,
1262                                                  priv->RcvCtl[ctx].dma,
1263                                                  priv->RcvCtl[ctx].len,
1264                                                  PCI_DMA_FROMDEVICE);
1265                                 dev_kfree_skb(priv->RcvCtl[ctx].skb);
1266                                 skb = priv->RcvCtl[ctx].skb = NULL;
1267                         }
1268
1269                         if (skb == NULL) {
1270                                 skb = dev_alloc_skb(len);
1271                                 if (skb == NULL) {
1272                                         printk (KERN_WARNING
1273                                                 MYNAM "/%s: Can't alloc skb\n",
1274                                                 __FUNCTION__);
1275                                         priv->mpt_rxfidx[++priv->mpt_rxfidx_tail] = ctx;
1276                                         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1277                                         break;
1278                                 }
1279
1280                                 dma = pci_map_single(mpt_dev->pcidev, skb->data,
1281                                                      len, PCI_DMA_FROMDEVICE);
1282
1283                                 priv->RcvCtl[ctx].skb = skb;
1284                                 priv->RcvCtl[ctx].dma = dma;
1285                                 priv->RcvCtl[ctx].len = len;
1286                         }
1287
1288                         spin_unlock_irqrestore(&priv->rxfidx_lock, flags);
1289
1290                         pTrans->ContextSize   = sizeof(u32);
1291                         pTrans->DetailsLength = 0;
1292                         pTrans->Flags         = 0;
1293                         pTrans->TransactionContext[0] = cpu_to_le32(ctx);
1294
1295                         pSimple = (SGESimple64_t *) pTrans->TransactionDetails;
1296
1297                         pSimple->FlagsLength = cpu_to_le32(
1298                                 ((MPI_SGE_FLAGS_END_OF_BUFFER |
1299                                   MPI_SGE_FLAGS_SIMPLE_ELEMENT |
1300                                   MPI_SGE_FLAGS_64_BIT_ADDRESSING) << MPI_SGE_FLAGS_SHIFT) | len);
1301                         pSimple->Address.Low = cpu_to_le32((u32) priv->RcvCtl[ctx].dma);
1302                         if (sizeof(dma_addr_t) > sizeof(u32))
1303                                 pSimple->Address.High = cpu_to_le32((u32) ((u64) priv->RcvCtl[ctx].dma >> 32));
1304                         else
1305                                 pSimple->Address.High = 0;
1306
1307                         pTrans = (SGETransaction32_t *) (pSimple + 1);
1308                 }
1309
1310                 if (pSimple == NULL) {
1311 /**/                    printk (KERN_WARNING MYNAM "/%s: No buckets posted\n",
1312 /**/                            __FUNCTION__);
1313                         mpt_free_msg_frame(mpt_dev, mf);
1314                         goto out;
1315                 }
1316
1317                 pSimple->FlagsLength |= cpu_to_le32(MPI_SGE_FLAGS_END_OF_LIST << MPI_SGE_FLAGS_SHIFT);
1318
1319                 pRecvReq->BucketCount = cpu_to_le32(i);
1320
1321 /*      printk(KERN_INFO MYNAM ": posting buckets\n   ");
1322  *      for (i = 0; i < j + 2; i ++)
1323  *          printk (" %08x", le32_to_cpu(msg[i]));
1324  *      printk ("\n");
1325  */
1326
1327                 mpt_put_msg_frame(LanCtx, mpt_dev, mf);
1328
1329                 priv->total_posted += i;
1330                 buckets -= i;
1331                 atomic_add(i, &priv->buckets_out);
1332         }
1333
1334 out:
1335         dioprintk((KERN_INFO MYNAM "/%s: End_buckets = %u, priv->buckets_out = %u\n",
1336                   __FUNCTION__, buckets, atomic_read(&priv->buckets_out)));
1337         dioprintk((KERN_INFO MYNAM "/%s: Posted %u buckets and received %u back\n",
1338         __FUNCTION__, priv->total_posted, priv->total_received));
1339
1340         clear_bit(0, &priv->post_buckets_active);
1341 }
1342
1343 static void
1344 mpt_lan_post_receive_buckets_work(struct work_struct *work)
1345 {
1346         mpt_lan_post_receive_buckets(container_of(work, struct mpt_lan_priv,
1347                                                   post_buckets_task.work));
1348 }
1349
1350 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1351 static struct net_device *
1352 mpt_register_lan_device (MPT_ADAPTER *mpt_dev, int pnum)
1353 {
1354         struct net_device *dev = alloc_fcdev(sizeof(struct mpt_lan_priv));
1355         struct mpt_lan_priv *priv = NULL;
1356         u8 HWaddr[FC_ALEN], *a;
1357
1358         if (!dev)
1359                 return NULL;
1360
1361         dev->mtu = MPT_LAN_MTU;
1362
1363         priv = netdev_priv(dev);
1364
1365         priv->dev = dev;
1366         priv->mpt_dev = mpt_dev;
1367         priv->pnum = pnum;
1368
1369         memset(&priv->post_buckets_task, 0, sizeof(priv->post_buckets_task));
1370         INIT_DELAYED_WORK(&priv->post_buckets_task,
1371                           mpt_lan_post_receive_buckets_work);
1372         priv->post_buckets_active = 0;
1373
1374         dlprintk((KERN_INFO MYNAM "@%d: bucketlen = %d\n",
1375                         __LINE__, dev->mtu + dev->hard_header_len + 4));
1376
1377         atomic_set(&priv->buckets_out, 0);
1378         priv->total_posted = 0;
1379         priv->total_received = 0;
1380         priv->max_buckets_out = max_buckets_out;
1381         if (mpt_dev->pfacts[0].MaxLanBuckets < max_buckets_out)
1382                 priv->max_buckets_out = mpt_dev->pfacts[0].MaxLanBuckets;
1383
1384         dlprintk((KERN_INFO MYNAM "@%d: MaxLanBuckets=%d, max_buckets_out/priv=%d/%d\n",
1385                         __LINE__,
1386                         mpt_dev->pfacts[0].MaxLanBuckets,
1387                         max_buckets_out,
1388                         priv->max_buckets_out));
1389
1390         priv->bucketthresh = priv->max_buckets_out * 2 / 3;
1391         spin_lock_init(&priv->txfidx_lock);
1392         spin_lock_init(&priv->rxfidx_lock);
1393
1394         memset(&priv->stats, 0, sizeof(priv->stats));
1395
1396         /*  Grab pre-fetched LANPage1 stuff. :-) */
1397         a = (u8 *) &mpt_dev->lan_cnfg_page1.HardwareAddressLow;
1398
1399         HWaddr[0] = a[5];
1400         HWaddr[1] = a[4];
1401         HWaddr[2] = a[3];
1402         HWaddr[3] = a[2];
1403         HWaddr[4] = a[1];
1404         HWaddr[5] = a[0];
1405
1406         dev->addr_len = FC_ALEN;
1407         memcpy(dev->dev_addr, HWaddr, FC_ALEN);
1408         memset(dev->broadcast, 0xff, FC_ALEN);
1409
1410         /* The Tx queue is 127 deep on the 909.
1411          * Give ourselves some breathing room.
1412          */
1413         priv->tx_max_out = (tx_max_out_p <= MPT_TX_MAX_OUT_LIM) ?
1414                             tx_max_out_p : MPT_TX_MAX_OUT_LIM;
1415
1416         dev->open = mpt_lan_open;
1417         dev->stop = mpt_lan_close;
1418         dev->get_stats = mpt_lan_get_stats;
1419         dev->set_multicast_list = NULL;
1420         dev->change_mtu = mpt_lan_change_mtu;
1421         dev->hard_start_xmit = mpt_lan_sdu_send;
1422
1423 /* Not in 2.3.42. Need 2.3.45+ */
1424         dev->tx_timeout = mpt_lan_tx_timeout;
1425         dev->watchdog_timeo = MPT_LAN_TX_TIMEOUT;
1426
1427         dlprintk((KERN_INFO MYNAM ": Finished registering dev "
1428                 "and setting initial values\n"));
1429
1430         SET_MODULE_OWNER(dev);
1431
1432         if (register_netdev(dev) != 0) {
1433                 free_netdev(dev);
1434                 dev = NULL;
1435         }
1436         return dev;
1437 }
1438
1439 static int
1440 mptlan_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1441 {
1442         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1443         struct net_device       *dev;
1444         int                     i;
1445
1446         for (i = 0; i < ioc->facts.NumberOfPorts; i++) {
1447                 printk(KERN_INFO MYNAM ": %s: PortNum=%x, "
1448                        "ProtocolFlags=%02Xh (%c%c%c%c)\n",
1449                        ioc->name, ioc->pfacts[i].PortNumber,
1450                        ioc->pfacts[i].ProtocolFlags,
1451                        MPT_PROTOCOL_FLAGS_c_c_c_c(
1452                                ioc->pfacts[i].ProtocolFlags));
1453
1454                 if (!(ioc->pfacts[i].ProtocolFlags &
1455                                         MPI_PORTFACTS_PROTOCOL_LAN)) {
1456                         printk(KERN_INFO MYNAM ": %s: Hmmm... LAN protocol "
1457                                "seems to be disabled on this adapter port!\n",
1458                                ioc->name);
1459                         continue;
1460                 }
1461
1462                 dev = mpt_register_lan_device(ioc, i);
1463                 if (!dev) {
1464                         printk(KERN_ERR MYNAM ": %s: Unable to register "
1465                                "port%d as a LAN device\n", ioc->name,
1466                                ioc->pfacts[i].PortNumber);
1467                         continue;
1468                 }
1469
1470                 printk(KERN_INFO MYNAM ": %s: Fusion MPT LAN device "
1471                        "registered as '%s'\n", ioc->name, dev->name);
1472                 printk(KERN_INFO MYNAM ": %s/%s: "
1473                        "LanAddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
1474                        IOC_AND_NETDEV_NAMES_s_s(dev),
1475                        dev->dev_addr[0], dev->dev_addr[1],
1476                        dev->dev_addr[2], dev->dev_addr[3],
1477                        dev->dev_addr[4], dev->dev_addr[5]);
1478
1479                 ioc->netdev = dev;
1480
1481                 return 0;
1482         }
1483
1484         return -ENODEV;
1485 }
1486
1487 static void
1488 mptlan_remove(struct pci_dev *pdev)
1489 {
1490         MPT_ADAPTER             *ioc = pci_get_drvdata(pdev);
1491         struct net_device       *dev = ioc->netdev;
1492
1493         if(dev != NULL) {
1494                 unregister_netdev(dev);
1495                 free_netdev(dev);
1496         }
1497 }
1498
1499 static struct mpt_pci_driver mptlan_driver = {
1500         .probe          = mptlan_probe,
1501         .remove         = mptlan_remove,
1502 };
1503
1504 static int __init mpt_lan_init (void)
1505 {
1506         show_mptmod_ver(LANAME, LANVER);
1507
1508         if ((LanCtx = mpt_register(lan_reply, MPTLAN_DRIVER)) <= 0) {
1509                 printk (KERN_ERR MYNAM ": Failed to register with MPT base driver\n");
1510                 return -EBUSY;
1511         }
1512
1513         /* Set the callback index to be used by driver core for turbo replies */
1514         mpt_lan_index = LanCtx;
1515
1516         dlprintk((KERN_INFO MYNAM ": assigned context of %d\n", LanCtx));
1517
1518         if (mpt_reset_register(LanCtx, mpt_lan_ioc_reset)) {
1519                 printk(KERN_ERR MYNAM ": Eieee! unable to register a reset "
1520                        "handler with mptbase! The world is at an end! "
1521                        "Everything is fading to black! Goodbye.\n");
1522                 return -EBUSY;
1523         }
1524
1525         dlprintk((KERN_INFO MYNAM ": Registered for IOC reset notifications\n"));
1526
1527         if (mpt_device_driver_register(&mptlan_driver, MPTLAN_DRIVER))
1528                 dprintk((KERN_INFO MYNAM ": failed to register dd callbacks\n"));
1529         return 0;
1530 }
1531
1532 static void __exit mpt_lan_exit(void)
1533 {
1534         mpt_device_driver_deregister(MPTLAN_DRIVER);
1535         mpt_reset_deregister(LanCtx);
1536
1537         if (LanCtx >= 0) {
1538                 mpt_deregister(LanCtx);
1539                 LanCtx = -1;
1540                 mpt_lan_index = 0;
1541         }
1542 }
1543
1544 module_init(mpt_lan_init);
1545 module_exit(mpt_lan_exit);
1546
1547 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1548 static unsigned short
1549 mpt_lan_type_trans(struct sk_buff *skb, struct net_device *dev)
1550 {
1551         struct mpt_lan_ohdr *fch = (struct mpt_lan_ohdr *)skb->data;
1552         struct fcllc *fcllc;
1553
1554         skb_reset_mac_header(skb);
1555         skb_pull(skb, sizeof(struct mpt_lan_ohdr));
1556
1557         if (fch->dtype == htons(0xffff)) {
1558                 u32 *p = (u32 *) fch;
1559
1560                 swab32s(p + 0);
1561                 swab32s(p + 1);
1562                 swab32s(p + 2);
1563                 swab32s(p + 3);
1564
1565                 printk (KERN_WARNING MYNAM ": %s: WARNING - Broadcast swap F/W bug detected!\n",
1566                                 NETDEV_PTR_TO_IOC_NAME_s(dev));
1567                 printk (KERN_WARNING MYNAM ": Please update sender @ MAC_addr = %02x:%02x:%02x:%02x:%02x:%02x\n",
1568                                 fch->saddr[0], fch->saddr[1], fch->saddr[2],
1569                                 fch->saddr[3], fch->saddr[4], fch->saddr[5]);
1570         }
1571
1572         if (*fch->daddr & 1) {
1573                 if (!memcmp(fch->daddr, dev->broadcast, FC_ALEN)) {
1574                         skb->pkt_type = PACKET_BROADCAST;
1575                 } else {
1576                         skb->pkt_type = PACKET_MULTICAST;
1577                 }
1578         } else {
1579                 if (memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) {
1580                         skb->pkt_type = PACKET_OTHERHOST;
1581                 } else {
1582                         skb->pkt_type = PACKET_HOST;
1583                 }
1584         }
1585
1586         fcllc = (struct fcllc *)skb->data;
1587
1588 #ifdef QLOGIC_NAA_WORKAROUND
1589 {
1590         u16 source_naa = fch->stype, found = 0;
1591
1592         /* Workaround for QLogic not following RFC 2625 in regards to the NAA
1593            value. */
1594
1595         if ((source_naa & 0xF000) == 0)
1596                 source_naa = swab16(source_naa);
1597
1598         if (fcllc->ethertype == htons(ETH_P_ARP))
1599             dlprintk ((KERN_INFO "mptlan/type_trans: got arp req/rep w/ naa of "
1600                       "%04x.\n", source_naa));
1601
1602         if ((fcllc->ethertype == htons(ETH_P_ARP)) &&
1603            ((source_naa >> 12) !=  MPT_LAN_NAA_RFC2625)){
1604                 struct NAA_Hosed *nh, *prevnh;
1605                 int i;
1606
1607                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep from "
1608                           "system with non-RFC 2625 NAA value (%04x).\n",
1609                           source_naa));
1610
1611                 write_lock_irq(&bad_naa_lock);
1612                 for (prevnh = nh = mpt_bad_naa; nh != NULL;
1613                      prevnh=nh, nh=nh->next) {
1614                         if ((nh->ieee[0] == fch->saddr[0]) &&
1615                             (nh->ieee[1] == fch->saddr[1]) &&
1616                             (nh->ieee[2] == fch->saddr[2]) &&
1617                             (nh->ieee[3] == fch->saddr[3]) &&
1618                             (nh->ieee[4] == fch->saddr[4]) &&
1619                             (nh->ieee[5] == fch->saddr[5])) {
1620                                 found = 1;
1621                                 dlprintk ((KERN_INFO "mptlan/type_trans: ARP Re"
1622                                          "q/Rep w/ bad NAA from system already"
1623                                          " in DB.\n"));
1624                                 break;
1625                         }
1626                 }
1627
1628                 if ((!found) && (nh == NULL)) {
1629
1630                         nh = kmalloc(sizeof(struct NAA_Hosed), GFP_KERNEL);
1631                         dlprintk ((KERN_INFO "mptlan/type_trans: ARP Req/Rep w/"
1632                                  " bad NAA from system not yet in DB.\n"));
1633
1634                         if (nh != NULL) {
1635                                 nh->next = NULL;
1636                                 if (!mpt_bad_naa)
1637                                         mpt_bad_naa = nh;
1638                                 if (prevnh)
1639                                         prevnh->next = nh;
1640
1641                                 nh->NAA = source_naa; /* Set the S_NAA value. */
1642                                 for (i = 0; i < FC_ALEN; i++)
1643                                         nh->ieee[i] = fch->saddr[i];
1644                                 dlprintk ((KERN_INFO "Got ARP from %02x:%02x:%02x:%02x:"
1645                                           "%02x:%02x with non-compliant S_NAA value.\n",
1646                                           fch->saddr[0], fch->saddr[1], fch->saddr[2],
1647                                           fch->saddr[3], fch->saddr[4],fch->saddr[5]));
1648                         } else {
1649                                 printk (KERN_ERR "mptlan/type_trans: Unable to"
1650                                         " kmalloc a NAA_Hosed struct.\n");
1651                         }
1652                 } else if (!found) {
1653                         printk (KERN_ERR "mptlan/type_trans: found not"
1654                                 " set, but nh isn't null. Evil "
1655                                 "funkiness abounds.\n");
1656                 }
1657                 write_unlock_irq(&bad_naa_lock);
1658         }
1659 }
1660 #endif
1661
1662         /* Strip the SNAP header from ARP packets since we don't
1663          * pass them through to the 802.2/SNAP layers.
1664          */
1665         if (fcllc->dsap == EXTENDED_SAP &&
1666                 (fcllc->ethertype == htons(ETH_P_IP) ||
1667                  fcllc->ethertype == htons(ETH_P_ARP))) {
1668                 skb_pull(skb, sizeof(struct fcllc));
1669                 return fcllc->ethertype;
1670         }
1671
1672         return htons(ETH_P_802_2);
1673 }
1674
1675 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/