SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/message/fusion/mptlan.c

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