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