drivers/staging/slicoss/slicoss.c

   1 /**************************************************************************
   2  *
   3  * Copyright  2000-2006 Alacritech, Inc.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above
  12  *    copyright notice, this list of conditions and the following
  13  *    disclaimer in the documentation and/or other materials provided
  14  *    with the distribution.
  15  *
  16  * Alternatively, this software may be distributed under the terms of the
  17  * GNU General Public License ("GPL") version 2 as published by the Free
  18  * Software Foundation.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY ALACRITECH, INC. ``AS IS'' AND ANY
  21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ALACRITECH, INC. OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  27  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  28  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  30  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * The views and conclusions contained in the software and documentation
  34  * are those of the authors and should not be interpreted as representing
  35  * official policies, either expressed or implied, of Alacritech, Inc.
  36  *
  37  **************************************************************************/
  38
  39 /*
  40  * FILENAME: slicoss.c
  41  *
  42  * The SLICOSS driver for Alacritech's IS-NIC products.
  43  *
  44  * This driver is supposed to support:
  45  *
  46  *      Mojave cards (single port PCI Gigabit) both copper and fiber
  47  *      Oasis cards (single and dual port PCI-x Gigabit) copper and fiber
  48  *      Kalahari cards (dual and quad port PCI-e Gigabit) copper and fiber
  49  *
  50  * The driver was actually tested on Oasis and Kalahari cards.
  51  *
  52  *
  53  * NOTE: This is the standard, non-accelerated version of Alacritech's
  54  *       IS-NIC driver.
  55  */
  56
  57 #define KLUDGE_FOR_4GB_BOUNDARY         1
  58 #define DEBUG_MICROCODE                 1
  59 #define DBG                             1
  60 #define SLIC_INTERRUPT_PROCESS_LIMIT    1
  61 #define SLIC_OFFLOAD_IP_CHECKSUM        1
  62 #define STATS_TIMER_INTERVAL            2
  63 #define PING_TIMER_INTERVAL             1
  64 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  65
  66 #include <linux/kernel.h>
  67 #include <linux/string.h>
  68 #include <linux/errno.h>
  69 #include <linux/ioport.h>
  70 #include <linux/slab.h>
  71 #include <linux/interrupt.h>
  72 #include <linux/timer.h>
  73 #include <linux/pci.h>
  74 #include <linux/spinlock.h>
  75 #include <linux/init.h>
  76 #include <linux/bitops.h>
  77 #include <linux/io.h>
  78 #include <linux/netdevice.h>
  79 #include <linux/crc32.h>
  80 #include <linux/etherdevice.h>
  81 #include <linux/skbuff.h>
  82 #include <linux/delay.h>
  83 #include <linux/seq_file.h>
  84 #include <linux/kthread.h>
  85 #include <linux/module.h>
  86
  87 #include <linux/firmware.h>
  88 #include <linux/types.h>
  89 #include <linux/dma-mapping.h>
  90 #include <linux/mii.h>
  91 #include <linux/if_vlan.h>
  92 #include <asm/unaligned.h>
  93
  94 #include <linux/ethtool.h>
  95 #include <linux/uaccess.h>
  96 #include "slichw.h"
  97 #include "slic.h"
  98
  99 static uint slic_first_init = 1;
 100 static char *slic_banner = "Alacritech SLIC Technology(tm) Server and Storage Accelerator (Non-Accelerated)";
 101
 102 static char *slic_proc_version = "2.0.351  2006/07/14 12:26:00";
 103
 104 static struct base_driver slic_global = { {}, 0, 0, 0, 1, NULL, NULL };
 105 #define DEFAULT_INTAGG_DELAY 100
 106 static unsigned int rcv_count;
 107
 108 #define DRV_NAME          "slicoss"
 109 #define DRV_VERSION       "2.0.1"
 110 #define DRV_AUTHOR        "Alacritech, Inc. Engineering"
 111 #define DRV_DESCRIPTION   "Alacritech SLIC Techonology(tm) "\
 112                 "Non-Accelerated Driver"
 113 #define DRV_COPYRIGHT     "Copyright  2000-2006 Alacritech, Inc. "\
 114                 "All rights reserved."
 115 #define PFX                DRV_NAME " "
 116
 117 MODULE_AUTHOR(DRV_AUTHOR);
 118 MODULE_DESCRIPTION(DRV_DESCRIPTION);
 119 MODULE_LICENSE("Dual BSD/GPL");
 120
 121 static const struct pci_device_id slic_pci_tbl[] = {
 122         { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH, SLIC_1GB_DEVICE_ID) },
 123         { PCI_DEVICE(PCI_VENDOR_ID_ALACRITECH, SLIC_2GB_DEVICE_ID) },
 124         { 0 }
 125 };
 126
 127 static const struct ethtool_ops slic_ethtool_ops;
 128
 129 MODULE_DEVICE_TABLE(pci, slic_pci_tbl);
 130
 131 static void slic_mcast_set_bit(struct adapter *adapter, char *address)
 132 {
 133         unsigned char crcpoly;
 134
 135         /* Get the CRC polynomial for the mac address */
 136         /*
 137          * we use bits 1-8 (lsb), bitwise reversed,
 138          * msb (= lsb bit 0 before bitrev) is automatically discarded
 139          */
 140         crcpoly = ether_crc(ETH_ALEN, address) >> 23;
 141
 142         /*
 143          * We only have space on the SLIC for 64 entries.  Lop
 144          * off the top two bits. (2^6 = 64)
 145          */
 146         crcpoly &= 0x3F;
 147
 148         /* OR in the new bit into our 64 bit mask. */
 149         adapter->mcastmask |= (u64)1 << crcpoly;
 150 }
 151
 152 static void slic_mcast_set_mask(struct adapter *adapter)
 153 {
 154         if (adapter->macopts & (MAC_ALLMCAST | MAC_PROMISC)) {
 155                 /*
 156                  * Turn on all multicast addresses. We have to do this for
 157                  * promiscuous mode as well as ALLMCAST mode.  It saves the
 158                  * Microcode from having to keep state about the MAC
 159                  * configuration.
 160                  */
 161                 slic_write32(adapter, SLIC_REG_MCASTLOW, 0xFFFFFFFF);
 162                 slic_write32(adapter, SLIC_REG_MCASTHIGH, 0xFFFFFFFF);
 163         } else {
 164                 /*
 165                  * Commit our multicast mast to the SLIC by writing to the
 166                  * multicast address mask registers
 167                  */
 168                 slic_write32(adapter, SLIC_REG_MCASTLOW,
 169                              (u32)(adapter->mcastmask & 0xFFFFFFFF));
 170                 slic_write32(adapter, SLIC_REG_MCASTHIGH,
 171                              (u32)((adapter->mcastmask >> 32) & 0xFFFFFFFF));
 172         }
 173 }
 174
 175 static void slic_timer_ping(ulong dev)
 176 {
 177         struct adapter *adapter;
 178         struct sliccard *card;
 179
 180         adapter = netdev_priv((struct net_device *)dev);
 181         card = adapter->card;
 182
 183         adapter->pingtimer.expires = jiffies + (PING_TIMER_INTERVAL * HZ);
 184         add_timer(&adapter->pingtimer);
 185 }
 186
 187 /*
 188  *  slic_link_config
 189  *
 190  *  Write phy control to configure link duplex/speed
 191  *
 192  */
 193 static void slic_link_config(struct adapter *adapter,
 194                       u32 linkspeed, u32 linkduplex)
 195 {
 196         u32 speed;
 197         u32 duplex;
 198         u32 phy_config;
 199         u32 phy_advreg;
 200         u32 phy_gctlreg;
 201
 202         if (adapter->state != ADAPT_UP)
 203                 return;
 204
 205         if (linkspeed > LINK_1000MB)
 206                 linkspeed = LINK_AUTOSPEED;
 207         if (linkduplex > LINK_AUTOD)
 208                 linkduplex = LINK_AUTOD;
 209
 210         if ((linkspeed == LINK_AUTOSPEED) || (linkspeed == LINK_1000MB)) {
 211                 if (adapter->flags & ADAPT_FLAGS_FIBERMEDIA) {
 212                         /*
 213                          * We've got a fiber gigabit interface, and register
 214                          *  4 is different in fiber mode than in copper mode
 215                          */
 216
 217                         /* advertise FD only @1000 Mb */
 218                         phy_advreg = (MIICR_REG_4 | (PAR_ADV1000XFD));
 219                         /* enable PAUSE frames        */
 220                         phy_advreg |= PAR_ASYMPAUSE_FIBER;
 221                         slic_write32(adapter, SLIC_REG_WPHY, phy_advreg);
 222
 223                         if (linkspeed == LINK_AUTOSPEED) {
 224                                 /* reset phy, enable auto-neg  */
 225                                 phy_config =
 226                                     (MIICR_REG_PCR |
 227                                      (PCR_RESET | PCR_AUTONEG |
 228                                       PCR_AUTONEG_RST));
 229                                 slic_write32(adapter, SLIC_REG_WPHY,
 230                                              phy_config);
 231                         } else {        /* forced 1000 Mb FD*/
 232                                 /*
 233                                  * power down phy to break link
 234                                  * this may not work)
 235                                  */
 236                                 phy_config = (MIICR_REG_PCR | PCR_POWERDOWN);
 237                                 slic_write32(adapter, SLIC_REG_WPHY,
 238                                              phy_config);
 239                                 slic_flush_write(adapter);
 240                                 /*
 241                                  * wait, Marvell says 1 sec,
 242                                  * try to get away with 10 ms
 243                                  */
 244                                 mdelay(10);
 245
 246                                 /*
 247                                  * disable auto-neg, set speed/duplex,
 248                                  * soft reset phy, powerup
 249                                  */
 250                                 phy_config =
 251                                     (MIICR_REG_PCR |
 252                                      (PCR_RESET | PCR_SPEED_1000 |
 253                                       PCR_DUPLEX_FULL));
 254                                 slic_write32(adapter, SLIC_REG_WPHY,
 255                                              phy_config);
 256                         }
 257                 } else {        /* copper gigabit */
 258
 259                         /*
 260                          * Auto-Negotiate or 1000 Mb must be auto negotiated
 261                          * We've got a copper gigabit interface, and
 262                          * register 4 is different in copper mode than
 263                          * in fiber mode
 264                          */
 265                         if (linkspeed == LINK_AUTOSPEED) {
 266                                 /* advertise 10/100 Mb modes   */
 267                                 phy_advreg =
 268                                     (MIICR_REG_4 |
 269                                      (PAR_ADV100FD | PAR_ADV100HD | PAR_ADV10FD
 270                                       | PAR_ADV10HD));
 271                         } else {
 272                         /*
 273                          * linkspeed == LINK_1000MB -
 274                          * don't advertise 10/100 Mb modes
 275                          */
 276                                 phy_advreg = MIICR_REG_4;
 277                         }
 278                         /* enable PAUSE frames  */
 279                         phy_advreg |= PAR_ASYMPAUSE;
 280                         /* required by the Cicada PHY  */
 281                         phy_advreg |= PAR_802_3;
 282                         slic_write32(adapter, SLIC_REG_WPHY, phy_advreg);
 283                         /* advertise FD only @1000 Mb  */
 284                         phy_gctlreg = (MIICR_REG_9 | (PGC_ADV1000FD));
 285                         slic_write32(adapter, SLIC_REG_WPHY, phy_gctlreg);
 286
 287                         if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) {
 288                                 /*
 289                                  * if a Marvell PHY
 290                                  * enable auto crossover
 291                                  */
 292                                 phy_config =
 293                                     (MIICR_REG_16 | (MRV_REG16_XOVERON));
 294                                 slic_write32(adapter, SLIC_REG_WPHY,
 295                                              phy_config);
 296
 297                                 /* reset phy, enable auto-neg  */
 298                                 phy_config =
 299                                     (MIICR_REG_PCR |
 300                                      (PCR_RESET | PCR_AUTONEG |
 301                                       PCR_AUTONEG_RST));
 302                                 slic_write32(adapter, SLIC_REG_WPHY,
 303                                              phy_config);
 304                         } else {        /* it's a Cicada PHY  */
 305                                 /* enable and restart auto-neg (don't reset)  */
 306                                 phy_config =
 307                                     (MIICR_REG_PCR |
 308                                      (PCR_AUTONEG | PCR_AUTONEG_RST));
 309                                 slic_write32(adapter, SLIC_REG_WPHY,
 310                                              phy_config);
 311                         }
 312                 }
 313         } else {
 314                 /* Forced 10/100  */
 315                 if (linkspeed == LINK_10MB)
 316                         speed = 0;
 317                 else
 318                         speed = PCR_SPEED_100;
 319                 if (linkduplex == LINK_HALFD)
 320                         duplex = 0;
 321                 else
 322                         duplex = PCR_DUPLEX_FULL;
 323
 324                 if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) {
 325                         /*
 326                          * if a Marvell PHY
 327                          * disable auto crossover
 328                          */
 329                         phy_config = (MIICR_REG_16 | (MRV_REG16_XOVEROFF));
 330                         slic_write32(adapter, SLIC_REG_WPHY, phy_config);
 331                 }
 332
 333                 /* power down phy to break link (this may not work)  */
 334                 phy_config = (MIICR_REG_PCR | (PCR_POWERDOWN | speed | duplex));
 335                 slic_write32(adapter, SLIC_REG_WPHY, phy_config);
 336                 slic_flush_write(adapter);
 337                 /* wait, Marvell says 1 sec, try to get away with 10 ms */
 338                 mdelay(10);
 339
 340                 if (adapter->subsysid != SLIC_1GB_CICADA_SUBSYS_ID) {
 341                         /*
 342                          * if a Marvell PHY
 343                          * disable auto-neg, set speed,
 344                          * soft reset phy, powerup
 345                          */
 346                         phy_config =
 347                             (MIICR_REG_PCR | (PCR_RESET | speed | duplex));
 348                         slic_write32(adapter, SLIC_REG_WPHY, phy_config);
 349                 } else {        /* it's a Cicada PHY  */
 350                         /* disable auto-neg, set speed, powerup  */
 351                         phy_config = (MIICR_REG_PCR | (speed | duplex));
 352                         slic_write32(adapter, SLIC_REG_WPHY, phy_config);
 353                 }
 354         }
 355 }
 356
 357 static int slic_card_download_gbrcv(struct adapter *adapter)
 358 {
 359         const struct firmware *fw;
 360         const char *file = "";
 361         int ret;
 362         u32 codeaddr;
 363         u32 instruction;
 364         int index = 0;
 365         u32 rcvucodelen = 0;
 366
 367         switch (adapter->devid) {
 368         case SLIC_2GB_DEVICE_ID:
 369                 file = "/*(DEBLOBBED)*/";
 370                 break;
 371         case SLIC_1GB_DEVICE_ID:
 372                 file = "/*(DEBLOBBED)*/";
 373                 break;
 374         default:
 375                 return -ENOENT;
 376         }
 377
 378         ret = reject_firmware(&fw, file, &adapter->pcidev->dev);
 379         if (ret) {
 380                 dev_err(&adapter->pcidev->dev,
 381                         "Failed to load firmware %s\n", file);
 382                 return ret;
 383         }
 384
 385         rcvucodelen = *(u32 *)(fw->data + index);
 386         index += 4;
 387         switch (adapter->devid) {
 388         case SLIC_2GB_DEVICE_ID:
 389                 if (rcvucodelen != OasisRcvUCodeLen) {
 390                         release_firmware(fw);
 391                         return -EINVAL;
 392                 }
 393                 break;
 394         case SLIC_1GB_DEVICE_ID:
 395                 if (rcvucodelen != GBRcvUCodeLen) {
 396                         release_firmware(fw);
 397                         return -EINVAL;
 398                 }
 399                 break;
 400         }
 401         /* start download */
 402         slic_write32(adapter, SLIC_REG_RCV_WCS, SLIC_RCVWCS_BEGIN);
 403         /* download the rcv sequencer ucode */
 404         for (codeaddr = 0; codeaddr < rcvucodelen; codeaddr++) {
 405                 /* write out instruction address */
 406                 slic_write32(adapter, SLIC_REG_RCV_WCS, codeaddr);
 407
 408                 instruction = *(u32 *)(fw->data + index);
 409                 index += 4;
 410                 /* write out the instruction data low addr */
 411                 slic_write32(adapter, SLIC_REG_RCV_WCS, instruction);
 412
 413                 instruction = *(u8 *)(fw->data + index);
 414                 index++;
 415                 /* write out the instruction data high addr */
 416                 slic_write32(adapter, SLIC_REG_RCV_WCS, instruction);
 417         }
 418
 419         /* download finished */
 420         release_firmware(fw);
 421         slic_write32(adapter, SLIC_REG_RCV_WCS, SLIC_RCVWCS_FINISH);
 422         slic_flush_write(adapter);
 423
 424         return 0;
 425 }
 426
 427 /*(DEBLOBBED)*/
 428
 429 static int slic_card_download(struct adapter *adapter)
 430 {
 431         const struct firmware *fw;
 432         const char *file = "";
 433         int ret;
 434         u32 section;
 435         int thissectionsize;
 436         int codeaddr;
 437         u32 instruction;
 438         u32 baseaddress;
 439         u32 i;
 440         u32 numsects = 0;
 441         u32 sectsize[3];
 442         u32 sectstart[3];
 443         int ucode_start, index = 0;
 444
 445         switch (adapter->devid) {
 446         case SLIC_2GB_DEVICE_ID:
 447                 file = "/*(DEBLOBBED)*/";
 448                 break;
 449         case SLIC_1GB_DEVICE_ID:
 450                 file = "/*(DEBLOBBED)*/";
 451                 break;
 452         default:
 453                 return -ENOENT;
 454         }
 455         ret = reject_firmware(&fw, file, &adapter->pcidev->dev);
 456         if (ret) {
 457                 dev_err(&adapter->pcidev->dev,
 458                         "Failed to load firmware %s\n", file);
 459                 return ret;
 460         }
 461         numsects = *(u32 *)(fw->data + index);
 462         index += 4;
 463         for (i = 0; i < numsects; i++) {
 464                 sectsize[i] = *(u32 *)(fw->data + index);
 465                 index += 4;
 466         }
 467         for (i = 0; i < numsects; i++) {
 468                 sectstart[i] = *(u32 *)(fw->data + index);
 469                 index += 4;
 470         }
 471         ucode_start = index;
 472         instruction = *(u32 *)(fw->data + index);
 473         index += 4;
 474         for (section = 0; section < numsects; section++) {
 475                 baseaddress = sectstart[section];
 476                 thissectionsize = sectsize[section] >> 3;
 477
 478                 for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) {
 479                         /* Write out instruction address */
 480                         slic_write32(adapter, SLIC_REG_WCS,
 481                                      baseaddress + codeaddr);
 482                         /* Write out instruction to low addr */
 483                         slic_write32(adapter, SLIC_REG_WCS,
 484                                      instruction);
 485                         instruction = *(u32 *)(fw->data + index);
 486                         index += 4;
 487
 488                         /* Write out instruction to high addr */
 489                         slic_write32(adapter, SLIC_REG_WCS,
 490                                      instruction);
 491                         instruction = *(u32 *)(fw->data + index);
 492                         index += 4;
 493                 }
 494         }
 495         index = ucode_start;
 496         for (section = 0; section < numsects; section++) {
 497                 instruction = *(u32 *)(fw->data + index);
 498                 baseaddress = sectstart[section];
 499                 if (baseaddress < 0x8000)
 500                         continue;
 501                 thissectionsize = sectsize[section] >> 3;
 502
 503                 for (codeaddr = 0; codeaddr < thissectionsize; codeaddr++) {
 504                         /* Write out instruction address */
 505                         slic_write32(adapter, SLIC_REG_WCS,
 506                                      SLIC_WCS_COMPARE | (baseaddress +
 507                                                          codeaddr));
 508                         /* Write out instruction to low addr */
 509                         slic_write32(adapter, SLIC_REG_WCS, instruction);
 510                         instruction = *(u32 *)(fw->data + index);
 511                         index += 4;
 512                         /* Write out instruction to high addr */
 513                         slic_write32(adapter, SLIC_REG_WCS, instruction);
 514                         instruction = *(u32 *)(fw->data + index);
 515                         index += 4;
 516                 }
 517         }
 518         release_firmware(fw);
 519         /* Everything OK, kick off the card */
 520         mdelay(10);
 521
 522         slic_write32(adapter, SLIC_REG_WCS, SLIC_WCS_START);
 523         slic_flush_write(adapter);
 524         /*
 525          * stall for 20 ms, long enough for ucode to init card
 526          * and reach mainloop
 527          */
 528         mdelay(20);
 529
 530         return 0;
 531 }
 532
 533 /*(DEBLOBBED)*/
 534
 535 static void slic_adapter_set_hwaddr(struct adapter *adapter)
 536 {
 537         struct sliccard *card = adapter->card;
 538
 539         if ((adapter->card) && (card->config_set)) {
 540                 memcpy(adapter->macaddr,
 541                        card->config.MacInfo[adapter->functionnumber].macaddrA,
 542                        sizeof(struct slic_config_mac));
 543                 if (is_zero_ether_addr(adapter->currmacaddr))
 544                         memcpy(adapter->currmacaddr, adapter->macaddr,
 545                                ETH_ALEN);
 546                 if (adapter->netdev)
 547                         memcpy(adapter->netdev->dev_addr, adapter->currmacaddr,
 548                                ETH_ALEN);
 549         }
 550 }
 551
 552 static void slic_intagg_set(struct adapter *adapter, u32 value)
 553 {
 554         slic_write32(adapter, SLIC_REG_INTAGG, value);
 555         adapter->card->loadlevel_current = value;
 556 }
 557
 558 static void slic_soft_reset(struct adapter *adapter)
 559 {
 560         if (adapter->card->state == CARD_UP) {
 561                 slic_write32(adapter, SLIC_REG_QUIESCE, 0);
 562                 slic_flush_write(adapter);
 563                 mdelay(1);
 564         }
 565
 566         slic_write32(adapter, SLIC_REG_RESET, SLIC_RESET_MAGIC);
 567         slic_flush_write(adapter);
 568
 569         mdelay(1);
 570 }
 571
 572 static void slic_mac_address_config(struct adapter *adapter)
 573 {
 574         u32 value;
 575         u32 value2;
 576
 577         value = ntohl(*(__be32 *)&adapter->currmacaddr[2]);
 578         slic_write32(adapter, SLIC_REG_WRADDRAL, value);
 579         slic_write32(adapter, SLIC_REG_WRADDRBL, value);
 580
 581         value2 = (u32)((adapter->currmacaddr[0] << 8 |
 582                              adapter->currmacaddr[1]) & 0xFFFF);
 583
 584         slic_write32(adapter, SLIC_REG_WRADDRAH, value2);
 585         slic_write32(adapter, SLIC_REG_WRADDRBH, value2);
 586
 587         /*
 588          * Write our multicast mask out to the card.  This is done
 589          * here in addition to the slic_mcast_addr_set routine
 590          * because ALL_MCAST may have been enabled or disabled
 591          */
 592         slic_mcast_set_mask(adapter);
 593 }
 594
 595 static void slic_mac_config(struct adapter *adapter)
 596 {
 597         u32 value;
 598
 599         /* Setup GMAC gaps */
 600         if (adapter->linkspeed == LINK_1000MB) {
 601                 value = ((GMCR_GAPBB_1000 << GMCR_GAPBB_SHIFT) |
 602                          (GMCR_GAPR1_1000 << GMCR_GAPR1_SHIFT) |
 603                          (GMCR_GAPR2_1000 << GMCR_GAPR2_SHIFT));
 604         } else {
 605                 value = ((GMCR_GAPBB_100 << GMCR_GAPBB_SHIFT) |
 606                          (GMCR_GAPR1_100 << GMCR_GAPR1_SHIFT) |
 607                          (GMCR_GAPR2_100 << GMCR_GAPR2_SHIFT));
 608         }
 609
 610         /* enable GMII */
 611         if (adapter->linkspeed == LINK_1000MB)
 612                 value |= GMCR_GBIT;
 613
 614         /* enable fullduplex */
 615         if ((adapter->linkduplex == LINK_FULLD)
 616             || (adapter->macopts & MAC_LOOPBACK)) {
 617                 value |= GMCR_FULLD;
 618         }
 619
 620         /* write mac config */
 621         slic_write32(adapter, SLIC_REG_WMCFG, value);
 622
 623         /* setup mac addresses */
 624         slic_mac_address_config(adapter);
 625 }
 626
 627 static void slic_config_set(struct adapter *adapter, bool linkchange)
 628 {
 629         u32 value;
 630         u32 RcrReset;
 631
 632         if (linkchange) {
 633                 /* Setup MAC */
 634                 slic_mac_config(adapter);
 635                 RcrReset = GRCR_RESET;
 636         } else {
 637                 slic_mac_address_config(adapter);
 638                 RcrReset = 0;
 639         }
 640
 641         if (adapter->linkduplex == LINK_FULLD) {
 642                 /* setup xmtcfg */
 643                 value = (GXCR_RESET |   /* Always reset     */
 644                          GXCR_XMTEN |   /* Enable transmit  */
 645                          GXCR_PAUSEEN); /* Enable pause     */
 646
 647                 slic_write32(adapter, SLIC_REG_WXCFG, value);
 648
 649                 /* Setup rcvcfg last */
 650                 value = (RcrReset |     /* Reset, if linkchange */
 651                          GRCR_CTLEN |   /* Enable CTL frames    */
 652                          GRCR_ADDRAEN | /* Address A enable     */
 653                          GRCR_RCVBAD |  /* Rcv bad frames       */
 654                          (GRCR_HASHSIZE << GRCR_HASHSIZE_SHIFT));
 655         } else {
 656                 /* setup xmtcfg */
 657                 value = (GXCR_RESET |   /* Always reset     */
 658                          GXCR_XMTEN);   /* Enable transmit  */
 659
 660                 slic_write32(adapter, SLIC_REG_WXCFG, value);
 661
 662                 /* Setup rcvcfg last */
 663                 value = (RcrReset |     /* Reset, if linkchange */
 664                          GRCR_ADDRAEN | /* Address A enable     */
 665                          GRCR_RCVBAD |  /* Rcv bad frames       */
 666                          (GRCR_HASHSIZE << GRCR_HASHSIZE_SHIFT));
 667         }
 668
 669         if (adapter->state != ADAPT_DOWN) {
 670                 /* Only enable receive if we are restarting or running */
 671                 value |= GRCR_RCVEN;
 672         }
 673
 674         if (adapter->macopts & MAC_PROMISC)
 675                 value |= GRCR_RCVALL;
 676
 677         slic_write32(adapter, SLIC_REG_WRCFG, value);
 678 }
 679
 680 /*
 681  *  Turn off RCV and XMT, power down PHY
 682  */
 683 static void slic_config_clear(struct adapter *adapter)
 684 {
 685         u32 value;
 686         u32 phy_config;
 687
 688         /* Setup xmtcfg */
 689         value = (GXCR_RESET |   /* Always reset */
 690                  GXCR_PAUSEEN); /* Enable pause */
 691
 692         slic_write32(adapter, SLIC_REG_WXCFG, value);
 693
 694         value = (GRCR_RESET |   /* Always reset      */
 695                  GRCR_CTLEN |   /* Enable CTL frames */
 696                  GRCR_ADDRAEN | /* Address A enable  */
 697                  (GRCR_HASHSIZE << GRCR_HASHSIZE_SHIFT));
 698
 699         slic_write32(adapter, SLIC_REG_WRCFG, value);
 700
 701         /* power down phy */
 702         phy_config = (MIICR_REG_PCR | (PCR_POWERDOWN));
 703         slic_write32(adapter, SLIC_REG_WPHY, phy_config);
 704 }
 705
 706 static bool slic_mac_filter(struct adapter *adapter,
 707                         struct ether_header *ether_frame)
 708 {
 709         struct net_device *netdev = adapter->netdev;
 710         u32 opts = adapter->macopts;
 711
 712         if (opts & MAC_PROMISC)
 713                 return true;
 714
 715         if (is_broadcast_ether_addr(ether_frame->ether_dhost)) {
 716                 if (opts & MAC_BCAST) {
 717                         adapter->rcv_broadcasts++;
 718                         return true;
 719                 }
 720
 721                 return false;
 722         }
 723
 724         if (is_multicast_ether_addr(ether_frame->ether_dhost)) {
 725                 if (opts & MAC_ALLMCAST) {
 726                         adapter->rcv_multicasts++;
 727                         netdev->stats.multicast++;
 728                         return true;
 729                 }
 730                 if (opts & MAC_MCAST) {
 731                         struct mcast_address *mcaddr = adapter->mcastaddrs;
 732
 733                         while (mcaddr) {
 734                                 if (ether_addr_equal(mcaddr->address,
 735                                                      ether_frame->ether_dhost)) {
 736                                         adapter->rcv_multicasts++;
 737                                         netdev->stats.multicast++;
 738                                         return true;
 739                                 }
 740                                 mcaddr = mcaddr->next;
 741                         }
 742
 743                         return false;
 744                 }
 745
 746                 return false;
 747         }
 748         if (opts & MAC_DIRECTED) {
 749                 adapter->rcv_unicasts++;
 750                 return true;
 751         }
 752         return false;
 753 }
 754
 755 static int slic_mac_set_address(struct net_device *dev, void *ptr)
 756 {
 757         struct adapter *adapter = netdev_priv(dev);
 758         struct sockaddr *addr = ptr;
 759
 760         if (netif_running(dev))
 761                 return -EBUSY;
 762         if (!adapter)
 763                 return -EBUSY;
 764
 765         if (!is_valid_ether_addr(addr->sa_data))
 766                 return -EINVAL;
 767
 768         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 769         memcpy(adapter->currmacaddr, addr->sa_data, dev->addr_len);
 770
 771         slic_config_set(adapter, true);
 772         return 0;
 773 }
 774
 775 static void slic_timer_load_check(ulong cardaddr)
 776 {
 777         struct sliccard *card = (struct sliccard *)cardaddr;
 778         struct adapter *adapter = card->master;
 779         u32 load = card->events;
 780         u32 level = 0;
 781
 782         if ((adapter) && (adapter->state == ADAPT_UP) &&
 783             (card->state == CARD_UP) && (slic_global.dynamic_intagg)) {
 784                 if (adapter->devid == SLIC_1GB_DEVICE_ID) {
 785                         if (adapter->linkspeed == LINK_1000MB)
 786                                 level = 100;
 787                         else {
 788                                 if (load > SLIC_LOAD_5)
 789                                         level = SLIC_INTAGG_5;
 790                                 else if (load > SLIC_LOAD_4)
 791                                         level = SLIC_INTAGG_4;
 792                                 else if (load > SLIC_LOAD_3)
 793                                         level = SLIC_INTAGG_3;
 794                                 else if (load > SLIC_LOAD_2)
 795                                         level = SLIC_INTAGG_2;
 796                                 else if (load > SLIC_LOAD_1)
 797                                         level = SLIC_INTAGG_1;
 798                                 else
 799                                         level = SLIC_INTAGG_0;
 800                         }
 801                         if (card->loadlevel_current != level) {
 802                                 card->loadlevel_current = level;
 803                                 slic_write32(adapter, SLIC_REG_INTAGG, level);
 804                         }
 805                 } else {
 806                         if (load > SLIC_LOAD_5)
 807                                 level = SLIC_INTAGG_5;
 808                         else if (load > SLIC_LOAD_4)
 809                                 level = SLIC_INTAGG_4;
 810                         else if (load > SLIC_LOAD_3)
 811                                 level = SLIC_INTAGG_3;
 812                         else if (load > SLIC_LOAD_2)
 813                                 level = SLIC_INTAGG_2;
 814                         else if (load > SLIC_LOAD_1)
 815                                 level = SLIC_INTAGG_1;
 816                         else
 817                                 level = SLIC_INTAGG_0;
 818                         if (card->loadlevel_current != level) {
 819                                 card->loadlevel_current = level;
 820                                 slic_write32(adapter, SLIC_REG_INTAGG, level);
 821                         }
 822                 }
 823         }
 824         card->events = 0;
 825         card->loadtimer.expires = jiffies + (SLIC_LOADTIMER_PERIOD * HZ);
 826         add_timer(&card->loadtimer);
 827 }
 828
 829 static int slic_upr_queue_request(struct adapter *adapter,
 830                            u32 upr_request,
 831                            u32 upr_data,
 832                            u32 upr_data_h,
 833                            u32 upr_buffer, u32 upr_buffer_h)
 834 {
 835         struct slic_upr *upr;
 836         struct slic_upr *uprqueue;
 837
 838         upr = kmalloc(sizeof(*upr), GFP_ATOMIC);
 839         if (!upr)
 840                 return -ENOMEM;
 841
 842         upr->adapter = adapter->port;
 843         upr->upr_request = upr_request;
 844         upr->upr_data = upr_data;
 845         upr->upr_buffer = upr_buffer;
 846         upr->upr_data_h = upr_data_h;
 847         upr->upr_buffer_h = upr_buffer_h;
 848         upr->next = NULL;
 849         if (adapter->upr_list) {
 850                 uprqueue = adapter->upr_list;
 851
 852                 while (uprqueue->next)
 853                         uprqueue = uprqueue->next;
 854                 uprqueue->next = upr;
 855         } else {
 856                 adapter->upr_list = upr;
 857         }
 858         return 0;
 859 }
 860
 861 static void slic_upr_start(struct adapter *adapter)
 862 {
 863         struct slic_upr *upr;
 864
 865         upr = adapter->upr_list;
 866         if (!upr)
 867                 return;
 868         if (adapter->upr_busy)
 869                 return;
 870         adapter->upr_busy = 1;
 871
 872         switch (upr->upr_request) {
 873         case SLIC_UPR_STATS:
 874                 if (upr->upr_data_h == 0) {
 875                         slic_write32(adapter, SLIC_REG_RSTAT, upr->upr_data);
 876                 } else {
 877                         slic_write64(adapter, SLIC_REG_RSTAT64, upr->upr_data,
 878                                      upr->upr_data_h);
 879                 }
 880                 break;
 881
 882         case SLIC_UPR_RLSR:
 883                 slic_write64(adapter, SLIC_REG_LSTAT, upr->upr_data,
 884                              upr->upr_data_h);
 885                 break;
 886
 887         case SLIC_UPR_RCONFIG:
 888                 slic_write64(adapter, SLIC_REG_RCONFIG, upr->upr_data,
 889                              upr->upr_data_h);
 890                 break;
 891         case SLIC_UPR_PING:
 892                 slic_write32(adapter, SLIC_REG_PING, 1);
 893                 break;
 894         }
 895         slic_flush_write(adapter);
 896 }
 897
 898 static int slic_upr_request(struct adapter *adapter,
 899                      u32 upr_request,
 900                      u32 upr_data,
 901                      u32 upr_data_h,
 902                      u32 upr_buffer, u32 upr_buffer_h)
 903 {
 904         unsigned long flags;
 905         int rc;
 906
 907         spin_lock_irqsave(&adapter->upr_lock, flags);
 908         rc = slic_upr_queue_request(adapter,
 909                                         upr_request,
 910                                         upr_data,
 911                                         upr_data_h, upr_buffer, upr_buffer_h);
 912         if (rc)
 913                 goto err_unlock_irq;
 914
 915         slic_upr_start(adapter);
 916 err_unlock_irq:
 917         spin_unlock_irqrestore(&adapter->upr_lock, flags);
 918         return rc;
 919 }
 920
 921 static void slic_link_upr_complete(struct adapter *adapter, u32 isr)
 922 {
 923         struct slic_shmemory *sm = &adapter->shmem;
 924         struct slic_shmem_data *sm_data = sm->shmem_data;
 925         u32 lst = sm_data->lnkstatus;
 926         uint linkup;
 927         unsigned char linkspeed;
 928         unsigned char linkduplex;
 929
 930         if ((isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) {
 931                 dma_addr_t phaddr = sm->lnkstatus_phaddr;
 932
 933                 slic_upr_queue_request(adapter, SLIC_UPR_RLSR,
 934                                        cpu_to_le32(lower_32_bits(phaddr)),
 935                                        cpu_to_le32(upper_32_bits(phaddr)),
 936                                        0, 0);
 937                 return;
 938         }
 939         if (adapter->state != ADAPT_UP)
 940                 return;
 941
 942         linkup = lst & GIG_LINKUP ? LINK_UP : LINK_DOWN;
 943         if (lst & GIG_SPEED_1000)
 944                 linkspeed = LINK_1000MB;
 945         else if (lst & GIG_SPEED_100)
 946                 linkspeed = LINK_100MB;
 947         else
 948                 linkspeed = LINK_10MB;
 949
 950         if (lst & GIG_FULLDUPLEX)
 951                 linkduplex = LINK_FULLD;
 952         else
 953                 linkduplex = LINK_HALFD;
 954
 955         if ((adapter->linkstate == LINK_DOWN) && (linkup == LINK_DOWN))
 956                 return;
 957
 958         /* link up event, but nothing has changed */
 959         if ((adapter->linkstate == LINK_UP) &&
 960             (linkup == LINK_UP) &&
 961             (adapter->linkspeed == linkspeed) &&
 962             (adapter->linkduplex == linkduplex))
 963                 return;
 964
 965         /* link has changed at this point */
 966
 967         /* link has gone from up to down */
 968         if (linkup == LINK_DOWN) {
 969                 adapter->linkstate = LINK_DOWN;
 970                 netif_carrier_off(adapter->netdev);
 971                 return;
 972         }
 973
 974         /* link has gone from down to up */
 975         adapter->linkspeed = linkspeed;
 976         adapter->linkduplex = linkduplex;
 977
 978         if (adapter->linkstate != LINK_UP) {
 979                 /* setup the mac */
 980                 slic_config_set(adapter, true);
 981                 adapter->linkstate = LINK_UP;
 982                 netif_carrier_on(adapter->netdev);
 983         }
 984 }
 985
 986 static void slic_upr_request_complete(struct adapter *adapter, u32 isr)
 987 {
 988         struct sliccard *card = adapter->card;
 989         struct slic_upr *upr;
 990         unsigned long flags;
 991
 992         spin_lock_irqsave(&adapter->upr_lock, flags);
 993         upr = adapter->upr_list;
 994         if (!upr) {
 995                 spin_unlock_irqrestore(&adapter->upr_lock, flags);
 996                 return;
 997         }
 998         adapter->upr_list = upr->next;
 999         upr->next = NULL;
1000         adapter->upr_busy = 0;
1001         switch (upr->upr_request) {
1002         case SLIC_UPR_STATS: {
1003                 struct slic_shmemory *sm = &adapter->shmem;
1004                 struct slic_shmem_data *sm_data = sm->shmem_data;
1005                 struct slic_stats *stats = &sm_data->stats;
1006                 struct slic_stats *old = &adapter->inicstats_prev;
1007                 struct slicnet_stats *stst = &adapter->slic_stats;
1008
1009                 if (isr & ISR_UPCERR) {
1010                         dev_err(&adapter->netdev->dev,
1011                                 "SLIC_UPR_STATS command failed isr[%x]\n", isr);
1012                         break;
1013                 }
1014
1015                 UPDATE_STATS_GB(stst->tcp.xmit_tcp_segs, stats->xmit_tcp_segs,
1016                                 old->xmit_tcp_segs);
1017
1018                 UPDATE_STATS_GB(stst->tcp.xmit_tcp_bytes, stats->xmit_tcp_bytes,
1019                                 old->xmit_tcp_bytes);
1020
1021                 UPDATE_STATS_GB(stst->tcp.rcv_tcp_segs, stats->rcv_tcp_segs,
1022                                 old->rcv_tcp_segs);
1023
1024                 UPDATE_STATS_GB(stst->tcp.rcv_tcp_bytes, stats->rcv_tcp_bytes,
1025                                 old->rcv_tcp_bytes);
1026
1027                 UPDATE_STATS_GB(stst->iface.xmt_bytes, stats->xmit_bytes,
1028                                 old->xmit_bytes);
1029
1030                 UPDATE_STATS_GB(stst->iface.xmt_ucast, stats->xmit_unicasts,
1031                                 old->xmit_unicasts);
1032
1033                 UPDATE_STATS_GB(stst->iface.rcv_bytes, stats->rcv_bytes,
1034                                 old->rcv_bytes);
1035
1036                 UPDATE_STATS_GB(stst->iface.rcv_ucast, stats->rcv_unicasts,
1037                                 old->rcv_unicasts);
1038
1039                 UPDATE_STATS_GB(stst->iface.xmt_errors, stats->xmit_collisions,
1040                                 old->xmit_collisions);
1041
1042                 UPDATE_STATS_GB(stst->iface.xmt_errors,
1043                                 stats->xmit_excess_collisions,
1044                                 old->xmit_excess_collisions);
1045
1046                 UPDATE_STATS_GB(stst->iface.xmt_errors, stats->xmit_other_error,
1047                                 old->xmit_other_error);
1048
1049                 UPDATE_STATS_GB(stst->iface.rcv_errors, stats->rcv_other_error,
1050                                 old->rcv_other_error);
1051
1052                 UPDATE_STATS_GB(stst->iface.rcv_discards, stats->rcv_drops,
1053                                 old->rcv_drops);
1054
1055                 if (stats->rcv_drops > old->rcv_drops)
1056                         adapter->rcv_drops += (stats->rcv_drops -
1057                                                old->rcv_drops);
1058                 memcpy_fromio(old, stats, sizeof(*stats));
1059                 break;
1060         }
1061         case SLIC_UPR_RLSR:
1062                 slic_link_upr_complete(adapter, isr);
1063                 break;
1064         case SLIC_UPR_RCONFIG:
1065                 break;
1066         case SLIC_UPR_PING:
1067                 card->pingstatus |= (isr & ISR_PINGDSMASK);
1068                 break;
1069         }
1070         kfree(upr);
1071         slic_upr_start(adapter);
1072         spin_unlock_irqrestore(&adapter->upr_lock, flags);
1073 }
1074
1075 static int slic_config_get(struct adapter *adapter, u32 config, u32 config_h)
1076 {
1077         return slic_upr_request(adapter, SLIC_UPR_RCONFIG, config, config_h,
1078                                 0, 0);
1079 }
1080
1081 /*
1082  * Compute a checksum of the EEPROM according to RFC 1071.
1083  */
1084 static u16 slic_eeprom_cksum(void *eeprom, unsigned int len)
1085 {
1086         u16 *wp = eeprom;
1087         u32 checksum = 0;
1088
1089         while (len > 1) {
1090                 checksum += *(wp++);
1091                 len -= 2;
1092         }
1093
1094         if (len > 0)
1095                 checksum += *(u8 *)wp;
1096
1097         while (checksum >> 16)
1098                 checksum = (checksum & 0xFFFF) + ((checksum >> 16) & 0xFFFF);
1099
1100         return ~checksum;
1101 }
1102
1103 static void slic_rspqueue_free(struct adapter *adapter)
1104 {
1105         int i;
1106         struct slic_rspqueue *rspq = &adapter->rspqueue;
1107
1108         for (i = 0; i < rspq->num_pages; i++) {
1109                 if (rspq->vaddr[i]) {
1110                         pci_free_consistent(adapter->pcidev, PAGE_SIZE,
1111                                             rspq->vaddr[i], rspq->paddr[i]);
1112                 }
1113                 rspq->vaddr[i] = NULL;
1114                 rspq->paddr[i] = 0;
1115         }
1116         rspq->offset = 0;
1117         rspq->pageindex = 0;
1118         rspq->rspbuf = NULL;
1119 }
1120
1121 static int slic_rspqueue_init(struct adapter *adapter)
1122 {
1123         int i;
1124         struct slic_rspqueue *rspq = &adapter->rspqueue;
1125         u32 paddrh = 0;
1126
1127         memset(rspq, 0, sizeof(struct slic_rspqueue));
1128
1129         rspq->num_pages = SLIC_RSPQ_PAGES_GB;
1130
1131         for (i = 0; i < rspq->num_pages; i++) {
1132                 rspq->vaddr[i] = pci_zalloc_consistent(adapter->pcidev,
1133                                                        PAGE_SIZE,
1134                                                        &rspq->paddr[i]);
1135                 if (!rspq->vaddr[i]) {
1136                         dev_err(&adapter->pcidev->dev,
1137                                 "pci_alloc_consistent failed\n");
1138                         slic_rspqueue_free(adapter);
1139                         return -ENOMEM;
1140                 }
1141
1142                 if (paddrh == 0) {
1143                         slic_write32(adapter, SLIC_REG_RBAR,
1144                                      rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE);
1145                 } else {
1146                         slic_write64(adapter, SLIC_REG_RBAR64,
1147                                      rspq->paddr[i] | SLIC_RSPQ_BUFSINPAGE,
1148                                      paddrh);
1149                 }
1150         }
1151         rspq->offset = 0;
1152         rspq->pageindex = 0;
1153         rspq->rspbuf = (struct slic_rspbuf *)rspq->vaddr[0];
1154         return 0;
1155 }
1156
1157 static struct slic_rspbuf *slic_rspqueue_getnext(struct adapter *adapter)
1158 {
1159         struct slic_rspqueue *rspq = &adapter->rspqueue;
1160         struct slic_rspbuf *buf;
1161
1162         if (!(rspq->rspbuf->status))
1163                 return NULL;
1164
1165         buf = rspq->rspbuf;
1166         if (++rspq->offset < SLIC_RSPQ_BUFSINPAGE) {
1167                 rspq->rspbuf++;
1168         } else {
1169                 slic_write64(adapter, SLIC_REG_RBAR64,
1170                              rspq->paddr[rspq->pageindex] |
1171                              SLIC_RSPQ_BUFSINPAGE, 0);
1172                 rspq->pageindex = (rspq->pageindex + 1) % rspq->num_pages;
1173                 rspq->offset = 0;
1174                 rspq->rspbuf = (struct slic_rspbuf *)
1175                                                 rspq->vaddr[rspq->pageindex];
1176         }
1177
1178         return buf;
1179 }
1180
1181 static void slic_cmdqmem_free(struct adapter *adapter)
1182 {
1183         struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
1184         int i;
1185
1186         for (i = 0; i < SLIC_CMDQ_MAXPAGES; i++) {
1187                 if (cmdqmem->pages[i]) {
1188                         pci_free_consistent(adapter->pcidev,
1189                                             PAGE_SIZE,
1190                                             (void *)cmdqmem->pages[i],
1191                                             cmdqmem->dma_pages[i]);
1192                 }
1193         }
1194         memset(cmdqmem, 0, sizeof(struct slic_cmdqmem));
1195 }
1196
1197 static u32 *slic_cmdqmem_addpage(struct adapter *adapter)
1198 {
1199         struct slic_cmdqmem *cmdqmem = &adapter->cmdqmem;
1200         u32 *pageaddr;
1201
1202         if (cmdqmem->pagecnt >= SLIC_CMDQ_MAXPAGES)
1203                 return NULL;
1204         pageaddr = pci_alloc_consistent(adapter->pcidev,
1205                                         PAGE_SIZE,
1206                                         &cmdqmem->dma_pages[cmdqmem->pagecnt]);
1207         if (!pageaddr)
1208                 return NULL;
1209
1210         cmdqmem->pages[cmdqmem->pagecnt] = pageaddr;
1211         cmdqmem->pagecnt++;
1212         return pageaddr;
1213 }
1214
1215 static void slic_cmdq_free(struct adapter *adapter)
1216 {
1217         struct slic_hostcmd *cmd;
1218
1219         cmd = adapter->cmdq_all.head;
1220         while (cmd) {
1221                 if (cmd->busy) {
1222                         struct sk_buff *tempskb;
1223
1224                         tempskb = cmd->skb;
1225                         if (tempskb) {
1226                                 cmd->skb = NULL;
1227                                 dev_kfree_skb_irq(tempskb);
1228                         }
1229                 }
1230                 cmd = cmd->next_all;
1231         }
1232         memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
1233         memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
1234         memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
1235         slic_cmdqmem_free(adapter);
1236 }
1237
1238 static void slic_cmdq_addcmdpage(struct adapter *adapter, u32 *page)
1239 {
1240         struct slic_hostcmd *cmd;
1241         struct slic_hostcmd *prev;
1242         struct slic_hostcmd *tail;
1243         struct slic_cmdqueue *cmdq;
1244         int cmdcnt;
1245         void *cmdaddr;
1246         ulong phys_addr;
1247         u32 phys_addrl;
1248         u32 phys_addrh;
1249         struct slic_handle *pslic_handle;
1250         unsigned long flags;
1251
1252         cmdaddr = page;
1253         cmd = cmdaddr;
1254         cmdcnt = 0;
1255
1256         phys_addr = virt_to_bus((void *)page);
1257         phys_addrl = SLIC_GET_ADDR_LOW(phys_addr);
1258         phys_addrh = SLIC_GET_ADDR_HIGH(phys_addr);
1259
1260         prev = NULL;
1261         tail = cmd;
1262         while ((cmdcnt < SLIC_CMDQ_CMDSINPAGE) &&
1263                (adapter->slic_handle_ix < 256)) {
1264                 /* Allocate and initialize a SLIC_HANDLE for this command */
1265                 spin_lock_irqsave(&adapter->handle_lock, flags);
1266                 pslic_handle  =  adapter->pfree_slic_handles;
1267                 adapter->pfree_slic_handles = pslic_handle->next;
1268                 spin_unlock_irqrestore(&adapter->handle_lock, flags);
1269                 pslic_handle->type = SLIC_HANDLE_CMD;
1270                 pslic_handle->address = (void *)cmd;
1271                 pslic_handle->offset = (ushort)adapter->slic_handle_ix++;
1272                 pslic_handle->other_handle = NULL;
1273                 pslic_handle->next = NULL;
1274
1275                 cmd->pslic_handle = pslic_handle;
1276                 cmd->cmd64.hosthandle = pslic_handle->token.handle_token;
1277                 cmd->busy = false;
1278                 cmd->paddrl = phys_addrl;
1279                 cmd->paddrh = phys_addrh;
1280                 cmd->next_all = prev;
1281                 cmd->next = prev;
1282                 prev = cmd;
1283                 phys_addrl += SLIC_HOSTCMD_SIZE;
1284                 cmdaddr += SLIC_HOSTCMD_SIZE;
1285
1286                 cmd = cmdaddr;
1287                 cmdcnt++;
1288         }
1289
1290         cmdq = &adapter->cmdq_all;
1291         cmdq->count += cmdcnt;  /*  SLIC_CMDQ_CMDSINPAGE;   mooktodo */
1292         tail->next_all = cmdq->head;
1293         cmdq->head = prev;
1294         cmdq = &adapter->cmdq_free;
1295         spin_lock_irqsave(&cmdq->lock, flags);
1296         cmdq->count += cmdcnt;  /*  SLIC_CMDQ_CMDSINPAGE;   mooktodo */
1297         tail->next = cmdq->head;
1298         cmdq->head = prev;
1299         spin_unlock_irqrestore(&cmdq->lock, flags);
1300 }
1301
1302 static int slic_cmdq_init(struct adapter *adapter)
1303 {
1304         int i;
1305         u32 *pageaddr;
1306
1307         memset(&adapter->cmdq_all, 0, sizeof(struct slic_cmdqueue));
1308         memset(&adapter->cmdq_free, 0, sizeof(struct slic_cmdqueue));
1309         memset(&adapter->cmdq_done, 0, sizeof(struct slic_cmdqueue));
1310         spin_lock_init(&adapter->cmdq_all.lock);
1311         spin_lock_init(&adapter->cmdq_free.lock);
1312         spin_lock_init(&adapter->cmdq_done.lock);
1313         memset(&adapter->cmdqmem, 0, sizeof(struct slic_cmdqmem));
1314         adapter->slic_handle_ix = 1;
1315         for (i = 0; i < SLIC_CMDQ_INITPAGES; i++) {
1316                 pageaddr = slic_cmdqmem_addpage(adapter);
1317                 if (!pageaddr) {
1318                         slic_cmdq_free(adapter);
1319                         return -ENOMEM;
1320                 }
1321                 slic_cmdq_addcmdpage(adapter, pageaddr);
1322         }
1323         adapter->slic_handle_ix = 1;
1324
1325         return 0;
1326 }
1327
1328 static void slic_cmdq_reset(struct adapter *adapter)
1329 {
1330         struct slic_hostcmd *hcmd;
1331         struct sk_buff *skb;
1332         u32 outstanding;
1333         unsigned long flags;
1334
1335         spin_lock_irqsave(&adapter->cmdq_free.lock, flags);
1336         spin_lock(&adapter->cmdq_done.lock);
1337         outstanding = adapter->cmdq_all.count - adapter->cmdq_done.count;
1338         outstanding -= adapter->cmdq_free.count;
1339         hcmd = adapter->cmdq_all.head;
1340         while (hcmd) {
1341                 if (hcmd->busy) {
1342                         skb = hcmd->skb;
1343                         hcmd->busy = 0;
1344                         hcmd->skb = NULL;
1345                         dev_kfree_skb_irq(skb);
1346                 }
1347                 hcmd = hcmd->next_all;
1348         }
1349         adapter->cmdq_free.count = 0;
1350         adapter->cmdq_free.head = NULL;
1351         adapter->cmdq_free.tail = NULL;
1352         adapter->cmdq_done.count = 0;
1353         adapter->cmdq_done.head = NULL;
1354         adapter->cmdq_done.tail = NULL;
1355         adapter->cmdq_free.head = adapter->cmdq_all.head;
1356         hcmd = adapter->cmdq_all.head;
1357         while (hcmd) {
1358                 adapter->cmdq_free.count++;
1359                 hcmd->next = hcmd->next_all;
1360                 hcmd = hcmd->next_all;
1361         }
1362         if (adapter->cmdq_free.count != adapter->cmdq_all.count) {
1363                 dev_err(&adapter->netdev->dev,
1364                         "free_count %d != all count %d\n",
1365                         adapter->cmdq_free.count, adapter->cmdq_all.count);
1366         }
1367         spin_unlock(&adapter->cmdq_done.lock);
1368         spin_unlock_irqrestore(&adapter->cmdq_free.lock, flags);
1369 }
1370
1371 static void slic_cmdq_getdone(struct adapter *adapter)
1372 {
1373         struct slic_cmdqueue *done_cmdq = &adapter->cmdq_done;
1374         struct slic_cmdqueue *free_cmdq = &adapter->cmdq_free;
1375         unsigned long flags;
1376
1377         spin_lock_irqsave(&done_cmdq->lock, flags);
1378
1379         free_cmdq->head = done_cmdq->head;
1380         free_cmdq->count = done_cmdq->count;
1381         done_cmdq->head = NULL;
1382         done_cmdq->tail = NULL;
1383         done_cmdq->count = 0;
1384         spin_unlock_irqrestore(&done_cmdq->lock, flags);
1385 }
1386
1387 static struct slic_hostcmd *slic_cmdq_getfree(struct adapter *adapter)
1388 {
1389         struct slic_cmdqueue *cmdq = &adapter->cmdq_free;
1390         struct slic_hostcmd *cmd = NULL;
1391         unsigned long flags;
1392
1393 lock_and_retry:
1394         spin_lock_irqsave(&cmdq->lock, flags);
1395 retry:
1396         cmd = cmdq->head;
1397         if (cmd) {
1398                 cmdq->head = cmd->next;
1399                 cmdq->count--;
1400                 spin_unlock_irqrestore(&cmdq->lock, flags);
1401         } else {
1402                 slic_cmdq_getdone(adapter);
1403                 cmd = cmdq->head;
1404                 if (cmd) {
1405                         goto retry;
1406                 } else {
1407                         u32 *pageaddr;
1408
1409                         spin_unlock_irqrestore(&cmdq->lock, flags);
1410                         pageaddr = slic_cmdqmem_addpage(adapter);
1411                         if (pageaddr) {
1412                                 slic_cmdq_addcmdpage(adapter, pageaddr);
1413                                 goto lock_and_retry;
1414                         }
1415                 }
1416         }
1417         return cmd;
1418 }
1419
1420 static void slic_cmdq_putdone_irq(struct adapter *adapter,
1421                                 struct slic_hostcmd *cmd)
1422 {
1423         struct slic_cmdqueue *cmdq = &adapter->cmdq_done;
1424
1425         spin_lock(&cmdq->lock);
1426         cmd->busy = 0;
1427         cmd->next = cmdq->head;
1428         cmdq->head = cmd;
1429         cmdq->count++;
1430         if ((adapter->xmitq_full) && (cmdq->count > 10))
1431                 netif_wake_queue(adapter->netdev);
1432         spin_unlock(&cmdq->lock);
1433 }
1434
1435 static int slic_rcvqueue_fill(struct adapter *adapter)
1436 {
1437         void *paddr;
1438         u32 paddrl;
1439         u32 paddrh;
1440         struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
1441         int i = 0;
1442         struct device *dev = &adapter->netdev->dev;
1443
1444         while (i < SLIC_RCVQ_FILLENTRIES) {
1445                 struct slic_rcvbuf *rcvbuf;
1446                 struct sk_buff *skb;
1447 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1448 retry_rcvqfill:
1449 #endif
1450                 skb = alloc_skb(SLIC_RCVQ_RCVBUFSIZE, GFP_ATOMIC);
1451                 if (skb) {
1452                         paddr = (void *)(unsigned long)
1453                                 pci_map_single(adapter->pcidev,
1454                                                skb->data,
1455                                                SLIC_RCVQ_RCVBUFSIZE,
1456                                                PCI_DMA_FROMDEVICE);
1457                         paddrl = SLIC_GET_ADDR_LOW(paddr);
1458                         paddrh = SLIC_GET_ADDR_HIGH(paddr);
1459
1460                         skb->len = SLIC_RCVBUF_HEADSIZE;
1461                         rcvbuf = (struct slic_rcvbuf *)skb->head;
1462                         rcvbuf->status = 0;
1463                         skb->next = NULL;
1464 #ifdef KLUDGE_FOR_4GB_BOUNDARY
1465                         if (paddrl == 0) {
1466                                 dev_err(dev, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1467                                         __func__);
1468                                 dev_err(dev, "skb[%p] PROBLEM\n", skb);
1469                                 dev_err(dev, "         skbdata[%p]\n",
1470                                                 skb->data);
1471                                 dev_err(dev, "         skblen[%x]\n", skb->len);
1472                                 dev_err(dev, "         paddr[%p]\n", paddr);
1473                                 dev_err(dev, "         paddrl[%x]\n", paddrl);
1474                                 dev_err(dev, "         paddrh[%x]\n", paddrh);
1475                                 dev_err(dev, "         rcvq->head[%p]\n",
1476                                                 rcvq->head);
1477                                 dev_err(dev, "         rcvq->tail[%p]\n",
1478                                                 rcvq->tail);
1479                                 dev_err(dev, "         rcvq->count[%x]\n",
1480                                                 rcvq->count);
1481                                 dev_err(dev, "SKIP THIS SKB!!!!!!!!\n");
1482                                 goto retry_rcvqfill;
1483                         }
1484 #else
1485                         if (paddrl == 0) {
1486                                 dev_err(dev, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1487                                         __func__);
1488                                 dev_err(dev, "skb[%p] PROBLEM\n", skb);
1489                                 dev_err(dev, "         skbdata[%p]\n",
1490                                                 skb->data);
1491                                 dev_err(dev, "         skblen[%x]\n", skb->len);
1492                                 dev_err(dev, "         paddr[%p]\n", paddr);
1493                                 dev_err(dev, "         paddrl[%x]\n", paddrl);
1494                                 dev_err(dev, "         paddrh[%x]\n", paddrh);
1495                                 dev_err(dev, "         rcvq->head[%p]\n",
1496                                                 rcvq->head);
1497                                 dev_err(dev, "         rcvq->tail[%p]\n",
1498                                                 rcvq->tail);
1499                                 dev_err(dev, "         rcvq->count[%x]\n",
1500                                                 rcvq->count);
1501                                 dev_err(dev, "GIVE TO CARD ANYWAY\n");
1502                         }
1503 #endif
1504                         if (paddrh == 0) {
1505                                 slic_write32(adapter, SLIC_REG_HBAR,
1506                                              (u32)paddrl);
1507                         } else {
1508                                 slic_write64(adapter, SLIC_REG_HBAR64, paddrl,
1509                                              paddrh);
1510                         }
1511                         if (rcvq->head)
1512                                 rcvq->tail->next = skb;
1513                         else
1514                                 rcvq->head = skb;
1515                         rcvq->tail = skb;
1516                         rcvq->count++;
1517                         i++;
1518                 } else {
1519                         dev_err(&adapter->netdev->dev,
1520                                 "slic_rcvqueue_fill could only get [%d] skbuffs\n",
1521                                 i);
1522                         break;
1523                 }
1524         }
1525         return i;
1526 }
1527
1528 static void slic_rcvqueue_free(struct adapter *adapter)
1529 {
1530         struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
1531         struct sk_buff *skb;
1532
1533         while (rcvq->head) {
1534                 skb = rcvq->head;
1535                 rcvq->head = rcvq->head->next;
1536                 dev_kfree_skb(skb);
1537         }
1538         rcvq->tail = NULL;
1539         rcvq->head = NULL;
1540         rcvq->count = 0;
1541 }
1542
1543 static int slic_rcvqueue_init(struct adapter *adapter)
1544 {
1545         int i, count;
1546         struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
1547
1548         rcvq->tail = NULL;
1549         rcvq->head = NULL;
1550         rcvq->size = SLIC_RCVQ_ENTRIES;
1551         rcvq->errors = 0;
1552         rcvq->count = 0;
1553         i = SLIC_RCVQ_ENTRIES / SLIC_RCVQ_FILLENTRIES;
1554         count = 0;
1555         while (i) {
1556                 count += slic_rcvqueue_fill(adapter);
1557                 i--;
1558         }
1559         if (rcvq->count < SLIC_RCVQ_MINENTRIES) {
1560                 slic_rcvqueue_free(adapter);
1561                 return -ENOMEM;
1562         }
1563         return 0;
1564 }
1565
1566 static struct sk_buff *slic_rcvqueue_getnext(struct adapter *adapter)
1567 {
1568         struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
1569         struct sk_buff *skb;
1570         struct slic_rcvbuf *rcvbuf;
1571         int count;
1572
1573         if (rcvq->count) {
1574                 skb = rcvq->head;
1575                 rcvbuf = (struct slic_rcvbuf *)skb->head;
1576
1577                 if (rcvbuf->status & IRHDDR_SVALID) {
1578                         rcvq->head = rcvq->head->next;
1579                         skb->next = NULL;
1580                         rcvq->count--;
1581                 } else {
1582                         skb = NULL;
1583                 }
1584         } else {
1585                 dev_err(&adapter->netdev->dev,
1586                         "RcvQ Empty!! rcvq[%p] count[%x]\n", rcvq, rcvq->count);
1587                 skb = NULL;
1588         }
1589         while (rcvq->count < SLIC_RCVQ_FILLTHRESH) {
1590                 count = slic_rcvqueue_fill(adapter);
1591                 if (!count)
1592                         break;
1593         }
1594         if (skb)
1595                 rcvq->errors = 0;
1596         return skb;
1597 }
1598
1599 static u32 slic_rcvqueue_reinsert(struct adapter *adapter, struct sk_buff *skb)
1600 {
1601         struct slic_rcvqueue *rcvq = &adapter->rcvqueue;
1602         void *paddr;
1603         u32 paddrl;
1604         u32 paddrh;
1605         struct slic_rcvbuf *rcvbuf = (struct slic_rcvbuf *)skb->head;
1606         struct device *dev;
1607
1608         paddr = (void *)(unsigned long)
1609                 pci_map_single(adapter->pcidev, skb->head,
1610                                SLIC_RCVQ_RCVBUFSIZE, PCI_DMA_FROMDEVICE);
1611         rcvbuf->status = 0;
1612         skb->next = NULL;
1613
1614         paddrl = SLIC_GET_ADDR_LOW(paddr);
1615         paddrh = SLIC_GET_ADDR_HIGH(paddr);
1616
1617         if (paddrl == 0) {
1618                 dev = &adapter->netdev->dev;
1619                 dev_err(dev, "%s: LOW 32bits PHYSICAL ADDRESS == 0\n",
1620                         __func__);
1621                 dev_err(dev, "skb[%p] PROBLEM\n", skb);
1622                 dev_err(dev, "         skbdata[%p]\n", skb->data);
1623                 dev_err(dev, "         skblen[%x]\n", skb->len);
1624                 dev_err(dev, "         paddr[%p]\n", paddr);
1625                 dev_err(dev, "         paddrl[%x]\n", paddrl);
1626                 dev_err(dev, "         paddrh[%x]\n", paddrh);
1627                 dev_err(dev, "         rcvq->head[%p]\n", rcvq->head);
1628                 dev_err(dev, "         rcvq->tail[%p]\n", rcvq->tail);
1629                 dev_err(dev, "         rcvq->count[%x]\n", rcvq->count);
1630         }
1631         if (paddrh == 0)
1632                 slic_write32(adapter, SLIC_REG_HBAR, (u32)paddrl);
1633         else
1634                 slic_write64(adapter, SLIC_REG_HBAR64, paddrl, paddrh);
1635         if (rcvq->head)
1636                 rcvq->tail->next = skb;
1637         else
1638                 rcvq->head = skb;
1639         rcvq->tail = skb;
1640         rcvq->count++;
1641         return rcvq->count;
1642 }
1643
1644 /*
1645  * slic_link_event_handler -
1646  *
1647  * Initiate a link configuration sequence.  The link configuration begins
1648  * by issuing a READ_LINK_STATUS command to the Utility Processor on the
1649  * SLIC.  Since the command finishes asynchronously, the slic_upr_comlete
1650  * routine will follow it up witha UP configuration write command, which
1651  * will also complete asynchronously.
1652  *
1653  */
1654 static int slic_link_event_handler(struct adapter *adapter)
1655 {
1656         int status;
1657         struct slic_shmemory *sm = &adapter->shmem;
1658         dma_addr_t phaddr = sm->lnkstatus_phaddr;
1659
1660         if (adapter->state != ADAPT_UP) {
1661                 /* Adapter is not operational.  Ignore.  */
1662                 return -ENODEV;
1663         }
1664         /* no 4GB wrap guaranteed */
1665         status = slic_upr_request(adapter, SLIC_UPR_RLSR,
1666                                   cpu_to_le32(lower_32_bits(phaddr)),
1667                                   cpu_to_le32(upper_32_bits(phaddr)), 0, 0);
1668         return status;
1669 }
1670
1671 static void slic_init_cleanup(struct adapter *adapter)
1672 {
1673         if (adapter->intrregistered) {
1674                 adapter->intrregistered = 0;
1675                 free_irq(adapter->netdev->irq, adapter->netdev);
1676         }
1677
1678         if (adapter->shmem.shmem_data) {
1679                 struct slic_shmemory *sm = &adapter->shmem;
1680                 struct slic_shmem_data *sm_data = sm->shmem_data;
1681
1682                 pci_free_consistent(adapter->pcidev, sizeof(*sm_data), sm_data,
1683                                     sm->isr_phaddr);
1684         }
1685
1686         if (adapter->pingtimerset) {
1687                 adapter->pingtimerset = 0;
1688                 del_timer(&adapter->pingtimer);
1689         }
1690
1691         slic_rspqueue_free(adapter);
1692         slic_cmdq_free(adapter);
1693         slic_rcvqueue_free(adapter);
1694 }
1695
1696 /*
1697  *  Allocate a mcast_address structure to hold the multicast address.
1698  *  Link it in.
1699  */
1700 static int slic_mcast_add_list(struct adapter *adapter, char *address)
1701 {
1702         struct mcast_address *mcaddr, *mlist;
1703
1704         /* Check to see if it already exists */
1705         mlist = adapter->mcastaddrs;
1706         while (mlist) {
1707                 if (ether_addr_equal(mlist->address, address))
1708                         return 0;
1709                 mlist = mlist->next;
1710         }
1711
1712         /* Doesn't already exist.  Allocate a structure to hold it */
1713         mcaddr = kmalloc(sizeof(*mcaddr), GFP_ATOMIC);
1714         if (!mcaddr)
1715                 return 1;
1716
1717         ether_addr_copy(mcaddr->address, address);
1718
1719         mcaddr->next = adapter->mcastaddrs;
1720         adapter->mcastaddrs = mcaddr;
1721
1722         return 0;
1723 }
1724
1725 static void slic_mcast_set_list(struct net_device *dev)
1726 {
1727         struct adapter *adapter = netdev_priv(dev);
1728         int status = 0;
1729         char *addresses;
1730         struct netdev_hw_addr *ha;
1731
1732         netdev_for_each_mc_addr(ha, dev) {
1733                 addresses = (char *)&ha->addr;
1734                 status = slic_mcast_add_list(adapter, addresses);
1735                 if (status != 0)
1736                         break;
1737                 slic_mcast_set_bit(adapter, addresses);
1738         }
1739
1740         if (adapter->devflags_prev != dev->flags) {
1741                 adapter->macopts = MAC_DIRECTED;
1742                 if (dev->flags) {
1743                         if (dev->flags & IFF_BROADCAST)
1744                                 adapter->macopts |= MAC_BCAST;
1745                         if (dev->flags & IFF_PROMISC)
1746                                 adapter->macopts |= MAC_PROMISC;
1747                         if (dev->flags & IFF_ALLMULTI)
1748                                 adapter->macopts |= MAC_ALLMCAST;
1749                         if (dev->flags & IFF_MULTICAST)
1750                                 adapter->macopts |= MAC_MCAST;
1751                 }
1752                 adapter->devflags_prev = dev->flags;
1753                 slic_config_set(adapter, true);
1754         } else {
1755                 if (status == 0)
1756                         slic_mcast_set_mask(adapter);
1757         }
1758 }
1759
1760 #define  XMIT_FAIL_LINK_STATE               1
1761 #define  XMIT_FAIL_ZERO_LENGTH              2
1762 #define  XMIT_FAIL_HOSTCMD_FAIL             3
1763
1764 static void slic_xmit_build_request(struct adapter *adapter,
1765                              struct slic_hostcmd *hcmd, struct sk_buff *skb)
1766 {
1767         struct slic_host64_cmd *ihcmd;
1768         ulong phys_addr;
1769
1770         ihcmd = &hcmd->cmd64;
1771
1772         ihcmd->flags = adapter->port << IHFLG_IFSHFT;
1773         ihcmd->command = IHCMD_XMT_REQ;
1774         ihcmd->u.slic_buffers.totlen = skb->len;
1775         phys_addr = pci_map_single(adapter->pcidev, skb->data, skb->len,
1776                         PCI_DMA_TODEVICE);
1777         if (pci_dma_mapping_error(adapter->pcidev, phys_addr)) {
1778                 kfree_skb(skb);
1779                 dev_err(&adapter->pcidev->dev, "DMA mapping error\n");
1780                 return;
1781         }
1782         ihcmd->u.slic_buffers.bufs[0].paddrl = SLIC_GET_ADDR_LOW(phys_addr);
1783         ihcmd->u.slic_buffers.bufs[0].paddrh = SLIC_GET_ADDR_HIGH(phys_addr);
1784         ihcmd->u.slic_buffers.bufs[0].length = skb->len;
1785 #if BITS_PER_LONG == 64
1786         hcmd->cmdsize = (u32)((((u64)&ihcmd->u.slic_buffers.bufs[1] -
1787                                      (u64)hcmd) + 31) >> 5);
1788 #else
1789         hcmd->cmdsize = (((u32)&ihcmd->u.slic_buffers.bufs[1] -
1790                                        (u32)hcmd) + 31) >> 5;
1791 #endif
1792 }
1793
1794 static void slic_xmit_fail(struct adapter *adapter,
1795                     struct sk_buff *skb,
1796                     void *cmd, u32 skbtype, u32 status)
1797 {
1798         if (adapter->xmitq_full)
1799                 netif_stop_queue(adapter->netdev);
1800         if ((!cmd) && (status <= XMIT_FAIL_HOSTCMD_FAIL)) {
1801                 switch (status) {
1802                 case XMIT_FAIL_LINK_STATE:
1803                         dev_err(&adapter->netdev->dev,
1804                                 "reject xmit skb[%p: %x] linkstate[%s] adapter[%s:%d] card[%s:%d]\n",
1805                                 skb, skb->pkt_type,
1806                                 SLIC_LINKSTATE(adapter->linkstate),
1807                                 SLIC_ADAPTER_STATE(adapter->state),
1808                                 adapter->state,
1809                                 SLIC_CARD_STATE(adapter->card->state),
1810                                 adapter->card->state);
1811                         break;
1812                 case XMIT_FAIL_ZERO_LENGTH:
1813                         dev_err(&adapter->netdev->dev,
1814                                 "xmit_start skb->len == 0 skb[%p] type[%x]\n",
1815                                 skb, skb->pkt_type);
1816                         break;
1817                 case XMIT_FAIL_HOSTCMD_FAIL:
1818                         dev_err(&adapter->netdev->dev,
1819                                 "xmit_start skb[%p] type[%x] No host commands available\n",
1820                                 skb, skb->pkt_type);
1821                         break;
1822                 }
1823         }
1824         dev_kfree_skb(skb);
1825         adapter->netdev->stats.tx_dropped++;
1826 }
1827
1828 static void slic_rcv_handle_error(struct adapter *adapter,
1829                                         struct slic_rcvbuf *rcvbuf)
1830 {
1831         struct slic_hddr_wds *hdr = (struct slic_hddr_wds *)rcvbuf->data;
1832         struct net_device *netdev = adapter->netdev;
1833
1834         if (adapter->devid != SLIC_1GB_DEVICE_ID) {
1835                 if (hdr->frame_status14 & VRHSTAT_802OE)
1836                         adapter->if_events.oflow802++;
1837                 if (hdr->frame_status14 & VRHSTAT_TPOFLO)
1838                         adapter->if_events.Tprtoflow++;
1839                 if (hdr->frame_status_b14 & VRHSTATB_802UE)
1840                         adapter->if_events.uflow802++;
1841                 if (hdr->frame_status_b14 & VRHSTATB_RCVE) {
1842                         adapter->if_events.rcvearly++;
1843                         netdev->stats.rx_fifo_errors++;
1844                 }
1845                 if (hdr->frame_status_b14 & VRHSTATB_BUFF) {
1846                         adapter->if_events.Bufov++;
1847                         netdev->stats.rx_over_errors++;
1848                 }
1849                 if (hdr->frame_status_b14 & VRHSTATB_CARRE) {
1850                         adapter->if_events.Carre++;
1851                         netdev->stats.tx_carrier_errors++;
1852                 }
1853                 if (hdr->frame_status_b14 & VRHSTATB_LONGE)
1854                         adapter->if_events.Longe++;
1855                 if (hdr->frame_status_b14 & VRHSTATB_PREA)
1856                         adapter->if_events.Invp++;
1857                 if (hdr->frame_status_b14 & VRHSTATB_CRC) {
1858                         adapter->if_events.Crc++;
1859                         netdev->stats.rx_crc_errors++;
1860                 }
1861                 if (hdr->frame_status_b14 & VRHSTATB_DRBL)
1862                         adapter->if_events.Drbl++;
1863                 if (hdr->frame_status_b14 & VRHSTATB_CODE)
1864                         adapter->if_events.Code++;
1865                 if (hdr->frame_status_b14 & VRHSTATB_TPCSUM)
1866                         adapter->if_events.TpCsum++;
1867                 if (hdr->frame_status_b14 & VRHSTATB_TPHLEN)
1868                         adapter->if_events.TpHlen++;
1869                 if (hdr->frame_status_b14 & VRHSTATB_IPCSUM)
1870                         adapter->if_events.IpCsum++;
1871                 if (hdr->frame_status_b14 & VRHSTATB_IPLERR)
1872                         adapter->if_events.IpLen++;
1873                 if (hdr->frame_status_b14 & VRHSTATB_IPHERR)
1874                         adapter->if_events.IpHlen++;
1875         } else {
1876                 if (hdr->frame_statusGB & VGBSTAT_XPERR) {
1877                         u32 xerr = hdr->frame_statusGB >> VGBSTAT_XERRSHFT;
1878
1879                         if (xerr == VGBSTAT_XCSERR)
1880                                 adapter->if_events.TpCsum++;
1881                         if (xerr == VGBSTAT_XUFLOW)
1882                                 adapter->if_events.Tprtoflow++;
1883                         if (xerr == VGBSTAT_XHLEN)
1884                                 adapter->if_events.TpHlen++;
1885                 }
1886                 if (hdr->frame_statusGB & VGBSTAT_NETERR) {
1887                         u32 nerr =
1888                             (hdr->
1889                              frame_statusGB >> VGBSTAT_NERRSHFT) &
1890                             VGBSTAT_NERRMSK;
1891                         if (nerr == VGBSTAT_NCSERR)
1892                                 adapter->if_events.IpCsum++;
1893                         if (nerr == VGBSTAT_NUFLOW)
1894                                 adapter->if_events.IpLen++;
1895                         if (nerr == VGBSTAT_NHLEN)
1896                                 adapter->if_events.IpHlen++;
1897                 }
1898                 if (hdr->frame_statusGB & VGBSTAT_LNKERR) {
1899                         u32 lerr = hdr->frame_statusGB & VGBSTAT_LERRMSK;
1900
1901                         if (lerr == VGBSTAT_LDEARLY)
1902                                 adapter->if_events.rcvearly++;
1903                         if (lerr == VGBSTAT_LBOFLO)
1904                                 adapter->if_events.Bufov++;
1905                         if (lerr == VGBSTAT_LCODERR)
1906                                 adapter->if_events.Code++;
1907                         if (lerr == VGBSTAT_LDBLNBL)
1908                                 adapter->if_events.Drbl++;
1909                         if (lerr == VGBSTAT_LCRCERR)
1910                                 adapter->if_events.Crc++;
1911                         if (lerr == VGBSTAT_LOFLO)
1912                                 adapter->if_events.oflow802++;
1913                         if (lerr == VGBSTAT_LUFLO)
1914                                 adapter->if_events.uflow802++;
1915                 }
1916         }
1917 }
1918
1919 #define TCP_OFFLOAD_FRAME_PUSHFLAG  0x10000000
1920 #define M_FAST_PATH                 0x0040
1921
1922 static void slic_rcv_handler(struct adapter *adapter)
1923 {
1924         struct net_device *netdev = adapter->netdev;
1925         struct sk_buff *skb;
1926         struct slic_rcvbuf *rcvbuf;
1927         u32 frames = 0;
1928
1929         while ((skb = slic_rcvqueue_getnext(adapter))) {
1930                 u32 rx_bytes;
1931
1932                 rcvbuf = (struct slic_rcvbuf *)skb->head;
1933                 adapter->card->events++;
1934                 if (rcvbuf->status & IRHDDR_ERR) {
1935                         adapter->rx_errors++;
1936                         slic_rcv_handle_error(adapter, rcvbuf);
1937                         slic_rcvqueue_reinsert(adapter, skb);
1938                         continue;
1939                 }
1940
1941                 if (!slic_mac_filter(adapter, (struct ether_header *)
1942                                         rcvbuf->data)) {
1943                         slic_rcvqueue_reinsert(adapter, skb);
1944                         continue;
1945                 }
1946                 skb_pull(skb, SLIC_RCVBUF_HEADSIZE);
1947                 rx_bytes = (rcvbuf->length & IRHDDR_FLEN_MSK);
1948                 skb_put(skb, rx_bytes);
1949                 netdev->stats.rx_packets++;
1950                 netdev->stats.rx_bytes += rx_bytes;
1951 #if SLIC_OFFLOAD_IP_CHECKSUM
1952                 skb->ip_summed = CHECKSUM_UNNECESSARY;
1953 #endif
1954
1955                 skb->dev = adapter->netdev;
1956                 skb->protocol = eth_type_trans(skb, skb->dev);
1957                 netif_rx(skb);
1958
1959                 ++frames;
1960 #if SLIC_INTERRUPT_PROCESS_LIMIT
1961                 if (frames >= SLIC_RCVQ_MAX_PROCESS_ISR) {
1962                         adapter->rcv_interrupt_yields++;
1963                         break;
1964                 }
1965 #endif
1966         }
1967         adapter->max_isr_rcvs = max(adapter->max_isr_rcvs, frames);
1968 }
1969
1970 static void slic_xmit_complete(struct adapter *adapter)
1971 {
1972         struct slic_hostcmd *hcmd;
1973         struct slic_rspbuf *rspbuf;
1974         u32 frames = 0;
1975         struct slic_handle_word slic_handle_word;
1976
1977         do {
1978                 rspbuf = slic_rspqueue_getnext(adapter);
1979                 if (!rspbuf)
1980                         break;
1981                 adapter->xmit_completes++;
1982                 adapter->card->events++;
1983                 /*
1984                  * Get the complete host command buffer
1985                  */
1986                 slic_handle_word.handle_token = rspbuf->hosthandle;
1987                 hcmd =
1988                         adapter->slic_handles[slic_handle_word.handle_index].
1989                                                                         address;
1990 /*      hcmd = (struct slic_hostcmd *) rspbuf->hosthandle; */
1991                 if (hcmd->type == SLIC_CMD_DUMB) {
1992                         if (hcmd->skb)
1993                                 dev_kfree_skb_irq(hcmd->skb);
1994                         slic_cmdq_putdone_irq(adapter, hcmd);
1995                 }
1996                 rspbuf->status = 0;
1997                 rspbuf->hosthandle = 0;
1998                 frames++;
1999         } while (1);
2000         adapter->max_isr_xmits = max(adapter->max_isr_xmits, frames);
2001 }
2002
2003 static void slic_interrupt_card_up(u32 isr, struct adapter *adapter,
2004                         struct net_device *dev)
2005 {
2006         if (isr & ~ISR_IO) {
2007                 if (isr & ISR_ERR) {
2008                         adapter->error_interrupts++;
2009                         if (isr & ISR_RMISS) {
2010                                 int count;
2011                                 int pre_count;
2012                                 int errors;
2013
2014                                 struct slic_rcvqueue *rcvq =
2015                                         &adapter->rcvqueue;
2016
2017                                 adapter->error_rmiss_interrupts++;
2018
2019                                 if (!rcvq->errors)
2020                                         rcv_count = rcvq->count;
2021                                 pre_count = rcvq->count;
2022                                 errors = rcvq->errors;
2023
2024                                 while (rcvq->count < SLIC_RCVQ_FILLTHRESH) {
2025                                         count = slic_rcvqueue_fill(adapter);
2026                                         if (!count)
2027                                                 break;
2028                                 }
2029                         } else if (isr & ISR_XDROP) {
2030                                 dev_err(&dev->dev,
2031                                                 "isr & ISR_ERR [%x] ISR_XDROP\n",
2032                                                 isr);
2033                         } else {
2034                                 dev_err(&dev->dev,
2035                                                 "isr & ISR_ERR [%x]\n",
2036                                                 isr);
2037                         }
2038                 }
2039
2040                 if (isr & ISR_LEVENT) {
2041                         adapter->linkevent_interrupts++;
2042                         if (slic_link_event_handler(adapter))
2043                                 adapter->linkevent_interrupts--;
2044                 }
2045
2046                 if ((isr & ISR_UPC) || (isr & ISR_UPCERR) ||
2047                     (isr & ISR_UPCBSY)) {
2048                         adapter->upr_interrupts++;
2049                         slic_upr_request_complete(adapter, isr);
2050                 }
2051         }
2052
2053         if (isr & ISR_RCV) {
2054                 adapter->rcv_interrupts++;
2055                 slic_rcv_handler(adapter);
2056         }
2057
2058         if (isr & ISR_CMD) {
2059                 adapter->xmit_interrupts++;
2060                 slic_xmit_complete(adapter);
2061         }
2062 }
2063
2064 static irqreturn_t slic_interrupt(int irq, void *dev_id)
2065 {
2066         struct net_device *dev = dev_id;
2067         struct adapter *adapter = netdev_priv(dev);
2068         struct slic_shmemory *sm = &adapter->shmem;
2069         struct slic_shmem_data *sm_data = sm->shmem_data;
2070         u32 isr;
2071
2072         if (sm_data->isr) {
2073                 slic_write32(adapter, SLIC_REG_ICR, ICR_INT_MASK);
2074                 slic_flush_write(adapter);
2075
2076                 isr = sm_data->isr;
2077                 sm_data->isr = 0;
2078                 adapter->num_isrs++;
2079                 switch (adapter->card->state) {
2080                 case CARD_UP:
2081                         slic_interrupt_card_up(isr, adapter, dev);
2082                         break;
2083
2084                 case CARD_DOWN:
2085                         if ((isr & ISR_UPC) ||
2086                             (isr & ISR_UPCERR) || (isr & ISR_UPCBSY)) {
2087                                 adapter->upr_interrupts++;
2088                                 slic_upr_request_complete(adapter, isr);
2089                         }
2090                         break;
2091                 }
2092
2093                 adapter->all_reg_writes += 2;
2094                 adapter->isr_reg_writes++;
2095                 slic_write32(adapter, SLIC_REG_ISR, 0);
2096         } else {
2097                 adapter->false_interrupts++;
2098         }
2099         return IRQ_HANDLED;
2100 }
2101
2102 #define NORMAL_ETHFRAME     0
2103
2104 static netdev_tx_t slic_xmit_start(struct sk_buff *skb, struct net_device *dev)
2105 {
2106         struct sliccard *card;
2107         struct adapter *adapter = netdev_priv(dev);
2108         struct slic_hostcmd *hcmd = NULL;
2109         u32 status = 0;
2110         void *offloadcmd = NULL;
2111
2112         card = adapter->card;
2113         if ((adapter->linkstate != LINK_UP) ||
2114             (adapter->state != ADAPT_UP) || (card->state != CARD_UP)) {
2115                 status = XMIT_FAIL_LINK_STATE;
2116                 goto xmit_fail;
2117
2118         } else if (skb->len == 0) {
2119                 status = XMIT_FAIL_ZERO_LENGTH;
2120                 goto xmit_fail;
2121         }
2122
2123         hcmd = slic_cmdq_getfree(adapter);
2124         if (!hcmd) {
2125                 adapter->xmitq_full = 1;
2126                 status = XMIT_FAIL_HOSTCMD_FAIL;
2127                 goto xmit_fail;
2128         }
2129         hcmd->skb = skb;
2130         hcmd->busy = 1;
2131         hcmd->type = SLIC_CMD_DUMB;
2132         slic_xmit_build_request(adapter, hcmd, skb);
2133         dev->stats.tx_packets++;
2134         dev->stats.tx_bytes += skb->len;
2135
2136 #ifdef DEBUG_DUMP
2137         if (adapter->kill_card) {
2138                 struct slic_host64_cmd ihcmd;
2139
2140                 ihcmd = &hcmd->cmd64;
2141
2142                 ihcmd->flags |= 0x40;
2143                 adapter->kill_card = 0; /* only do this once */
2144         }
2145 #endif
2146         if (hcmd->paddrh == 0) {
2147                 slic_write32(adapter, SLIC_REG_CBAR, (hcmd->paddrl |
2148                                                       hcmd->cmdsize));
2149         } else {
2150                 slic_write64(adapter, SLIC_REG_CBAR64,
2151                              hcmd->paddrl | hcmd->cmdsize, hcmd->paddrh);
2152         }
2153 xmit_done:
2154         return NETDEV_TX_OK;
2155 xmit_fail:
2156         slic_xmit_fail(adapter, skb, offloadcmd, NORMAL_ETHFRAME, status);
2157         goto xmit_done;
2158 }
2159
2160 static void slic_adapter_freeresources(struct adapter *adapter)
2161 {
2162         slic_init_cleanup(adapter);
2163         adapter->error_interrupts = 0;
2164         adapter->rcv_interrupts = 0;
2165         adapter->xmit_interrupts = 0;
2166         adapter->linkevent_interrupts = 0;
2167         adapter->upr_interrupts = 0;
2168         adapter->num_isrs = 0;
2169         adapter->xmit_completes = 0;
2170         adapter->rcv_broadcasts = 0;
2171         adapter->rcv_multicasts = 0;
2172         adapter->rcv_unicasts = 0;
2173 }
2174
2175 static int slic_adapter_allocresources(struct adapter *adapter,
2176                                        unsigned long *flags)
2177 {
2178         if (!adapter->intrregistered) {
2179                 int retval;
2180
2181                 spin_unlock_irqrestore(&slic_global.driver_lock, *flags);
2182
2183                 retval = request_irq(adapter->netdev->irq,
2184                                      &slic_interrupt,
2185                                      IRQF_SHARED,
2186                                      adapter->netdev->name, adapter->netdev);
2187
2188                 spin_lock_irqsave(&slic_global.driver_lock, *flags);
2189
2190                 if (retval) {
2191                         dev_err(&adapter->netdev->dev,
2192                                 "request_irq (%s) FAILED [%x]\n",
2193                                 adapter->netdev->name, retval);
2194                         return retval;
2195                 }
2196                 adapter->intrregistered = 1;
2197         }
2198         return 0;
2199 }
2200
2201 /*
2202  *  slic_if_init
2203  *
2204  *  Perform initialization of our slic interface.
2205  *
2206  */
2207 static int slic_if_init(struct adapter *adapter, unsigned long *flags)
2208 {
2209         struct sliccard *card = adapter->card;
2210         struct net_device *dev = adapter->netdev;
2211         struct slic_shmemory *sm = &adapter->shmem;
2212         struct slic_shmem_data *sm_data = sm->shmem_data;
2213         int rc;
2214
2215         /* adapter should be down at this point */
2216         if (adapter->state != ADAPT_DOWN) {
2217                 dev_err(&dev->dev, "%s: adapter->state != ADAPT_DOWN\n",
2218                         __func__);
2219                 rc = -EIO;
2220                 goto err;
2221         }
2222
2223         adapter->devflags_prev = dev->flags;
2224         adapter->macopts = MAC_DIRECTED;
2225         if (dev->flags) {
2226                 if (dev->flags & IFF_BROADCAST)
2227                         adapter->macopts |= MAC_BCAST;
2228                 if (dev->flags & IFF_PROMISC)
2229                         adapter->macopts |= MAC_PROMISC;
2230                 if (dev->flags & IFF_ALLMULTI)
2231                         adapter->macopts |= MAC_ALLMCAST;
2232                 if (dev->flags & IFF_MULTICAST)
2233                         adapter->macopts |= MAC_MCAST;
2234         }
2235         rc = slic_adapter_allocresources(adapter, flags);
2236         if (rc) {
2237                 dev_err(&dev->dev, "slic_adapter_allocresources FAILED %x\n",
2238                         rc);
2239                 slic_adapter_freeresources(adapter);
2240                 goto err;
2241         }
2242
2243         if (!adapter->queues_initialized) {
2244                 rc = slic_rspqueue_init(adapter);
2245                 if (rc)
2246                         goto err;
2247                 rc = slic_cmdq_init(adapter);
2248                 if (rc)
2249                         goto err;
2250                 rc = slic_rcvqueue_init(adapter);
2251                 if (rc)
2252                         goto err;
2253                 adapter->queues_initialized = 1;
2254         }
2255
2256         slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF);
2257         slic_flush_write(adapter);
2258         mdelay(1);
2259
2260         if (!adapter->isp_initialized) {
2261                 unsigned long flags;
2262
2263                 spin_lock_irqsave(&adapter->bit64reglock, flags);
2264                 slic_write32(adapter, SLIC_REG_ADDR_UPPER,
2265                              cpu_to_le32(upper_32_bits(sm->isr_phaddr)));
2266                 slic_write32(adapter, SLIC_REG_ISP,
2267                              cpu_to_le32(lower_32_bits(sm->isr_phaddr)));
2268                 spin_unlock_irqrestore(&adapter->bit64reglock, flags);
2269
2270                 adapter->isp_initialized = 1;
2271         }
2272
2273         adapter->state = ADAPT_UP;
2274         if (!card->loadtimerset) {
2275                 setup_timer(&card->loadtimer, &slic_timer_load_check,
2276                             (ulong)card);
2277                 card->loadtimer.expires =
2278                     jiffies + (SLIC_LOADTIMER_PERIOD * HZ);
2279                 add_timer(&card->loadtimer);
2280
2281                 card->loadtimerset = 1;
2282         }
2283
2284         if (!adapter->pingtimerset) {
2285                 setup_timer(&adapter->pingtimer, &slic_timer_ping, (ulong)dev);
2286                 adapter->pingtimer.expires =
2287                     jiffies + (PING_TIMER_INTERVAL * HZ);
2288                 add_timer(&adapter->pingtimer);
2289                 adapter->pingtimerset = 1;
2290                 adapter->card->pingstatus = ISR_PINGMASK;
2291         }
2292
2293         /*
2294          *    clear any pending events, then enable interrupts
2295          */
2296         sm_data->isr = 0;
2297         slic_write32(adapter, SLIC_REG_ISR, 0);
2298         slic_write32(adapter, SLIC_REG_ICR, ICR_INT_ON);
2299
2300         slic_link_config(adapter, LINK_AUTOSPEED, LINK_AUTOD);
2301         slic_flush_write(adapter);
2302
2303         rc = slic_link_event_handler(adapter);
2304         if (rc) {
2305                 /* disable interrupts then clear pending events */
2306                 slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF);
2307                 slic_write32(adapter, SLIC_REG_ISR, 0);
2308                 slic_flush_write(adapter);
2309
2310                 if (adapter->pingtimerset) {
2311                         del_timer(&adapter->pingtimer);
2312                         adapter->pingtimerset = 0;
2313                 }
2314                 if (card->loadtimerset) {
2315                         del_timer(&card->loadtimer);
2316                         card->loadtimerset = 0;
2317                 }
2318                 adapter->state = ADAPT_DOWN;
2319                 slic_adapter_freeresources(adapter);
2320         }
2321
2322 err:
2323         return rc;
2324 }
2325
2326 static int slic_entry_open(struct net_device *dev)
2327 {
2328         struct adapter *adapter = netdev_priv(dev);
2329         struct sliccard *card = adapter->card;
2330         unsigned long flags;
2331         int status;
2332
2333         netif_carrier_off(dev);
2334
2335         spin_lock_irqsave(&slic_global.driver_lock, flags);
2336         if (!adapter->activated) {
2337                 card->adapters_activated++;
2338                 slic_global.num_slic_ports_active++;
2339                 adapter->activated = 1;
2340         }
2341         status = slic_if_init(adapter, &flags);
2342
2343         if (status != 0) {
2344                 if (adapter->activated) {
2345                         card->adapters_activated--;
2346                         slic_global.num_slic_ports_active--;
2347                         adapter->activated = 0;
2348                 }
2349                 goto spin_unlock;
2350         }
2351         if (!card->master)
2352                 card->master = adapter;
2353
2354 spin_unlock:
2355         spin_unlock_irqrestore(&slic_global.driver_lock, flags);
2356
2357         netif_start_queue(adapter->netdev);
2358
2359         return status;
2360 }
2361
2362 static void slic_card_cleanup(struct sliccard *card)
2363 {
2364         if (card->loadtimerset) {
2365                 card->loadtimerset = 0;
2366                 del_timer_sync(&card->loadtimer);
2367         }
2368
2369         kfree(card);
2370 }
2371
2372 static void slic_entry_remove(struct pci_dev *pcidev)
2373 {
2374         struct net_device *dev = pci_get_drvdata(pcidev);
2375         struct adapter *adapter = netdev_priv(dev);
2376         struct sliccard *card;
2377         struct mcast_address *mcaddr, *mlist;
2378
2379         unregister_netdev(dev);
2380
2381         slic_adapter_freeresources(adapter);
2382         iounmap(adapter->regs);
2383
2384         /* free multicast addresses */
2385         mlist = adapter->mcastaddrs;
2386         while (mlist) {
2387                 mcaddr = mlist;
2388                 mlist = mlist->next;
2389                 kfree(mcaddr);
2390         }
2391         card = adapter->card;
2392         card->adapters_allocated--;
2393         adapter->allocated = 0;
2394         if (!card->adapters_allocated) {
2395                 struct sliccard *curr_card = slic_global.slic_card;
2396
2397                 if (curr_card == card) {
2398                         slic_global.slic_card = card->next;
2399                 } else {
2400                         while (curr_card->next != card)
2401                                 curr_card = curr_card->next;
2402                         curr_card->next = card->next;
2403                 }
2404                 slic_global.num_slic_cards--;
2405                 slic_card_cleanup(card);
2406         }
2407         free_netdev(dev);
2408         pci_release_regions(pcidev);
2409         pci_disable_device(pcidev);
2410 }
2411
2412 static int slic_entry_halt(struct net_device *dev)
2413 {
2414         struct adapter *adapter = netdev_priv(dev);
2415         struct sliccard *card = adapter->card;
2416         unsigned long flags;
2417
2418         spin_lock_irqsave(&slic_global.driver_lock, flags);
2419         netif_stop_queue(adapter->netdev);
2420         adapter->state = ADAPT_DOWN;
2421         adapter->linkstate = LINK_DOWN;
2422         adapter->upr_list = NULL;
2423         adapter->upr_busy = 0;
2424         adapter->devflags_prev = 0;
2425         slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF);
2426         adapter->all_reg_writes++;
2427         adapter->icr_reg_writes++;
2428         slic_config_clear(adapter);
2429         if (adapter->activated) {
2430                 card->adapters_activated--;
2431                 slic_global.num_slic_ports_active--;
2432                 adapter->activated = 0;
2433         }
2434 #ifdef AUTOMATIC_RESET
2435         slic_write32(adapter, SLIC_REG_RESET_IFACE, 0);
2436 #endif
2437         slic_flush_write(adapter);
2438
2439         /*
2440          *  Reset the adapter's cmd queues
2441          */
2442         slic_cmdq_reset(adapter);
2443
2444 #ifdef AUTOMATIC_RESET
2445         if (!card->adapters_activated)
2446                 slic_card_init(card, adapter);
2447 #endif
2448
2449         spin_unlock_irqrestore(&slic_global.driver_lock, flags);
2450
2451         netif_carrier_off(dev);
2452
2453         return 0;
2454 }
2455
2456 static struct net_device_stats *slic_get_stats(struct net_device *dev)
2457 {
2458         struct adapter *adapter = netdev_priv(dev);
2459
2460         dev->stats.collisions = adapter->slic_stats.iface.xmit_collisions;
2461         dev->stats.rx_errors = adapter->slic_stats.iface.rcv_errors;
2462         dev->stats.tx_errors = adapter->slic_stats.iface.xmt_errors;
2463         dev->stats.rx_missed_errors = adapter->slic_stats.iface.rcv_discards;
2464         dev->stats.tx_heartbeat_errors = 0;
2465         dev->stats.tx_aborted_errors = 0;
2466         dev->stats.tx_window_errors = 0;
2467         dev->stats.tx_fifo_errors = 0;
2468         dev->stats.rx_frame_errors = 0;
2469         dev->stats.rx_length_errors = 0;
2470
2471         return &dev->stats;
2472 }
2473
2474 static int slic_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2475 {
2476         struct adapter *adapter = netdev_priv(dev);
2477         struct ethtool_cmd edata;
2478         struct ethtool_cmd ecmd;
2479         u32 data[7];
2480         u32 intagg;
2481
2482         switch (cmd) {
2483         case SIOCSLICSETINTAGG:
2484                 if (copy_from_user(data, rq->ifr_data, 28))
2485                         return -EFAULT;
2486                 intagg = data[0];
2487                 dev_err(&dev->dev, "set interrupt aggregation to %d\n",
2488                         intagg);
2489                 slic_intagg_set(adapter, intagg);
2490                 return 0;
2491
2492         case SIOCETHTOOL:
2493                 if (copy_from_user(&ecmd, rq->ifr_data, sizeof(ecmd)))
2494                         return -EFAULT;
2495
2496                 if (ecmd.cmd == ETHTOOL_GSET) {
2497                         memset(&edata, 0, sizeof(edata));
2498                         edata.supported = (SUPPORTED_10baseT_Half |
2499                                            SUPPORTED_10baseT_Full |
2500                                            SUPPORTED_100baseT_Half |
2501                                            SUPPORTED_100baseT_Full |
2502                                            SUPPORTED_Autoneg | SUPPORTED_MII);
2503                         edata.port = PORT_MII;
2504                         edata.transceiver = XCVR_INTERNAL;
2505                         edata.phy_address = 0;
2506                         if (adapter->linkspeed == LINK_100MB)
2507                                 edata.speed = SPEED_100;
2508                         else if (adapter->linkspeed == LINK_10MB)
2509                                 edata.speed = SPEED_10;
2510                         else
2511                                 edata.speed = 0;
2512
2513                         if (adapter->linkduplex == LINK_FULLD)
2514                                 edata.duplex = DUPLEX_FULL;
2515                         else
2516                                 edata.duplex = DUPLEX_HALF;
2517
2518                         edata.autoneg = AUTONEG_ENABLE;
2519                         edata.maxtxpkt = 1;
2520                         edata.maxrxpkt = 1;
2521                         if (copy_to_user(rq->ifr_data, &edata, sizeof(edata)))
2522                                 return -EFAULT;
2523
2524                 } else if (ecmd.cmd == ETHTOOL_SSET) {
2525                         if (!capable(CAP_NET_ADMIN))
2526                                 return -EPERM;
2527
2528                         if (adapter->linkspeed == LINK_100MB)
2529                                 edata.speed = SPEED_100;
2530                         else if (adapter->linkspeed == LINK_10MB)
2531                                 edata.speed = SPEED_10;
2532                         else
2533                                 edata.speed = 0;
2534
2535                         if (adapter->linkduplex == LINK_FULLD)
2536                                 edata.duplex = DUPLEX_FULL;
2537                         else
2538                                 edata.duplex = DUPLEX_HALF;
2539
2540                         edata.autoneg = AUTONEG_ENABLE;
2541                         edata.maxtxpkt = 1;
2542                         edata.maxrxpkt = 1;
2543                         if ((ecmd.speed != edata.speed) ||
2544                             (ecmd.duplex != edata.duplex)) {
2545                                 u32 speed;
2546                                 u32 duplex;
2547
2548                                 if (ecmd.speed == SPEED_10)
2549                                         speed = 0;
2550                                 else
2551                                         speed = PCR_SPEED_100;
2552                                 if (ecmd.duplex == DUPLEX_FULL)
2553                                         duplex = PCR_DUPLEX_FULL;
2554                                 else
2555                                         duplex = 0;
2556                                 slic_link_config(adapter, speed, duplex);
2557                                 if (slic_link_event_handler(adapter))
2558                                         return -EFAULT;
2559                         }
2560                 }
2561                 return 0;
2562         default:
2563                 return -EOPNOTSUPP;
2564         }
2565 }
2566
2567 static void slic_config_pci(struct pci_dev *pcidev)
2568 {
2569         u16 pci_command;
2570         u16 new_command;
2571
2572         pci_read_config_word(pcidev, PCI_COMMAND, &pci_command);
2573
2574         new_command = pci_command | PCI_COMMAND_MASTER
2575             | PCI_COMMAND_MEMORY
2576             | PCI_COMMAND_INVALIDATE
2577             | PCI_COMMAND_PARITY | PCI_COMMAND_SERR | PCI_COMMAND_FAST_BACK;
2578         if (pci_command != new_command)
2579                 pci_write_config_word(pcidev, PCI_COMMAND, new_command);
2580 }
2581
2582 static int slic_card_init(struct sliccard *card, struct adapter *adapter)
2583 {
2584         struct slic_shmemory *sm = &adapter->shmem;
2585         struct slic_shmem_data *sm_data = sm->shmem_data;
2586         struct slic_eeprom *peeprom;
2587         struct oslic_eeprom *pOeeprom;
2588         dma_addr_t phys_config;
2589         u32 phys_configh;
2590         u32 phys_configl;
2591         u32 i = 0;
2592         int status;
2593         uint macaddrs = card->card_size;
2594         ushort eecodesize;
2595         ushort dramsize;
2596         ushort ee_chksum;
2597         ushort calc_chksum;
2598         struct slic_config_mac *pmac;
2599         unsigned char fruformat;
2600         unsigned char oemfruformat;
2601         struct atk_fru *patkfru;
2602         union oemfru *poemfru;
2603         unsigned long flags;
2604
2605         /* Reset everything except PCI configuration space */
2606         slic_soft_reset(adapter);
2607
2608         /* Download the microcode */
2609         status = slic_card_download(adapter);
2610         if (status)
2611                 return status;
2612
2613         if (!card->config_set) {
2614                 peeprom = pci_alloc_consistent(adapter->pcidev,
2615                                                sizeof(struct slic_eeprom),
2616                                                &phys_config);
2617
2618                 if (!peeprom) {
2619                         dev_err(&adapter->pcidev->dev,
2620                                 "Failed to allocate DMA memory for EEPROM.\n");
2621                         return -ENOMEM;
2622                 }
2623
2624                 phys_configl = SLIC_GET_ADDR_LOW(phys_config);
2625                 phys_configh = SLIC_GET_ADDR_HIGH(phys_config);
2626
2627                 memset(peeprom, 0, sizeof(struct slic_eeprom));
2628
2629                 slic_write32(adapter, SLIC_REG_ICR, ICR_INT_OFF);
2630                 slic_flush_write(adapter);
2631                 mdelay(1);
2632
2633                 spin_lock_irqsave(&adapter->bit64reglock, flags);
2634                 slic_write32(adapter, SLIC_REG_ADDR_UPPER,
2635                              cpu_to_le32(upper_32_bits(sm->isr_phaddr)));
2636                 slic_write32(adapter, SLIC_REG_ISP,
2637                              cpu_to_le32(lower_32_bits(sm->isr_phaddr)));
2638                 spin_unlock_irqrestore(&adapter->bit64reglock, flags);
2639
2640                 status = slic_config_get(adapter, phys_configl, phys_configh);
2641                 if (status) {
2642                         dev_err(&adapter->pcidev->dev,
2643                                 "Failed to fetch config data from device.\n");
2644                         goto card_init_err;
2645                 }
2646
2647                 for (;;) {
2648                         if (sm_data->isr) {
2649                                 if (sm_data->isr & ISR_UPC) {
2650                                         sm_data->isr = 0;
2651                                         slic_write64(adapter, SLIC_REG_ISP, 0,
2652                                                      0);
2653                                         slic_write32(adapter, SLIC_REG_ISR, 0);
2654                                         slic_flush_write(adapter);
2655
2656                                         slic_upr_request_complete(adapter, 0);
2657                                         break;
2658                                 }
2659
2660                                 sm_data->isr = 0;
2661                                 slic_write32(adapter, SLIC_REG_ISR, 0);
2662                                 slic_flush_write(adapter);
2663                         } else {
2664                                 mdelay(1);
2665                                 i++;
2666                                 if (i > 5000) {
2667                                         dev_err(&adapter->pcidev->dev,
2668                                                 "Fetch of config data timed out.\n");
2669                                         slic_write64(adapter, SLIC_REG_ISP,
2670                                                      0, 0);
2671                                         slic_flush_write(adapter);
2672
2673                                         status = -EINVAL;
2674                                         goto card_init_err;
2675                                 }
2676                         }
2677                 }
2678
2679                 switch (adapter->devid) {
2680                 /* Oasis card */
2681                 case SLIC_2GB_DEVICE_ID:
2682                         /* extract EEPROM data and pointers to EEPROM data */
2683                         pOeeprom = (struct oslic_eeprom *)peeprom;
2684                         eecodesize = pOeeprom->EecodeSize;
2685                         dramsize = pOeeprom->DramSize;
2686                         pmac = pOeeprom->MacInfo;
2687                         fruformat = pOeeprom->FruFormat;
2688                         patkfru = &pOeeprom->AtkFru;
2689                         oemfruformat = pOeeprom->OemFruFormat;
2690                         poemfru = &pOeeprom->OemFru;
2691                         macaddrs = 2;
2692                         /*
2693                          * Minor kludge for Oasis card
2694                          * get 2 MAC addresses from the
2695                          * EEPROM to ensure that function 1
2696                          * gets the Port 1 MAC address
2697                          */
2698                         break;
2699                 default:
2700                         /* extract EEPROM data and pointers to EEPROM data */
2701                         eecodesize = peeprom->EecodeSize;
2702                         dramsize = peeprom->DramSize;
2703                         pmac = peeprom->u2.mac.MacInfo;
2704                         fruformat = peeprom->FruFormat;
2705                         patkfru = &peeprom->AtkFru;
2706                         oemfruformat = peeprom->OemFruFormat;
2707                         poemfru = &peeprom->OemFru;
2708                         break;
2709                 }
2710
2711                 card->config.EepromValid = false;
2712
2713                 /*  see if the EEPROM is valid by checking it's checksum */
2714                 if ((eecodesize <= MAX_EECODE_SIZE) &&
2715                     (eecodesize >= MIN_EECODE_SIZE)) {
2716                         ee_chksum =
2717                             *(u16 *)((char *)peeprom + (eecodesize - 2));
2718                         /*
2719                          *  calculate the EEPROM checksum
2720                          */
2721                         calc_chksum = slic_eeprom_cksum(peeprom,
2722                                                         eecodesize - 2);
2723                         /*
2724                          *  if the ucdoe chksum flag bit worked,
2725                          *  we wouldn't need this
2726                          */
2727                         if (ee_chksum == calc_chksum)
2728                                 card->config.EepromValid = true;
2729                 }
2730                 /*  copy in the DRAM size */
2731                 card->config.DramSize = dramsize;
2732
2733                 /*  copy in the MAC address(es) */
2734                 for (i = 0; i < macaddrs; i++) {
2735                         memcpy(&card->config.MacInfo[i],
2736                                &pmac[i], sizeof(struct slic_config_mac));
2737                 }
2738
2739                 /*  copy the Alacritech FRU information */
2740                 card->config.FruFormat = fruformat;
2741                 memcpy(&card->config.AtkFru, patkfru,
2742                                                 sizeof(struct atk_fru));
2743
2744                 pci_free_consistent(adapter->pcidev,
2745                                     sizeof(struct slic_eeprom),
2746                                     peeprom, phys_config);
2747
2748                 if (!card->config.EepromValid) {
2749                         slic_write64(adapter, SLIC_REG_ISP, 0, 0);
2750                         slic_flush_write(adapter);
2751                         dev_err(&adapter->pcidev->dev, "EEPROM invalid.\n");
2752                         return -EINVAL;
2753                 }
2754
2755                 card->config_set = 1;
2756         }
2757
2758         status = slic_card_download_gbrcv(adapter);
2759         if (status)
2760                 return status;
2761
2762         if (slic_global.dynamic_intagg)
2763                 slic_intagg_set(adapter, 0);
2764         else
2765                 slic_intagg_set(adapter, adapter->intagg_delay);
2766
2767         /*
2768          *  Initialize ping status to "ok"
2769          */
2770         card->pingstatus = ISR_PINGMASK;
2771
2772         /*
2773          * Lastly, mark our card state as up and return success
2774          */
2775         card->state = CARD_UP;
2776         card->reset_in_progress = 0;
2777
2778         return 0;
2779
2780 card_init_err:
2781         pci_free_consistent(adapter->pcidev, sizeof(struct slic_eeprom),
2782                             peeprom, phys_config);
2783         return status;
2784 }
2785
2786 static int slic_get_coalesce(struct net_device *dev,
2787                              struct ethtool_coalesce *coalesce)
2788 {
2789         struct adapter *adapter = netdev_priv(dev);
2790
2791         adapter->intagg_delay = coalesce->rx_coalesce_usecs;
2792         adapter->dynamic_intagg = coalesce->use_adaptive_rx_coalesce;
2793         return 0;
2794 }
2795
2796 static int slic_set_coalesce(struct net_device *dev,
2797                              struct ethtool_coalesce *coalesce)
2798 {
2799         struct adapter *adapter = netdev_priv(dev);
2800
2801         coalesce->rx_coalesce_usecs = adapter->intagg_delay;
2802         coalesce->use_adaptive_rx_coalesce = adapter->dynamic_intagg;
2803         return 0;
2804 }
2805
2806 static void slic_init_driver(void)
2807 {
2808         if (slic_first_init) {
2809                 slic_first_init = 0;
2810                 spin_lock_init(&slic_global.driver_lock);
2811         }
2812 }
2813
2814 static int slic_init_adapter(struct net_device *netdev,
2815                              struct pci_dev *pcidev,
2816                              const struct pci_device_id *pci_tbl_entry,
2817                              void __iomem *memaddr, int chip_idx)
2818 {
2819         ushort index;
2820         struct slic_handle *pslic_handle;
2821         struct adapter *adapter = netdev_priv(netdev);
2822         struct slic_shmemory *sm = &adapter->shmem;
2823         struct slic_shmem_data *sm_data;
2824         dma_addr_t phaddr;
2825
2826 /*      adapter->pcidev = pcidev;*/
2827         adapter->vendid = pci_tbl_entry->vendor;
2828         adapter->devid = pci_tbl_entry->device;
2829         adapter->subsysid = pci_tbl_entry->subdevice;
2830         adapter->busnumber = pcidev->bus->number;
2831         adapter->slotnumber = ((pcidev->devfn >> 3) & 0x1F);
2832         adapter->functionnumber = (pcidev->devfn & 0x7);
2833         adapter->regs = memaddr;
2834         adapter->irq = pcidev->irq;
2835         adapter->chipid = chip_idx;
2836         adapter->port = 0;
2837         adapter->cardindex = adapter->port;
2838         spin_lock_init(&adapter->upr_lock);
2839         spin_lock_init(&adapter->bit64reglock);
2840         spin_lock_init(&adapter->adapter_lock);
2841         spin_lock_init(&adapter->reset_lock);
2842         spin_lock_init(&adapter->handle_lock);
2843
2844         adapter->card_size = 1;
2845         /*
2846          * Initialize slic_handle array
2847          */
2848         /*
2849          * Start with 1.  0 is an invalid host handle.
2850          */
2851         for (index = 1, pslic_handle = &adapter->slic_handles[1];
2852              index < SLIC_CMDQ_MAXCMDS; index++, pslic_handle++) {
2853                 pslic_handle->token.handle_index = index;
2854                 pslic_handle->type = SLIC_HANDLE_FREE;
2855                 pslic_handle->next = adapter->pfree_slic_handles;
2856                 adapter->pfree_slic_handles = pslic_handle;
2857         }
2858         sm_data = pci_zalloc_consistent(adapter->pcidev, sizeof(*sm_data),
2859                                         &phaddr);
2860         if (!sm_data)
2861                 return -ENOMEM;
2862
2863         sm->shmem_data = sm_data;
2864         sm->isr_phaddr = phaddr;
2865         sm->lnkstatus_phaddr = phaddr + offsetof(struct slic_shmem_data,
2866                                                  lnkstatus);
2867         sm->stats_phaddr = phaddr + offsetof(struct slic_shmem_data, stats);
2868
2869         return 0;
2870 }
2871
2872 static const struct net_device_ops slic_netdev_ops = {
2873         .ndo_open               = slic_entry_open,
2874         .ndo_stop               = slic_entry_halt,
2875         .ndo_start_xmit         = slic_xmit_start,
2876         .ndo_do_ioctl           = slic_ioctl,
2877         .ndo_set_mac_address    = slic_mac_set_address,
2878         .ndo_get_stats          = slic_get_stats,
2879         .ndo_set_rx_mode        = slic_mcast_set_list,
2880         .ndo_validate_addr      = eth_validate_addr,
2881         .ndo_change_mtu         = eth_change_mtu,
2882 };
2883
2884 static u32 slic_card_locate(struct adapter *adapter)
2885 {
2886         struct sliccard *card = slic_global.slic_card;
2887         struct physcard *physcard = slic_global.phys_card;
2888         ushort card_hostid;
2889         uint i;
2890
2891         card_hostid = slic_read32(adapter, SLIC_REG_HOSTID);
2892
2893         /* Initialize a new card structure if need be */
2894         if (card_hostid == SLIC_HOSTID_DEFAULT) {
2895                 card = kzalloc(sizeof(*card), GFP_KERNEL);
2896                 if (!card)
2897                         return -ENOMEM;
2898
2899                 card->next = slic_global.slic_card;
2900                 slic_global.slic_card = card;
2901                 card->busnumber = adapter->busnumber;
2902                 card->slotnumber = adapter->slotnumber;
2903
2904                 /* Find an available cardnum */
2905                 for (i = 0; i < SLIC_MAX_CARDS; i++) {
2906                         if (slic_global.cardnuminuse[i] == 0) {
2907                                 slic_global.cardnuminuse[i] = 1;
2908                                 card->cardnum = i;
2909                                 break;
2910                         }
2911                 }
2912                 slic_global.num_slic_cards++;
2913         } else {
2914                 /* Card exists, find the card this adapter belongs to */
2915                 while (card) {
2916                         if (card->cardnum == card_hostid)
2917                                 break;
2918                         card = card->next;
2919                 }
2920         }
2921
2922         if (!card)
2923                 return -ENXIO;
2924         /* Put the adapter in the card's adapter list */
2925         if (!card->adapter[adapter->port]) {
2926                 card->adapter[adapter->port] = adapter;
2927                 adapter->card = card;
2928         }
2929
2930         card->card_size = 1;    /* one port per *logical* card */
2931
2932         while (physcard) {
2933                 for (i = 0; i < SLIC_MAX_PORTS; i++) {
2934                         if (physcard->adapter[i])
2935                                 break;
2936                 }
2937                 if (i == SLIC_MAX_PORTS)
2938                         break;
2939
2940                 if (physcard->adapter[i]->slotnumber == adapter->slotnumber)
2941                         break;
2942                 physcard = physcard->next;
2943         }
2944         if (!physcard) {
2945                 /* no structure allocated for this physical card yet */
2946                 physcard = kzalloc(sizeof(*physcard), GFP_ATOMIC);
2947                 if (!physcard) {
2948                         if (card_hostid == SLIC_HOSTID_DEFAULT)
2949                                 kfree(card);
2950                         return -ENOMEM;
2951                 }
2952
2953                 physcard->next = slic_global.phys_card;
2954                 slic_global.phys_card = physcard;
2955                 physcard->adapters_allocd = 1;
2956         } else {
2957                 physcard->adapters_allocd++;
2958         }
2959         /* Note - this is ZERO relative */
2960         adapter->physport = physcard->adapters_allocd - 1;
2961
2962         physcard->adapter[adapter->physport] = adapter;
2963         adapter->physcard = physcard;
2964
2965         return 0;
2966 }
2967
2968 static int slic_entry_probe(struct pci_dev *pcidev,
2969                                const struct pci_device_id *pci_tbl_entry)
2970 {
2971         static int cards_found;
2972         static int did_version;
2973         int err = -ENODEV;
2974         struct net_device *netdev;
2975         struct adapter *adapter;
2976         void __iomem *memmapped_ioaddr = NULL;
2977         ulong mmio_start = 0;
2978         ulong mmio_len = 0;
2979         struct sliccard *card = NULL;
2980         int pci_using_dac = 0;
2981
2982         err = pci_enable_device(pcidev);
2983
2984         if (err)
2985                 return err;
2986
2987         if (did_version++ == 0) {
2988                 dev_info(&pcidev->dev, "%s\n", slic_banner);
2989                 dev_info(&pcidev->dev, "%s\n", slic_proc_version);
2990         }
2991
2992         if (!pci_set_dma_mask(pcidev, DMA_BIT_MASK(64))) {
2993                 pci_using_dac = 1;
2994                 err = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64));
2995                 if (err) {
2996                         dev_err(&pcidev->dev, "unable to obtain 64-bit DMA for consistent allocations\n");
2997                         goto err_out_disable_pci;
2998                 }
2999         } else {
3000                 err = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
3001                 if (err) {
3002                         dev_err(&pcidev->dev, "no usable DMA configuration\n");
3003                         goto err_out_disable_pci;
3004                 }
3005                 pci_using_dac = 0;
3006                 pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32));
3007         }
3008
3009         err = pci_request_regions(pcidev, DRV_NAME);
3010         if (err) {
3011                 dev_err(&pcidev->dev, "can't obtain PCI resources\n");
3012                 goto err_out_disable_pci;
3013         }
3014
3015         pci_set_master(pcidev);
3016
3017         netdev = alloc_etherdev(sizeof(struct adapter));
3018         if (!netdev) {
3019                 err = -ENOMEM;
3020                 goto err_out_exit_slic_probe;
3021         }
3022
3023         netdev->ethtool_ops = &slic_ethtool_ops;
3024         SET_NETDEV_DEV(netdev, &pcidev->dev);
3025
3026         pci_set_drvdata(pcidev, netdev);
3027         adapter = netdev_priv(netdev);
3028         adapter->netdev = netdev;
3029         adapter->pcidev = pcidev;
3030         slic_global.dynamic_intagg = adapter->dynamic_intagg;
3031         if (pci_using_dac)
3032                 netdev->features |= NETIF_F_HIGHDMA;
3033
3034         mmio_start = pci_resource_start(pcidev, 0);
3035         mmio_len = pci_resource_len(pcidev, 0);
3036
3037         memmapped_ioaddr = ioremap_nocache(mmio_start, mmio_len);
3038         if (!memmapped_ioaddr) {
3039                 dev_err(&pcidev->dev, "cannot remap MMIO region %lx @ %lx\n",
3040                         mmio_len, mmio_start);
3041                 err = -ENOMEM;
3042                 goto err_out_free_netdev;
3043         }
3044
3045         slic_config_pci(pcidev);
3046
3047         slic_init_driver();
3048
3049         err = slic_init_adapter(netdev, pcidev, pci_tbl_entry, memmapped_ioaddr,
3050                                 cards_found);
3051         if (err) {
3052                 dev_err(&pcidev->dev, "failed to init adapter: %i\n", err);
3053                 goto err_out_unmap;
3054         }
3055
3056         err = slic_card_locate(adapter);
3057         if (err) {
3058                 dev_err(&pcidev->dev, "cannot locate card\n");
3059                 goto err_clean_init;
3060         }
3061
3062         card = adapter->card;
3063
3064         if (!adapter->allocated) {
3065                 card->adapters_allocated++;
3066                 adapter->allocated = 1;
3067         }
3068
3069         err = slic_card_init(card, adapter);
3070         if (err)
3071                 goto err_clean_init;
3072
3073         slic_adapter_set_hwaddr(adapter);
3074
3075         netdev->base_addr = (unsigned long)memmapped_ioaddr;
3076         netdev->irq = adapter->irq;
3077         netdev->netdev_ops = &slic_netdev_ops;
3078
3079         netif_carrier_off(netdev);
3080
3081         strcpy(netdev->name, "eth%d");
3082         err = register_netdev(netdev);
3083         if (err) {
3084                 dev_err(&pcidev->dev, "Cannot register net device, aborting.\n");
3085                 goto err_clean_init;
3086         }
3087
3088         cards_found++;
3089
3090         return 0;
3091
3092 err_clean_init:
3093         slic_init_cleanup(adapter);
3094 err_out_unmap:
3095         iounmap(memmapped_ioaddr);
3096 err_out_free_netdev:
3097         free_netdev(netdev);
3098 err_out_exit_slic_probe:
3099         pci_release_regions(pcidev);
3100 err_out_disable_pci:
3101         pci_disable_device(pcidev);
3102         return err;
3103 }
3104
3105 static struct pci_driver slic_driver = {
3106         .name = DRV_NAME,
3107         .id_table = slic_pci_tbl,
3108         .probe = slic_entry_probe,
3109         .remove = slic_entry_remove,
3110 };
3111
3112 static int __init slic_module_init(void)
3113 {
3114         slic_init_driver();
3115
3116         return pci_register_driver(&slic_driver);
3117 }
3118
3119 static void __exit slic_module_cleanup(void)
3120 {
3121         pci_unregister_driver(&slic_driver);
3122 }
3123
3124 static const struct ethtool_ops slic_ethtool_ops = {
3125         .get_coalesce = slic_get_coalesce,
3126         .set_coalesce = slic_set_coalesce
3127 };
3128
3129 module_init(slic_module_init);
3130 module_exit(slic_module_cleanup);