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