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