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