drivers/message/fusion/mptlan.c

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

DEFINITIONS
