drivers/net/ethernet/alteon/acenic.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * acenic.c: Linux driver for the Alteon AceNIC Gigabit Ethernet card
   4  *           and other Tigon based cards.
   5  *
   6  * Copyright 1998-2002 by Jes Sorensen, <jes@trained-monkey.org>.
   7  *
   8  * Thanks to Alteon and 3Com for providing hardware and documentation
   9  * enabling me to write this driver.
  10  *
  11  * A mailing list for discussing the use of this driver has been
  12  * setup, please subscribe to the lists if you have any questions
  13  * about the driver. Send mail to linux-acenic-help@sunsite.auc.dk to
  14  * see how to subscribe.
  15  *
  16  * Additional credits:
  17  *   Pete Wyckoff <wyckoff@ca.sandia.gov>: Initial Linux/Alpha and trace
  18  *       dump support. The trace dump support has not been
  19  *       integrated yet however.
  20  *   Troy Benjegerdes: Big Endian (PPC) patches.
  21  *   Nate Stahl: Better out of memory handling and stats support.
  22  *   Aman Singla: Nasty race between interrupt handler and tx code dealing
  23  *                with 'testing the tx_ret_csm and setting tx_full'
  24  *   David S. Miller <davem@redhat.com>: conversion to new PCI dma mapping
  25  *                                       infrastructure and Sparc support
  26  *   Pierrick Pinasseau (CERN): For lending me an Ultra 5 to test the
  27  *                              driver under Linux/Sparc64
  28  *   Matt Domsch <Matt_Domsch@dell.com>: Detect Alteon 1000baseT cards
  29  *                                       ETHTOOL_GDRVINFO support
  30  *   Chip Salzenberg <chip@valinux.com>: Fix race condition between tx
  31  *                                       handler and close() cleanup.
  32  *   Ken Aaker <kdaaker@rchland.vnet.ibm.com>: Correct check for whether
  33  *                                       memory mapped IO is enabled to
  34  *                                       make the driver work on RS/6000.
  35  *   Takayoshi Kouchi <kouchi@hpc.bs1.fc.nec.co.jp>: Identifying problem
  36  *                                       where the driver would disable
  37  *                                       bus master mode if it had to disable
  38  *                                       write and invalidate.
  39  *   Stephen Hack <stephen_hack@hp.com>: Fixed ace_set_mac_addr for little
  40  *                                       endian systems.
  41  *   Val Henson <vhenson@esscom.com>:    Reset Jumbo skb producer and
  42  *                                       rx producer index when
  43  *                                       flushing the Jumbo ring.
  44  *   Hans Grobler <grobh@sun.ac.za>:     Memory leak fixes in the
  45  *                                       driver init path.
  46  *   Grant Grundler <grundler@cup.hp.com>: PCI write posting fixes.
  47  */
  48
  49 #include <linux/module.h>
  50 #include <linux/moduleparam.h>
  51 #include <linux/types.h>
  52 #include <linux/errno.h>
  53 #include <linux/ioport.h>
  54 #include <linux/pci.h>
  55 #include <linux/dma-mapping.h>
  56 #include <linux/kernel.h>
  57 #include <linux/netdevice.h>
  58 #include <linux/etherdevice.h>
  59 #include <linux/skbuff.h>
  60 #include <linux/delay.h>
  61 #include <linux/mm.h>
  62 #include <linux/highmem.h>
  63 #include <linux/sockios.h>
  64 #include <linux/firmware.h>
  65 #include <linux/slab.h>
  66 #include <linux/prefetch.h>
  67 #include <linux/if_vlan.h>
  68
  69 #ifdef SIOCETHTOOL
  70 #include <linux/ethtool.h>
  71 #endif
  72
  73 #include <net/sock.h>
  74 #include <net/ip.h>
  75
  76 #include <asm/io.h>
  77 #include <asm/irq.h>
  78 #include <asm/byteorder.h>
  79 #include <linux/uaccess.h>
  80
  81
  82 #define DRV_NAME "acenic"
  83
  84 #undef INDEX_DEBUG
  85
  86 #ifdef CONFIG_ACENIC_OMIT_TIGON_I
  87 #define ACE_IS_TIGON_I(ap)      0
  88 #define ACE_TX_RING_ENTRIES(ap) MAX_TX_RING_ENTRIES
  89 #else
  90 #define ACE_IS_TIGON_I(ap)      (ap->version == 1)
  91 #define ACE_TX_RING_ENTRIES(ap) ap->tx_ring_entries
  92 #endif
  93
  94 #ifndef PCI_VENDOR_ID_ALTEON
  95 #define PCI_VENDOR_ID_ALTEON            0x12ae
  96 #endif
  97 #ifndef PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE
  98 #define PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE  0x0001
  99 #define PCI_DEVICE_ID_ALTEON_ACENIC_COPPER 0x0002
 100 #endif
 101 #ifndef PCI_DEVICE_ID_3COM_3C985
 102 #define PCI_DEVICE_ID_3COM_3C985        0x0001
 103 #endif
 104 #ifndef PCI_VENDOR_ID_NETGEAR
 105 #define PCI_VENDOR_ID_NETGEAR           0x1385
 106 #define PCI_DEVICE_ID_NETGEAR_GA620     0x620a
 107 #endif
 108 #ifndef PCI_DEVICE_ID_NETGEAR_GA620T
 109 #define PCI_DEVICE_ID_NETGEAR_GA620T    0x630a
 110 #endif
 111
 112
 113 /*
 114  * Farallon used the DEC vendor ID by mistake and they seem not
 115  * to care - stinky!
 116  */
 117 #ifndef PCI_DEVICE_ID_FARALLON_PN9000SX
 118 #define PCI_DEVICE_ID_FARALLON_PN9000SX 0x1a
 119 #endif
 120 #ifndef PCI_DEVICE_ID_FARALLON_PN9100T
 121 #define PCI_DEVICE_ID_FARALLON_PN9100T  0xfa
 122 #endif
 123 #ifndef PCI_VENDOR_ID_SGI
 124 #define PCI_VENDOR_ID_SGI               0x10a9
 125 #endif
 126 #ifndef PCI_DEVICE_ID_SGI_ACENIC
 127 #define PCI_DEVICE_ID_SGI_ACENIC        0x0009
 128 #endif
 129
 130 static const struct pci_device_id acenic_pci_tbl[] = {
 131         { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE,
 132           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 133         { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_COPPER,
 134           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 135         { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C985,
 136           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 137         { PCI_VENDOR_ID_NETGEAR, PCI_DEVICE_ID_NETGEAR_GA620,
 138           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 139         { PCI_VENDOR_ID_NETGEAR, PCI_DEVICE_ID_NETGEAR_GA620T,
 140           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 141         /*
 142          * Farallon used the DEC vendor ID on their cards incorrectly,
 143          * then later Alteon's ID.
 144          */
 145         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_FARALLON_PN9000SX,
 146           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 147         { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_FARALLON_PN9100T,
 148           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 149         { PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_ACENIC,
 150           PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
 151         { }
 152 };
 153 MODULE_DEVICE_TABLE(pci, acenic_pci_tbl);
 154
 155 #define ace_sync_irq(irq)       synchronize_irq(irq)
 156
 157 #ifndef offset_in_page
 158 #define offset_in_page(ptr)     ((unsigned long)(ptr) & ~PAGE_MASK)
 159 #endif
 160
 161 #define ACE_MAX_MOD_PARMS       8
 162 #define BOARD_IDX_STATIC        0
 163 #define BOARD_IDX_OVERFLOW      -1
 164
 165 #include "acenic.h"
 166
 167 /*
 168  * These must be defined before the firmware is included.
 169  */
 170 #define MAX_TEXT_LEN    96*1024
 171 #define MAX_RODATA_LEN  8*1024
 172 #define MAX_DATA_LEN    2*1024
 173
 174 #ifndef tigon2FwReleaseLocal
 175 #define tigon2FwReleaseLocal 0
 176 #endif
 177
 178 /*
 179  * This driver currently supports Tigon I and Tigon II based cards
 180  * including the Alteon AceNIC, the 3Com 3C985[B] and NetGear
 181  * GA620. The driver should also work on the SGI, DEC and Farallon
 182  * versions of the card, however I have not been able to test that
 183  * myself.
 184  *
 185  * This card is really neat, it supports receive hardware checksumming
 186  * and jumbo frames (up to 9000 bytes) and does a lot of work in the
 187  * firmware. Also the programming interface is quite neat, except for
 188  * the parts dealing with the i2c eeprom on the card ;-)
 189  *
 190  * Using jumbo frames:
 191  *
 192  * To enable jumbo frames, simply specify an mtu between 1500 and 9000
 193  * bytes to ifconfig. Jumbo frames can be enabled or disabled at any time
 194  * by running `ifconfig eth<X> mtu <MTU>' with <X> being the Ethernet
 195  * interface number and <MTU> being the MTU value.
 196  *
 197  * Module parameters:
 198  *
 199  * When compiled as a loadable module, the driver allows for a number
 200  * of module parameters to be specified. The driver supports the
 201  * following module parameters:
 202  *
 203  *  trace=<val> - Firmware trace level. This requires special traced
 204  *                firmware to replace the firmware supplied with
 205  *                the driver - for debugging purposes only.
 206  *
 207  *  link=<val>  - Link state. Normally you want to use the default link
 208  *                parameters set by the driver. This can be used to
 209  *                override these in case your switch doesn't negotiate
 210  *                the link properly. Valid values are:
 211  *         0x0001 - Force half duplex link.
 212  *         0x0002 - Do not negotiate line speed with the other end.
 213  *         0x0010 - 10Mbit/sec link.
 214  *         0x0020 - 100Mbit/sec link.
 215  *         0x0040 - 1000Mbit/sec link.
 216  *         0x0100 - Do not negotiate flow control.
 217  *         0x0200 - Enable RX flow control Y
 218  *         0x0400 - Enable TX flow control Y (Tigon II NICs only).
 219  *                Default value is 0x0270, ie. enable link+flow
 220  *                control negotiation. Negotiating the highest
 221  *                possible link speed with RX flow control enabled.
 222  *
 223  *                When disabling link speed negotiation, only one link
 224  *                speed is allowed to be specified!
 225  *
 226  *  tx_coal_tick=<val> - number of coalescing clock ticks (us) allowed
 227  *                to wait for more packets to arive before
 228  *                interrupting the host, from the time the first
 229  *                packet arrives.
 230  *
 231  *  rx_coal_tick=<val> - number of coalescing clock ticks (us) allowed
 232  *                to wait for more packets to arive in the transmit ring,
 233  *                before interrupting the host, after transmitting the
 234  *                first packet in the ring.
 235  *
 236  *  max_tx_desc=<val> - maximum number of transmit descriptors
 237  *                (packets) transmitted before interrupting the host.
 238  *
 239  *  max_rx_desc=<val> - maximum number of receive descriptors
 240  *                (packets) received before interrupting the host.
 241  *
 242  *  tx_ratio=<val> - 7 bit value (0 - 63) specifying the split in 64th
 243  *                increments of the NIC's on board memory to be used for
 244  *                transmit and receive buffers. For the 1MB NIC app. 800KB
 245  *                is available, on the 1/2MB NIC app. 300KB is available.
 246  *                68KB will always be available as a minimum for both
 247  *                directions. The default value is a 50/50 split.
 248  *  dis_pci_mem_inval=<val> - disable PCI memory write and invalidate
 249  *                operations, default (1) is to always disable this as
 250  *                that is what Alteon does on NT. I have not been able
 251  *                to measure any real performance differences with
 252  *                this on my systems. Set <val>=0 if you want to
 253  *                enable these operations.
 254  *
 255  * If you use more than one NIC, specify the parameters for the
 256  * individual NICs with a comma, ie. trace=0,0x00001fff,0 you want to
 257  * run tracing on NIC #2 but not on NIC #1 and #3.
 258  *
 259  * TODO:
 260  *
 261  * - Proper multicast support.
 262  * - NIC dump support.
 263  * - More tuning parameters.
 264  *
 265  * The mini ring is not used under Linux and I am not sure it makes sense
 266  * to actually use it.
 267  *
 268  * New interrupt handler strategy:
 269  *
 270  * The old interrupt handler worked using the traditional method of
 271  * replacing an skbuff with a new one when a packet arrives. However
 272  * the rx rings do not need to contain a static number of buffer
 273  * descriptors, thus it makes sense to move the memory allocation out
 274  * of the main interrupt handler and do it in a bottom half handler
 275  * and only allocate new buffers when the number of buffers in the
 276  * ring is below a certain threshold. In order to avoid starving the
 277  * NIC under heavy load it is however necessary to force allocation
 278  * when hitting a minimum threshold. The strategy for alloction is as
 279  * follows:
 280  *
 281  *     RX_LOW_BUF_THRES    - allocate buffers in the bottom half
 282  *     RX_PANIC_LOW_THRES  - we are very low on buffers, allocate
 283  *                           the buffers in the interrupt handler
 284  *     RX_RING_THRES       - maximum number of buffers in the rx ring
 285  *     RX_MINI_THRES       - maximum number of buffers in the mini ring
 286  *     RX_JUMBO_THRES      - maximum number of buffers in the jumbo ring
 287  *
 288  * One advantagous side effect of this allocation approach is that the
 289  * entire rx processing can be done without holding any spin lock
 290  * since the rx rings and registers are totally independent of the tx
 291  * ring and its registers.  This of course includes the kmalloc's of
 292  * new skb's. Thus start_xmit can run in parallel with rx processing
 293  * and the memory allocation on SMP systems.
 294  *
 295  * Note that running the skb reallocation in a bottom half opens up
 296  * another can of races which needs to be handled properly. In
 297  * particular it can happen that the interrupt handler tries to run
 298  * the reallocation while the bottom half is either running on another
 299  * CPU or was interrupted on the same CPU. To get around this the
 300  * driver uses bitops to prevent the reallocation routines from being
 301  * reentered.
 302  *
 303  * TX handling can also be done without holding any spin lock, wheee
 304  * this is fun! since tx_ret_csm is only written to by the interrupt
 305  * handler. The case to be aware of is when shutting down the device
 306  * and cleaning up where it is necessary to make sure that
 307  * start_xmit() is not running while this is happening. Well DaveM
 308  * informs me that this case is already protected against ... bye bye
 309  * Mr. Spin Lock, it was nice to know you.
 310  *
 311  * TX interrupts are now partly disabled so the NIC will only generate
 312  * TX interrupts for the number of coal ticks, not for the number of
 313  * TX packets in the queue. This should reduce the number of TX only,
 314  * ie. when no RX processing is done, interrupts seen.
 315  */
 316
 317 /*
 318  * Threshold values for RX buffer allocation - the low water marks for
 319  * when to start refilling the rings are set to 75% of the ring
 320  * sizes. It seems to make sense to refill the rings entirely from the
 321  * intrrupt handler once it gets below the panic threshold, that way
 322  * we don't risk that the refilling is moved to another CPU when the
 323  * one running the interrupt handler just got the slab code hot in its
 324  * cache.
 325  */
 326 #define RX_RING_SIZE            72
 327 #define RX_MINI_SIZE            64
 328 #define RX_JUMBO_SIZE           48
 329
 330 #define RX_PANIC_STD_THRES      16
 331 #define RX_PANIC_STD_REFILL     (3*RX_PANIC_STD_THRES)/2
 332 #define RX_LOW_STD_THRES        (3*RX_RING_SIZE)/4
 333 #define RX_PANIC_MINI_THRES     12
 334 #define RX_PANIC_MINI_REFILL    (3*RX_PANIC_MINI_THRES)/2
 335 #define RX_LOW_MINI_THRES       (3*RX_MINI_SIZE)/4
 336 #define RX_PANIC_JUMBO_THRES    6
 337 #define RX_PANIC_JUMBO_REFILL   (3*RX_PANIC_JUMBO_THRES)/2
 338 #define RX_LOW_JUMBO_THRES      (3*RX_JUMBO_SIZE)/4
 339
 340
 341 /*
 342  * Size of the mini ring entries, basically these just should be big
 343  * enough to take TCP ACKs
 344  */
 345 #define ACE_MINI_SIZE           100
 346
 347 #define ACE_MINI_BUFSIZE        ACE_MINI_SIZE
 348 #define ACE_STD_BUFSIZE         (ACE_STD_MTU + ETH_HLEN + 4)
 349 #define ACE_JUMBO_BUFSIZE       (ACE_JUMBO_MTU + ETH_HLEN + 4)
 350
 351 /*
 352  * There seems to be a magic difference in the effect between 995 and 996
 353  * but little difference between 900 and 995 ... no idea why.
 354  *
 355  * There is now a default set of tuning parameters which is set, depending
 356  * on whether or not the user enables Jumbo frames. It's assumed that if
 357  * Jumbo frames are enabled, the user wants optimal tuning for that case.
 358  */
 359 #define DEF_TX_COAL             400 /* 996 */
 360 #define DEF_TX_MAX_DESC         60  /* was 40 */
 361 #define DEF_RX_COAL             120 /* 1000 */
 362 #define DEF_RX_MAX_DESC         25
 363 #define DEF_TX_RATIO            21 /* 24 */
 364
 365 #define DEF_JUMBO_TX_COAL       20
 366 #define DEF_JUMBO_TX_MAX_DESC   60
 367 #define DEF_JUMBO_RX_COAL       30
 368 #define DEF_JUMBO_RX_MAX_DESC   6
 369 #define DEF_JUMBO_TX_RATIO      21
 370
 371 #if tigon2FwReleaseLocal < 20001118
 372 /*
 373  * Standard firmware and early modifications duplicate
 374  * IRQ load without this flag (coal timer is never reset).
 375  * Note that with this flag tx_coal should be less than
 376  * time to xmit full tx ring.
 377  * 400usec is not so bad for tx ring size of 128.
 378  */
 379 #define TX_COAL_INTS_ONLY       1       /* worth it */
 380 #else
 381 /*
 382  * With modified firmware, this is not necessary, but still useful.
 383  */
 384 #define TX_COAL_INTS_ONLY       1
 385 #endif
 386
 387 #define DEF_TRACE               0
 388 #define DEF_STAT                (2 * TICKS_PER_SEC)
 389
 390
 391 static int link_state[ACE_MAX_MOD_PARMS];
 392 static int trace[ACE_MAX_MOD_PARMS];
 393 static int tx_coal_tick[ACE_MAX_MOD_PARMS];
 394 static int rx_coal_tick[ACE_MAX_MOD_PARMS];
 395 static int max_tx_desc[ACE_MAX_MOD_PARMS];
 396 static int max_rx_desc[ACE_MAX_MOD_PARMS];
 397 static int tx_ratio[ACE_MAX_MOD_PARMS];
 398 static int dis_pci_mem_inval[ACE_MAX_MOD_PARMS] = {1, 1, 1, 1, 1, 1, 1, 1};
 399
 400 MODULE_AUTHOR("Jes Sorensen <jes@trained-monkey.org>");
 401 MODULE_LICENSE("GPL");
 402 MODULE_DESCRIPTION("AceNIC/3C985/GA620 Gigabit Ethernet driver");
 403 #ifndef CONFIG_ACENIC_OMIT_TIGON_I
 404 MODULE_FIRMWARE("acenic/tg1.bin");
 405 #endif
 406 MODULE_FIRMWARE("acenic/tg2.bin");
 407
 408 module_param_array_named(link, link_state, int, NULL, 0);
 409 module_param_array(trace, int, NULL, 0);
 410 module_param_array(tx_coal_tick, int, NULL, 0);
 411 module_param_array(max_tx_desc, int, NULL, 0);
 412 module_param_array(rx_coal_tick, int, NULL, 0);
 413 module_param_array(max_rx_desc, int, NULL, 0);
 414 module_param_array(tx_ratio, int, NULL, 0);
 415 MODULE_PARM_DESC(link, "AceNIC/3C985/NetGear link state");
 416 MODULE_PARM_DESC(trace, "AceNIC/3C985/NetGear firmware trace level");
 417 MODULE_PARM_DESC(tx_coal_tick, "AceNIC/3C985/GA620 max clock ticks to wait from first tx descriptor arrives");
 418 MODULE_PARM_DESC(max_tx_desc, "AceNIC/3C985/GA620 max number of transmit descriptors to wait");
 419 MODULE_PARM_DESC(rx_coal_tick, "AceNIC/3C985/GA620 max clock ticks to wait from first rx descriptor arrives");
 420 MODULE_PARM_DESC(max_rx_desc, "AceNIC/3C985/GA620 max number of receive descriptors to wait");
 421 MODULE_PARM_DESC(tx_ratio, "AceNIC/3C985/GA620 ratio of NIC memory used for TX/RX descriptors (range 0-63)");
 422
 423
 424 static const char version[] =
 425   "acenic.c: v0.92 08/05/2002  Jes Sorensen, linux-acenic@SunSITE.dk\n"
 426   "                            http://home.cern.ch/~jes/gige/acenic.html\n";
 427
 428 static int ace_get_link_ksettings(struct net_device *,
 429                                   struct ethtool_link_ksettings *);
 430 static int ace_set_link_ksettings(struct net_device *,
 431                                   const struct ethtool_link_ksettings *);
 432 static void ace_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);
 433
 434 static const struct ethtool_ops ace_ethtool_ops = {
 435         .get_drvinfo = ace_get_drvinfo,
 436         .get_link_ksettings = ace_get_link_ksettings,
 437         .set_link_ksettings = ace_set_link_ksettings,
 438 };
 439
 440 static void ace_watchdog(struct net_device *dev);
 441
 442 static const struct net_device_ops ace_netdev_ops = {
 443         .ndo_open               = ace_open,
 444         .ndo_stop               = ace_close,
 445         .ndo_tx_timeout         = ace_watchdog,
 446         .ndo_get_stats          = ace_get_stats,
 447         .ndo_start_xmit         = ace_start_xmit,
 448         .ndo_set_rx_mode        = ace_set_multicast_list,
 449         .ndo_validate_addr      = eth_validate_addr,
 450         .ndo_set_mac_address    = ace_set_mac_addr,
 451         .ndo_change_mtu         = ace_change_mtu,
 452 };
 453
 454 static int acenic_probe_one(struct pci_dev *pdev,
 455                             const struct pci_device_id *id)
 456 {
 457         struct net_device *dev;
 458         struct ace_private *ap;
 459         static int boards_found;
 460
 461         dev = alloc_etherdev(sizeof(struct ace_private));
 462         if (dev == NULL)
 463                 return -ENOMEM;
 464
 465         SET_NETDEV_DEV(dev, &pdev->dev);
 466
 467         ap = netdev_priv(dev);
 468         ap->pdev = pdev;
 469         ap->name = pci_name(pdev);
 470
 471         dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
 472         dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
 473
 474         dev->watchdog_timeo = 5*HZ;
 475         dev->min_mtu = 0;
 476         dev->max_mtu = ACE_JUMBO_MTU;
 477
 478         dev->netdev_ops = &ace_netdev_ops;
 479         dev->ethtool_ops = &ace_ethtool_ops;
 480
 481         /* we only display this string ONCE */
 482         if (!boards_found)
 483                 printk(version);
 484
 485         if (pci_enable_device(pdev))
 486                 goto fail_free_netdev;
 487
 488         /*
 489          * Enable master mode before we start playing with the
 490          * pci_command word since pci_set_master() will modify
 491          * it.
 492          */
 493         pci_set_master(pdev);
 494
 495         pci_read_config_word(pdev, PCI_COMMAND, &ap->pci_command);
 496
 497         /* OpenFirmware on Mac's does not set this - DOH.. */
 498         if (!(ap->pci_command & PCI_COMMAND_MEMORY)) {
 499                 printk(KERN_INFO "%s: Enabling PCI Memory Mapped "
 500                        "access - was not enabled by BIOS/Firmware\n",
 501                        ap->name);
 502                 ap->pci_command = ap->pci_command | PCI_COMMAND_MEMORY;
 503                 pci_write_config_word(ap->pdev, PCI_COMMAND,
 504                                       ap->pci_command);
 505                 wmb();
 506         }
 507
 508         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ap->pci_latency);
 509         if (ap->pci_latency <= 0x40) {
 510                 ap->pci_latency = 0x40;
 511                 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ap->pci_latency);
 512         }
 513
 514         /*
 515          * Remap the regs into kernel space - this is abuse of
 516          * dev->base_addr since it was means for I/O port
 517          * addresses but who gives a damn.
 518          */
 519         dev->base_addr = pci_resource_start(pdev, 0);
 520         ap->regs = ioremap(dev->base_addr, 0x4000);
 521         if (!ap->regs) {
 522                 printk(KERN_ERR "%s:  Unable to map I/O register, "
 523                        "AceNIC %i will be disabled.\n",
 524                        ap->name, boards_found);
 525                 goto fail_free_netdev;
 526         }
 527
 528         switch(pdev->vendor) {
 529         case PCI_VENDOR_ID_ALTEON:
 530                 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9100T) {
 531                         printk(KERN_INFO "%s: Farallon PN9100-T ",
 532                                ap->name);
 533                 } else {
 534                         printk(KERN_INFO "%s: Alteon AceNIC ",
 535                                ap->name);
 536                 }
 537                 break;
 538         case PCI_VENDOR_ID_3COM:
 539                 printk(KERN_INFO "%s: 3Com 3C985 ", ap->name);
 540                 break;
 541         case PCI_VENDOR_ID_NETGEAR:
 542                 printk(KERN_INFO "%s: NetGear GA620 ", ap->name);
 543                 break;
 544         case PCI_VENDOR_ID_DEC:
 545                 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9000SX) {
 546                         printk(KERN_INFO "%s: Farallon PN9000-SX ",
 547                                ap->name);
 548                         break;
 549                 }
 550                 /* Fall through */
 551         case PCI_VENDOR_ID_SGI:
 552                 printk(KERN_INFO "%s: SGI AceNIC ", ap->name);
 553                 break;
 554         default:
 555                 printk(KERN_INFO "%s: Unknown AceNIC ", ap->name);
 556                 break;
 557         }
 558
 559         printk("Gigabit Ethernet at 0x%08lx, ", dev->base_addr);
 560         printk("irq %d\n", pdev->irq);
 561
 562 #ifdef CONFIG_ACENIC_OMIT_TIGON_I
 563         if ((readl(&ap->regs->HostCtrl) >> 28) == 4) {
 564                 printk(KERN_ERR "%s: Driver compiled without Tigon I"
 565                        " support - NIC disabled\n", dev->name);
 566                 goto fail_uninit;
 567         }
 568 #endif
 569
 570         if (ace_allocate_descriptors(dev))
 571                 goto fail_free_netdev;
 572
 573 #ifdef MODULE
 574         if (boards_found >= ACE_MAX_MOD_PARMS)
 575                 ap->board_idx = BOARD_IDX_OVERFLOW;
 576         else
 577                 ap->board_idx = boards_found;
 578 #else
 579         ap->board_idx = BOARD_IDX_STATIC;
 580 #endif
 581
 582         if (ace_init(dev))
 583                 goto fail_free_netdev;
 584
 585         if (register_netdev(dev)) {
 586                 printk(KERN_ERR "acenic: device registration failed\n");
 587                 goto fail_uninit;
 588         }
 589         ap->name = dev->name;
 590
 591         if (ap->pci_using_dac)
 592                 dev->features |= NETIF_F_HIGHDMA;
 593
 594         pci_set_drvdata(pdev, dev);
 595
 596         boards_found++;
 597         return 0;
 598
 599  fail_uninit:
 600         ace_init_cleanup(dev);
 601  fail_free_netdev:
 602         free_netdev(dev);
 603         return -ENODEV;
 604 }
 605
 606 static void acenic_remove_one(struct pci_dev *pdev)
 607 {
 608         struct net_device *dev = pci_get_drvdata(pdev);
 609         struct ace_private *ap = netdev_priv(dev);
 610         struct ace_regs __iomem *regs = ap->regs;
 611         short i;
 612
 613         unregister_netdev(dev);
 614
 615         writel(readl(&regs->CpuCtrl) | CPU_HALT, &regs->CpuCtrl);
 616         if (ap->version >= 2)
 617                 writel(readl(&regs->CpuBCtrl) | CPU_HALT, &regs->CpuBCtrl);
 618
 619         /*
 620          * This clears any pending interrupts
 621          */
 622         writel(1, &regs->Mb0Lo);
 623         readl(&regs->CpuCtrl);  /* flush */
 624
 625         /*
 626          * Make sure no other CPUs are processing interrupts
 627          * on the card before the buffers are being released.
 628          * Otherwise one might experience some `interesting'
 629          * effects.
 630          *
 631          * Then release the RX buffers - jumbo buffers were
 632          * already released in ace_close().
 633          */
 634         ace_sync_irq(dev->irq);
 635
 636         for (i = 0; i < RX_STD_RING_ENTRIES; i++) {
 637                 struct sk_buff *skb = ap->skb->rx_std_skbuff[i].skb;
 638
 639                 if (skb) {
 640                         struct ring_info *ringp;
 641                         dma_addr_t mapping;
 642
 643                         ringp = &ap->skb->rx_std_skbuff[i];
 644                         mapping = dma_unmap_addr(ringp, mapping);
 645                         pci_unmap_page(ap->pdev, mapping,
 646                                        ACE_STD_BUFSIZE,
 647                                        PCI_DMA_FROMDEVICE);
 648
 649                         ap->rx_std_ring[i].size = 0;
 650                         ap->skb->rx_std_skbuff[i].skb = NULL;
 651                         dev_kfree_skb(skb);
 652                 }
 653         }
 654
 655         if (ap->version >= 2) {
 656                 for (i = 0; i < RX_MINI_RING_ENTRIES; i++) {
 657                         struct sk_buff *skb = ap->skb->rx_mini_skbuff[i].skb;
 658
 659                         if (skb) {
 660                                 struct ring_info *ringp;
 661                                 dma_addr_t mapping;
 662
 663                                 ringp = &ap->skb->rx_mini_skbuff[i];
 664                                 mapping = dma_unmap_addr(ringp,mapping);
 665                                 pci_unmap_page(ap->pdev, mapping,
 666                                                ACE_MINI_BUFSIZE,
 667                                                PCI_DMA_FROMDEVICE);
 668
 669                                 ap->rx_mini_ring[i].size = 0;
 670                                 ap->skb->rx_mini_skbuff[i].skb = NULL;
 671                                 dev_kfree_skb(skb);
 672                         }
 673                 }
 674         }
 675
 676         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
 677                 struct sk_buff *skb = ap->skb->rx_jumbo_skbuff[i].skb;
 678                 if (skb) {
 679                         struct ring_info *ringp;
 680                         dma_addr_t mapping;
 681
 682                         ringp = &ap->skb->rx_jumbo_skbuff[i];
 683                         mapping = dma_unmap_addr(ringp, mapping);
 684                         pci_unmap_page(ap->pdev, mapping,
 685                                        ACE_JUMBO_BUFSIZE,
 686                                        PCI_DMA_FROMDEVICE);
 687
 688                         ap->rx_jumbo_ring[i].size = 0;
 689                         ap->skb->rx_jumbo_skbuff[i].skb = NULL;
 690                         dev_kfree_skb(skb);
 691                 }
 692         }
 693
 694         ace_init_cleanup(dev);
 695         free_netdev(dev);
 696 }
 697
 698 static struct pci_driver acenic_pci_driver = {
 699         .name           = "acenic",
 700         .id_table       = acenic_pci_tbl,
 701         .probe          = acenic_probe_one,
 702         .remove         = acenic_remove_one,
 703 };
 704
 705 static void ace_free_descriptors(struct net_device *dev)
 706 {
 707         struct ace_private *ap = netdev_priv(dev);
 708         int size;
 709
 710         if (ap->rx_std_ring != NULL) {
 711                 size = (sizeof(struct rx_desc) *
 712                         (RX_STD_RING_ENTRIES +
 713                          RX_JUMBO_RING_ENTRIES +
 714                          RX_MINI_RING_ENTRIES +
 715                          RX_RETURN_RING_ENTRIES));
 716                 pci_free_consistent(ap->pdev, size, ap->rx_std_ring,
 717                                     ap->rx_ring_base_dma);
 718                 ap->rx_std_ring = NULL;
 719                 ap->rx_jumbo_ring = NULL;
 720                 ap->rx_mini_ring = NULL;
 721                 ap->rx_return_ring = NULL;
 722         }
 723         if (ap->evt_ring != NULL) {
 724                 size = (sizeof(struct event) * EVT_RING_ENTRIES);
 725                 pci_free_consistent(ap->pdev, size, ap->evt_ring,
 726                                     ap->evt_ring_dma);
 727                 ap->evt_ring = NULL;
 728         }
 729         if (ap->tx_ring != NULL && !ACE_IS_TIGON_I(ap)) {
 730                 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
 731                 pci_free_consistent(ap->pdev, size, ap->tx_ring,
 732                                     ap->tx_ring_dma);
 733         }
 734         ap->tx_ring = NULL;
 735
 736         if (ap->evt_prd != NULL) {
 737                 pci_free_consistent(ap->pdev, sizeof(u32),
 738                                     (void *)ap->evt_prd, ap->evt_prd_dma);
 739                 ap->evt_prd = NULL;
 740         }
 741         if (ap->rx_ret_prd != NULL) {
 742                 pci_free_consistent(ap->pdev, sizeof(u32),
 743                                     (void *)ap->rx_ret_prd,
 744                                     ap->rx_ret_prd_dma);
 745                 ap->rx_ret_prd = NULL;
 746         }
 747         if (ap->tx_csm != NULL) {
 748                 pci_free_consistent(ap->pdev, sizeof(u32),
 749                                     (void *)ap->tx_csm, ap->tx_csm_dma);
 750                 ap->tx_csm = NULL;
 751         }
 752 }
 753
 754
 755 static int ace_allocate_descriptors(struct net_device *dev)
 756 {
 757         struct ace_private *ap = netdev_priv(dev);
 758         int size;
 759
 760         size = (sizeof(struct rx_desc) *
 761                 (RX_STD_RING_ENTRIES +
 762                  RX_JUMBO_RING_ENTRIES +
 763                  RX_MINI_RING_ENTRIES +
 764                  RX_RETURN_RING_ENTRIES));
 765
 766         ap->rx_std_ring = pci_alloc_consistent(ap->pdev, size,
 767                                                &ap->rx_ring_base_dma);
 768         if (ap->rx_std_ring == NULL)
 769                 goto fail;
 770
 771         ap->rx_jumbo_ring = ap->rx_std_ring + RX_STD_RING_ENTRIES;
 772         ap->rx_mini_ring = ap->rx_jumbo_ring + RX_JUMBO_RING_ENTRIES;
 773         ap->rx_return_ring = ap->rx_mini_ring + RX_MINI_RING_ENTRIES;
 774
 775         size = (sizeof(struct event) * EVT_RING_ENTRIES);
 776
 777         ap->evt_ring = pci_alloc_consistent(ap->pdev, size, &ap->evt_ring_dma);
 778
 779         if (ap->evt_ring == NULL)
 780                 goto fail;
 781
 782         /*
 783          * Only allocate a host TX ring for the Tigon II, the Tigon I
 784          * has to use PCI registers for this ;-(
 785          */
 786         if (!ACE_IS_TIGON_I(ap)) {
 787                 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
 788
 789                 ap->tx_ring = pci_alloc_consistent(ap->pdev, size,
 790                                                    &ap->tx_ring_dma);
 791
 792                 if (ap->tx_ring == NULL)
 793                         goto fail;
 794         }
 795
 796         ap->evt_prd = pci_alloc_consistent(ap->pdev, sizeof(u32),
 797                                            &ap->evt_prd_dma);
 798         if (ap->evt_prd == NULL)
 799                 goto fail;
 800
 801         ap->rx_ret_prd = pci_alloc_consistent(ap->pdev, sizeof(u32),
 802                                               &ap->rx_ret_prd_dma);
 803         if (ap->rx_ret_prd == NULL)
 804                 goto fail;
 805
 806         ap->tx_csm = pci_alloc_consistent(ap->pdev, sizeof(u32),
 807                                           &ap->tx_csm_dma);
 808         if (ap->tx_csm == NULL)
 809                 goto fail;
 810
 811         return 0;
 812
 813 fail:
 814         /* Clean up. */
 815         ace_init_cleanup(dev);
 816         return 1;
 817 }
 818
 819
 820 /*
 821  * Generic cleanup handling data allocated during init. Used when the
 822  * module is unloaded or if an error occurs during initialization
 823  */
 824 static void ace_init_cleanup(struct net_device *dev)
 825 {
 826         struct ace_private *ap;
 827
 828         ap = netdev_priv(dev);
 829
 830         ace_free_descriptors(dev);
 831
 832         if (ap->info)
 833                 pci_free_consistent(ap->pdev, sizeof(struct ace_info),
 834                                     ap->info, ap->info_dma);
 835         kfree(ap->skb);
 836         kfree(ap->trace_buf);
 837
 838         if (dev->irq)
 839                 free_irq(dev->irq, dev);
 840
 841         iounmap(ap->regs);
 842 }
 843
 844
 845 /*
 846  * Commands are considered to be slow.
 847  */
 848 static inline void ace_issue_cmd(struct ace_regs __iomem *regs, struct cmd *cmd)
 849 {
 850         u32 idx;
 851
 852         idx = readl(&regs->CmdPrd);
 853
 854         writel(*(u32 *)(cmd), &regs->CmdRng[idx]);
 855         idx = (idx + 1) % CMD_RING_ENTRIES;
 856
 857         writel(idx, &regs->CmdPrd);
 858 }
 859
 860
 861 static int ace_init(struct net_device *dev)
 862 {
 863         struct ace_private *ap;
 864         struct ace_regs __iomem *regs;
 865         struct ace_info *info = NULL;
 866         struct pci_dev *pdev;
 867         unsigned long myjif;
 868         u64 tmp_ptr;
 869         u32 tig_ver, mac1, mac2, tmp, pci_state;
 870         int board_idx, ecode = 0;
 871         short i;
 872         unsigned char cache_size;
 873
 874         ap = netdev_priv(dev);
 875         regs = ap->regs;
 876
 877         board_idx = ap->board_idx;
 878
 879         /*
 880          * aman@sgi.com - its useful to do a NIC reset here to
 881          * address the `Firmware not running' problem subsequent
 882          * to any crashes involving the NIC
 883          */
 884         writel(HW_RESET | (HW_RESET << 24), &regs->HostCtrl);
 885         readl(&regs->HostCtrl);         /* PCI write posting */
 886         udelay(5);
 887
 888         /*
 889          * Don't access any other registers before this point!
 890          */
 891 #ifdef __BIG_ENDIAN
 892         /*
 893          * This will most likely need BYTE_SWAP once we switch
 894          * to using __raw_writel()
 895          */
 896         writel((WORD_SWAP | CLR_INT | ((WORD_SWAP | CLR_INT) << 24)),
 897                &regs->HostCtrl);
 898 #else
 899         writel((CLR_INT | WORD_SWAP | ((CLR_INT | WORD_SWAP) << 24)),
 900                &regs->HostCtrl);
 901 #endif
 902         readl(&regs->HostCtrl);         /* PCI write posting */
 903
 904         /*
 905          * Stop the NIC CPU and clear pending interrupts
 906          */
 907         writel(readl(&regs->CpuCtrl) | CPU_HALT, &regs->CpuCtrl);
 908         readl(&regs->CpuCtrl);          /* PCI write posting */
 909         writel(0, &regs->Mb0Lo);
 910
 911         tig_ver = readl(&regs->HostCtrl) >> 28;
 912
 913         switch(tig_ver){
 914 #ifndef CONFIG_ACENIC_OMIT_TIGON_I
 915         case 4:
 916         case 5:
 917                 printk(KERN_INFO "  Tigon I  (Rev. %i), Firmware: %i.%i.%i, ",
 918                        tig_ver, ap->firmware_major, ap->firmware_minor,
 919                        ap->firmware_fix);
 920                 writel(0, &regs->LocalCtrl);
 921                 ap->version = 1;
 922                 ap->tx_ring_entries = TIGON_I_TX_RING_ENTRIES;
 923                 break;
 924 #endif
 925         case 6:
 926                 printk(KERN_INFO "  Tigon II (Rev. %i), Firmware: %i.%i.%i, ",
 927                        tig_ver, ap->firmware_major, ap->firmware_minor,
 928                        ap->firmware_fix);
 929                 writel(readl(&regs->CpuBCtrl) | CPU_HALT, &regs->CpuBCtrl);
 930                 readl(&regs->CpuBCtrl);         /* PCI write posting */
 931                 /*
 932                  * The SRAM bank size does _not_ indicate the amount
 933                  * of memory on the card, it controls the _bank_ size!
 934                  * Ie. a 1MB AceNIC will have two banks of 512KB.
 935                  */
 936                 writel(SRAM_BANK_512K, &regs->LocalCtrl);
 937                 writel(SYNC_SRAM_TIMING, &regs->MiscCfg);
 938                 ap->version = 2;
 939                 ap->tx_ring_entries = MAX_TX_RING_ENTRIES;
 940                 break;
 941         default:
 942                 printk(KERN_WARNING "  Unsupported Tigon version detected "
 943                        "(%i)\n", tig_ver);
 944                 ecode = -ENODEV;
 945                 goto init_error;
 946         }
 947
 948         /*
 949          * ModeStat _must_ be set after the SRAM settings as this change
 950          * seems to corrupt the ModeStat and possible other registers.
 951          * The SRAM settings survive resets and setting it to the same
 952          * value a second time works as well. This is what caused the
 953          * `Firmware not running' problem on the Tigon II.
 954          */
 955 #ifdef __BIG_ENDIAN
 956         writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL | ACE_BYTE_SWAP_BD |
 957                ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, &regs->ModeStat);
 958 #else
 959         writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL |
 960                ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, &regs->ModeStat);
 961 #endif
 962         readl(&regs->ModeStat);         /* PCI write posting */
 963
 964         mac1 = 0;
 965         for(i = 0; i < 4; i++) {
 966                 int t;
 967
 968                 mac1 = mac1 << 8;
 969                 t = read_eeprom_byte(dev, 0x8c+i);
 970                 if (t < 0) {
 971                         ecode = -EIO;
 972                         goto init_error;
 973                 } else
 974                         mac1 |= (t & 0xff);
 975         }
 976         mac2 = 0;
 977         for(i = 4; i < 8; i++) {
 978                 int t;
 979
 980                 mac2 = mac2 << 8;
 981                 t = read_eeprom_byte(dev, 0x8c+i);
 982                 if (t < 0) {
 983                         ecode = -EIO;
 984                         goto init_error;
 985                 } else
 986                         mac2 |= (t & 0xff);
 987         }
 988
 989         writel(mac1, &regs->MacAddrHi);
 990         writel(mac2, &regs->MacAddrLo);
 991
 992         dev->dev_addr[0] = (mac1 >> 8) & 0xff;
 993         dev->dev_addr[1] = mac1 & 0xff;
 994         dev->dev_addr[2] = (mac2 >> 24) & 0xff;
 995         dev->dev_addr[3] = (mac2 >> 16) & 0xff;
 996         dev->dev_addr[4] = (mac2 >> 8) & 0xff;
 997         dev->dev_addr[5] = mac2 & 0xff;
 998
 999         printk("MAC: %pM\n", dev->dev_addr);
1000
1001         /*
1002          * Looks like this is necessary to deal with on all architectures,
1003          * even this %$#%$# N440BX Intel based thing doesn't get it right.
1004          * Ie. having two NICs in the machine, one will have the cache
1005          * line set at boot time, the other will not.
1006          */
1007         pdev = ap->pdev;
1008         pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_size);
1009         cache_size <<= 2;
1010         if (cache_size != SMP_CACHE_BYTES) {
1011                 printk(KERN_INFO "  PCI cache line size set incorrectly "
1012                        "(%i bytes) by BIOS/FW, ", cache_size);
1013                 if (cache_size > SMP_CACHE_BYTES)
1014                         printk("expecting %i\n", SMP_CACHE_BYTES);
1015                 else {
1016                         printk("correcting to %i\n", SMP_CACHE_BYTES);
1017                         pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
1018                                               SMP_CACHE_BYTES >> 2);
1019                 }
1020         }
1021
1022         pci_state = readl(&regs->PciState);
1023         printk(KERN_INFO "  PCI bus width: %i bits, speed: %iMHz, "
1024                "latency: %i clks\n",
1025                 (pci_state & PCI_32BIT) ? 32 : 64,
1026                 (pci_state & PCI_66MHZ) ? 66 : 33,
1027                 ap->pci_latency);
1028
1029         /*
1030          * Set the max DMA transfer size. Seems that for most systems
1031          * the performance is better when no MAX parameter is
1032          * set. However for systems enabling PCI write and invalidate,
1033          * DMA writes must be set to the L1 cache line size to get
1034          * optimal performance.
1035          *
1036          * The default is now to turn the PCI write and invalidate off
1037          * - that is what Alteon does for NT.
1038          */
1039         tmp = READ_CMD_MEM | WRITE_CMD_MEM;
1040         if (ap->version >= 2) {
1041                 tmp |= (MEM_READ_MULTIPLE | (pci_state & PCI_66MHZ));
1042                 /*
1043                  * Tuning parameters only supported for 8 cards
1044                  */
1045                 if (board_idx == BOARD_IDX_OVERFLOW ||
1046                     dis_pci_mem_inval[board_idx]) {
1047                         if (ap->pci_command & PCI_COMMAND_INVALIDATE) {
1048                                 ap->pci_command &= ~PCI_COMMAND_INVALIDATE;
1049                                 pci_write_config_word(pdev, PCI_COMMAND,
1050                                                       ap->pci_command);
1051                                 printk(KERN_INFO "  Disabling PCI memory "
1052                                        "write and invalidate\n");
1053                         }
1054                 } else if (ap->pci_command & PCI_COMMAND_INVALIDATE) {
1055                         printk(KERN_INFO "  PCI memory write & invalidate "
1056                                "enabled by BIOS, enabling counter measures\n");
1057
1058                         switch(SMP_CACHE_BYTES) {
1059                         case 16:
1060                                 tmp |= DMA_WRITE_MAX_16;
1061                                 break;
1062                         case 32:
1063                                 tmp |= DMA_WRITE_MAX_32;
1064                                 break;
1065                         case 64:
1066                                 tmp |= DMA_WRITE_MAX_64;
1067                                 break;
1068                         case 128:
1069                                 tmp |= DMA_WRITE_MAX_128;
1070                                 break;
1071                         default:
1072                                 printk(KERN_INFO "  Cache line size %i not "
1073                                        "supported, PCI write and invalidate "
1074                                        "disabled\n", SMP_CACHE_BYTES);
1075                                 ap->pci_command &= ~PCI_COMMAND_INVALIDATE;
1076                                 pci_write_config_word(pdev, PCI_COMMAND,
1077                                                       ap->pci_command);
1078                         }
1079                 }
1080         }
1081
1082 #ifdef __sparc__
1083         /*
1084          * On this platform, we know what the best dma settings
1085          * are.  We use 64-byte maximum bursts, because if we
1086          * burst larger than the cache line size (or even cross
1087          * a 64byte boundary in a single burst) the UltraSparc
1088          * PCI controller will disconnect at 64-byte multiples.
1089          *
1090          * Read-multiple will be properly enabled above, and when
1091          * set will give the PCI controller proper hints about
1092          * prefetching.
1093          */
1094         tmp &= ~DMA_READ_WRITE_MASK;
1095         tmp |= DMA_READ_MAX_64;
1096         tmp |= DMA_WRITE_MAX_64;
1097 #endif
1098 #ifdef __alpha__
1099         tmp &= ~DMA_READ_WRITE_MASK;
1100         tmp |= DMA_READ_MAX_128;
1101         /*
1102          * All the docs say MUST NOT. Well, I did.
1103          * Nothing terrible happens, if we load wrong size.
1104          * Bit w&i still works better!
1105          */
1106         tmp |= DMA_WRITE_MAX_128;
1107 #endif
1108         writel(tmp, &regs->PciState);
1109
1110 #if 0
1111         /*
1112          * The Host PCI bus controller driver has to set FBB.
1113          * If all devices on that PCI bus support FBB, then the controller
1114          * can enable FBB support in the Host PCI Bus controller (or on
1115          * the PCI-PCI bridge if that applies).
1116          * -ggg
1117          */
1118         /*
1119          * I have received reports from people having problems when this
1120          * bit is enabled.
1121          */
1122         if (!(ap->pci_command & PCI_COMMAND_FAST_BACK)) {
1123                 printk(KERN_INFO "  Enabling PCI Fast Back to Back\n");
1124                 ap->pci_command |= PCI_COMMAND_FAST_BACK;
1125                 pci_write_config_word(pdev, PCI_COMMAND, ap->pci_command);
1126         }
1127 #endif
1128
1129         /*
1130          * Configure DMA attributes.
1131          */
1132         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
1133                 ap->pci_using_dac = 1;
1134         } else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
1135                 ap->pci_using_dac = 0;
1136         } else {
1137                 ecode = -ENODEV;
1138                 goto init_error;
1139         }
1140
1141         /*
1142          * Initialize the generic info block and the command+event rings
1143          * and the control blocks for the transmit and receive rings
1144          * as they need to be setup once and for all.
1145          */
1146         if (!(info = pci_alloc_consistent(ap->pdev, sizeof(struct ace_info),
1147                                           &ap->info_dma))) {
1148                 ecode = -EAGAIN;
1149                 goto init_error;
1150         }
1151         ap->info = info;
1152
1153         /*
1154          * Get the memory for the skb rings.
1155          */
1156         if (!(ap->skb = kmalloc(sizeof(struct ace_skb), GFP_KERNEL))) {
1157                 ecode = -EAGAIN;
1158                 goto init_error;
1159         }
1160
1161         ecode = request_irq(pdev->irq, ace_interrupt, IRQF_SHARED,
1162                             DRV_NAME, dev);
1163         if (ecode) {
1164                 printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
1165                        DRV_NAME, pdev->irq);
1166                 goto init_error;
1167         } else
1168                 dev->irq = pdev->irq;
1169
1170 #ifdef INDEX_DEBUG
1171         spin_lock_init(&ap->debug_lock);
1172         ap->last_tx = ACE_TX_RING_ENTRIES(ap) - 1;
1173         ap->last_std_rx = 0;
1174         ap->last_mini_rx = 0;
1175 #endif
1176
1177         memset(ap->info, 0, sizeof(struct ace_info));
1178         memset(ap->skb, 0, sizeof(struct ace_skb));
1179
1180         ecode = ace_load_firmware(dev);
1181         if (ecode)
1182                 goto init_error;
1183
1184         ap->fw_running = 0;
1185
1186         tmp_ptr = ap->info_dma;
1187         writel(tmp_ptr >> 32, &regs->InfoPtrHi);
1188         writel(tmp_ptr & 0xffffffff, &regs->InfoPtrLo);
1189
1190         memset(ap->evt_ring, 0, EVT_RING_ENTRIES * sizeof(struct event));
1191
1192         set_aceaddr(&info->evt_ctrl.rngptr, ap->evt_ring_dma);
1193         info->evt_ctrl.flags = 0;
1194
1195         *(ap->evt_prd) = 0;
1196         wmb();
1197         set_aceaddr(&info->evt_prd_ptr, ap->evt_prd_dma);
1198         writel(0, &regs->EvtCsm);
1199
1200         set_aceaddr(&info->cmd_ctrl.rngptr, 0x100);
1201         info->cmd_ctrl.flags = 0;
1202         info->cmd_ctrl.max_len = 0;
1203
1204         for (i = 0; i < CMD_RING_ENTRIES; i++)
1205                 writel(0, &regs->CmdRng[i]);
1206
1207         writel(0, &regs->CmdPrd);
1208         writel(0, &regs->CmdCsm);
1209
1210         tmp_ptr = ap->info_dma;
1211         tmp_ptr += (unsigned long) &(((struct ace_info *)0)->s.stats);
1212         set_aceaddr(&info->stats2_ptr, (dma_addr_t) tmp_ptr);
1213
1214         set_aceaddr(&info->rx_std_ctrl.rngptr, ap->rx_ring_base_dma);
1215         info->rx_std_ctrl.max_len = ACE_STD_BUFSIZE;
1216         info->rx_std_ctrl.flags =
1217           RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1218
1219         memset(ap->rx_std_ring, 0,
1220                RX_STD_RING_ENTRIES * sizeof(struct rx_desc));
1221
1222         for (i = 0; i < RX_STD_RING_ENTRIES; i++)
1223                 ap->rx_std_ring[i].flags = BD_FLG_TCP_UDP_SUM;
1224
1225         ap->rx_std_skbprd = 0;
1226         atomic_set(&ap->cur_rx_bufs, 0);
1227
1228         set_aceaddr(&info->rx_jumbo_ctrl.rngptr,
1229                     (ap->rx_ring_base_dma +
1230                      (sizeof(struct rx_desc) * RX_STD_RING_ENTRIES)));
1231         info->rx_jumbo_ctrl.max_len = 0;
1232         info->rx_jumbo_ctrl.flags =
1233           RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1234
1235         memset(ap->rx_jumbo_ring, 0,
1236                RX_JUMBO_RING_ENTRIES * sizeof(struct rx_desc));
1237
1238         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++)
1239                 ap->rx_jumbo_ring[i].flags = BD_FLG_TCP_UDP_SUM | BD_FLG_JUMBO;
1240
1241         ap->rx_jumbo_skbprd = 0;
1242         atomic_set(&ap->cur_jumbo_bufs, 0);
1243
1244         memset(ap->rx_mini_ring, 0,
1245                RX_MINI_RING_ENTRIES * sizeof(struct rx_desc));
1246
1247         if (ap->version >= 2) {
1248                 set_aceaddr(&info->rx_mini_ctrl.rngptr,
1249                             (ap->rx_ring_base_dma +
1250                              (sizeof(struct rx_desc) *
1251                               (RX_STD_RING_ENTRIES +
1252                                RX_JUMBO_RING_ENTRIES))));
1253                 info->rx_mini_ctrl.max_len = ACE_MINI_SIZE;
1254                 info->rx_mini_ctrl.flags =
1255                   RCB_FLG_TCP_UDP_SUM|RCB_FLG_NO_PSEUDO_HDR|RCB_FLG_VLAN_ASSIST;
1256
1257                 for (i = 0; i < RX_MINI_RING_ENTRIES; i++)
1258                         ap->rx_mini_ring[i].flags =
1259                                 BD_FLG_TCP_UDP_SUM | BD_FLG_MINI;
1260         } else {
1261                 set_aceaddr(&info->rx_mini_ctrl.rngptr, 0);
1262                 info->rx_mini_ctrl.flags = RCB_FLG_RNG_DISABLE;
1263                 info->rx_mini_ctrl.max_len = 0;
1264         }
1265
1266         ap->rx_mini_skbprd = 0;
1267         atomic_set(&ap->cur_mini_bufs, 0);
1268
1269         set_aceaddr(&info->rx_return_ctrl.rngptr,
1270                     (ap->rx_ring_base_dma +
1271                      (sizeof(struct rx_desc) *
1272                       (RX_STD_RING_ENTRIES +
1273                        RX_JUMBO_RING_ENTRIES +
1274                        RX_MINI_RING_ENTRIES))));
1275         info->rx_return_ctrl.flags = 0;
1276         info->rx_return_ctrl.max_len = RX_RETURN_RING_ENTRIES;
1277
1278         memset(ap->rx_return_ring, 0,
1279                RX_RETURN_RING_ENTRIES * sizeof(struct rx_desc));
1280
1281         set_aceaddr(&info->rx_ret_prd_ptr, ap->rx_ret_prd_dma);
1282         *(ap->rx_ret_prd) = 0;
1283
1284         writel(TX_RING_BASE, &regs->WinBase);
1285
1286         if (ACE_IS_TIGON_I(ap)) {
1287                 ap->tx_ring = (__force struct tx_desc *) regs->Window;
1288                 for (i = 0; i < (TIGON_I_TX_RING_ENTRIES
1289                                  * sizeof(struct tx_desc)) / sizeof(u32); i++)
1290                         writel(0, (__force void __iomem *)ap->tx_ring  + i * 4);
1291
1292                 set_aceaddr(&info->tx_ctrl.rngptr, TX_RING_BASE);
1293         } else {
1294                 memset(ap->tx_ring, 0,
1295                        MAX_TX_RING_ENTRIES * sizeof(struct tx_desc));
1296
1297                 set_aceaddr(&info->tx_ctrl.rngptr, ap->tx_ring_dma);
1298         }
1299
1300         info->tx_ctrl.max_len = ACE_TX_RING_ENTRIES(ap);
1301         tmp = RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1302
1303         /*
1304          * The Tigon I does not like having the TX ring in host memory ;-(
1305          */
1306         if (!ACE_IS_TIGON_I(ap))
1307                 tmp |= RCB_FLG_TX_HOST_RING;
1308 #if TX_COAL_INTS_ONLY
1309         tmp |= RCB_FLG_COAL_INT_ONLY;
1310 #endif
1311         info->tx_ctrl.flags = tmp;
1312
1313         set_aceaddr(&info->tx_csm_ptr, ap->tx_csm_dma);
1314
1315         /*
1316          * Potential item for tuning parameter
1317          */
1318 #if 0 /* NO */
1319         writel(DMA_THRESH_16W, &regs->DmaReadCfg);
1320         writel(DMA_THRESH_16W, &regs->DmaWriteCfg);
1321 #else
1322         writel(DMA_THRESH_8W, &regs->DmaReadCfg);
1323         writel(DMA_THRESH_8W, &regs->DmaWriteCfg);
1324 #endif
1325
1326         writel(0, &regs->MaskInt);
1327         writel(1, &regs->IfIdx);
1328 #if 0
1329         /*
1330          * McKinley boxes do not like us fiddling with AssistState
1331          * this early
1332          */
1333         writel(1, &regs->AssistState);
1334 #endif
1335
1336         writel(DEF_STAT, &regs->TuneStatTicks);
1337         writel(DEF_TRACE, &regs->TuneTrace);
1338
1339         ace_set_rxtx_parms(dev, 0);
1340
1341         if (board_idx == BOARD_IDX_OVERFLOW) {
1342                 printk(KERN_WARNING "%s: more than %i NICs detected, "
1343                        "ignoring module parameters!\n",
1344                        ap->name, ACE_MAX_MOD_PARMS);
1345         } else if (board_idx >= 0) {
1346                 if (tx_coal_tick[board_idx])
1347                         writel(tx_coal_tick[board_idx],
1348                                &regs->TuneTxCoalTicks);
1349                 if (max_tx_desc[board_idx])
1350                         writel(max_tx_desc[board_idx], &regs->TuneMaxTxDesc);
1351
1352                 if (rx_coal_tick[board_idx])
1353                         writel(rx_coal_tick[board_idx],
1354                                &regs->TuneRxCoalTicks);
1355                 if (max_rx_desc[board_idx])
1356                         writel(max_rx_desc[board_idx], &regs->TuneMaxRxDesc);
1357
1358                 if (trace[board_idx])
1359                         writel(trace[board_idx], &regs->TuneTrace);
1360
1361                 if ((tx_ratio[board_idx] > 0) && (tx_ratio[board_idx] < 64))
1362                         writel(tx_ratio[board_idx], &regs->TxBufRat);
1363         }
1364
1365         /*
1366          * Default link parameters
1367          */
1368         tmp = LNK_ENABLE | LNK_FULL_DUPLEX | LNK_1000MB | LNK_100MB |
1369                 LNK_10MB | LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL | LNK_NEGOTIATE;
1370         if(ap->version >= 2)
1371                 tmp |= LNK_TX_FLOW_CTL_Y;
1372
1373         /*
1374          * Override link default parameters
1375          */
1376         if ((board_idx >= 0) && link_state[board_idx]) {
1377                 int option = link_state[board_idx];
1378
1379                 tmp = LNK_ENABLE;
1380
1381                 if (option & 0x01) {
1382                         printk(KERN_INFO "%s: Setting half duplex link\n",
1383                                ap->name);
1384                         tmp &= ~LNK_FULL_DUPLEX;
1385                 }
1386                 if (option & 0x02)
1387                         tmp &= ~LNK_NEGOTIATE;
1388                 if (option & 0x10)
1389                         tmp |= LNK_10MB;
1390                 if (option & 0x20)
1391                         tmp |= LNK_100MB;
1392                 if (option & 0x40)
1393                         tmp |= LNK_1000MB;
1394                 if ((option & 0x70) == 0) {
1395                         printk(KERN_WARNING "%s: No media speed specified, "
1396                                "forcing auto negotiation\n", ap->name);
1397                         tmp |= LNK_NEGOTIATE | LNK_1000MB |
1398                                 LNK_100MB | LNK_10MB;
1399                 }
1400                 if ((option & 0x100) == 0)
1401                         tmp |= LNK_NEG_FCTL;
1402                 else
1403                         printk(KERN_INFO "%s: Disabling flow control "
1404                                "negotiation\n", ap->name);
1405                 if (option & 0x200)
1406                         tmp |= LNK_RX_FLOW_CTL_Y;
1407                 if ((option & 0x400) && (ap->version >= 2)) {
1408                         printk(KERN_INFO "%s: Enabling TX flow control\n",
1409                                ap->name);
1410                         tmp |= LNK_TX_FLOW_CTL_Y;
1411                 }
1412         }
1413
1414         ap->link = tmp;
1415         writel(tmp, &regs->TuneLink);
1416         if (ap->version >= 2)
1417                 writel(tmp, &regs->TuneFastLink);
1418
1419         writel(ap->firmware_start, &regs->Pc);
1420
1421         writel(0, &regs->Mb0Lo);
1422
1423         /*
1424          * Set tx_csm before we start receiving interrupts, otherwise
1425          * the interrupt handler might think it is supposed to process
1426          * tx ints before we are up and running, which may cause a null
1427          * pointer access in the int handler.
1428          */
1429         ap->cur_rx = 0;
1430         ap->tx_prd = *(ap->tx_csm) = ap->tx_ret_csm = 0;
1431
1432         wmb();
1433         ace_set_txprd(regs, ap, 0);
1434         writel(0, &regs->RxRetCsm);
1435
1436         /*
1437          * Enable DMA engine now.
1438          * If we do this sooner, Mckinley box pukes.
1439          * I assume it's because Tigon II DMA engine wants to check
1440          * *something* even before the CPU is started.
1441          */
1442         writel(1, &regs->AssistState);  /* enable DMA */
1443
1444         /*
1445          * Start the NIC CPU
1446          */
1447         writel(readl(&regs->CpuCtrl) & ~(CPU_HALT|CPU_TRACE), &regs->CpuCtrl);
1448         readl(&regs->CpuCtrl);
1449
1450         /*
1451          * Wait for the firmware to spin up - max 3 seconds.
1452          */
1453         myjif = jiffies + 3 * HZ;
1454         while (time_before(jiffies, myjif) && !ap->fw_running)
1455                 cpu_relax();
1456
1457         if (!ap->fw_running) {
1458                 printk(KERN_ERR "%s: Firmware NOT running!\n", ap->name);
1459
1460                 ace_dump_trace(ap);
1461                 writel(readl(&regs->CpuCtrl) | CPU_HALT, &regs->CpuCtrl);
1462                 readl(&regs->CpuCtrl);
1463
1464                 /* aman@sgi.com - account for badly behaving firmware/NIC:
1465                  * - have observed that the NIC may continue to generate
1466                  *   interrupts for some reason; attempt to stop it - halt
1467                  *   second CPU for Tigon II cards, and also clear Mb0
1468                  * - if we're a module, we'll fail to load if this was
1469                  *   the only GbE card in the system => if the kernel does
1470                  *   see an interrupt from the NIC, code to handle it is
1471                  *   gone and OOps! - so free_irq also
1472                  */
1473                 if (ap->version >= 2)
1474                         writel(readl(&regs->CpuBCtrl) | CPU_HALT,
1475                                &regs->CpuBCtrl);
1476                 writel(0, &regs->Mb0Lo);
1477                 readl(&regs->Mb0Lo);
1478
1479                 ecode = -EBUSY;
1480                 goto init_error;
1481         }
1482
1483         /*
1484          * We load the ring here as there seem to be no way to tell the
1485          * firmware to wipe the ring without re-initializing it.
1486          */
1487         if (!test_and_set_bit(0, &ap->std_refill_busy))
1488                 ace_load_std_rx_ring(dev, RX_RING_SIZE);
1489         else
1490                 printk(KERN_ERR "%s: Someone is busy refilling the RX ring\n",
1491                        ap->name);
1492         if (ap->version >= 2) {
1493                 if (!test_and_set_bit(0, &ap->mini_refill_busy))
1494                         ace_load_mini_rx_ring(dev, RX_MINI_SIZE);
1495                 else
1496                         printk(KERN_ERR "%s: Someone is busy refilling "
1497                                "the RX mini ring\n", ap->name);
1498         }
1499         return 0;
1500
1501  init_error:
1502         ace_init_cleanup(dev);
1503         return ecode;
1504 }
1505
1506
1507 static void ace_set_rxtx_parms(struct net_device *dev, int jumbo)
1508 {
1509         struct ace_private *ap = netdev_priv(dev);
1510         struct ace_regs __iomem *regs = ap->regs;
1511         int board_idx = ap->board_idx;
1512
1513         if (board_idx >= 0) {
1514                 if (!jumbo) {
1515                         if (!tx_coal_tick[board_idx])
1516                                 writel(DEF_TX_COAL, &regs->TuneTxCoalTicks);
1517                         if (!max_tx_desc[board_idx])
1518                                 writel(DEF_TX_MAX_DESC, &regs->TuneMaxTxDesc);
1519                         if (!rx_coal_tick[board_idx])
1520                                 writel(DEF_RX_COAL, &regs->TuneRxCoalTicks);
1521                         if (!max_rx_desc[board_idx])
1522                                 writel(DEF_RX_MAX_DESC, &regs->TuneMaxRxDesc);
1523                         if (!tx_ratio[board_idx])
1524                                 writel(DEF_TX_RATIO, &regs->TxBufRat);
1525                 } else {
1526                         if (!tx_coal_tick[board_idx])
1527                                 writel(DEF_JUMBO_TX_COAL,
1528                                        &regs->TuneTxCoalTicks);
1529                         if (!max_tx_desc[board_idx])
1530                                 writel(DEF_JUMBO_TX_MAX_DESC,
1531                                        &regs->TuneMaxTxDesc);
1532                         if (!rx_coal_tick[board_idx])
1533                                 writel(DEF_JUMBO_RX_COAL,
1534                                        &regs->TuneRxCoalTicks);
1535                         if (!max_rx_desc[board_idx])
1536                                 writel(DEF_JUMBO_RX_MAX_DESC,
1537                                        &regs->TuneMaxRxDesc);
1538                         if (!tx_ratio[board_idx])
1539                                 writel(DEF_JUMBO_TX_RATIO, &regs->TxBufRat);
1540                 }
1541         }
1542 }
1543
1544
1545 static void ace_watchdog(struct net_device *data)
1546 {
1547         struct net_device *dev = data;
1548         struct ace_private *ap = netdev_priv(dev);
1549         struct ace_regs __iomem *regs = ap->regs;
1550
1551         /*
1552          * We haven't received a stats update event for more than 2.5
1553          * seconds and there is data in the transmit queue, thus we
1554          * assume the card is stuck.
1555          */
1556         if (*ap->tx_csm != ap->tx_ret_csm) {
1557                 printk(KERN_WARNING "%s: Transmitter is stuck, %08x\n",
1558                        dev->name, (unsigned int)readl(&regs->HostCtrl));
1559                 /* This can happen due to ieee flow control. */
1560         } else {
1561                 printk(KERN_DEBUG "%s: BUG... transmitter died. Kicking it.\n",
1562                        dev->name);
1563 #if 0
1564                 netif_wake_queue(dev);
1565 #endif
1566         }
1567 }
1568
1569
1570 static void ace_tasklet(unsigned long arg)
1571 {
1572         struct net_device *dev = (struct net_device *) arg;
1573         struct ace_private *ap = netdev_priv(dev);
1574         int cur_size;
1575
1576         cur_size = atomic_read(&ap->cur_rx_bufs);
1577         if ((cur_size < RX_LOW_STD_THRES) &&
1578             !test_and_set_bit(0, &ap->std_refill_busy)) {
1579 #ifdef DEBUG
1580                 printk("refilling buffers (current %i)\n", cur_size);
1581 #endif
1582                 ace_load_std_rx_ring(dev, RX_RING_SIZE - cur_size);
1583         }
1584
1585         if (ap->version >= 2) {
1586                 cur_size = atomic_read(&ap->cur_mini_bufs);
1587                 if ((cur_size < RX_LOW_MINI_THRES) &&
1588                     !test_and_set_bit(0, &ap->mini_refill_busy)) {
1589 #ifdef DEBUG
1590                         printk("refilling mini buffers (current %i)\n",
1591                                cur_size);
1592 #endif
1593                         ace_load_mini_rx_ring(dev, RX_MINI_SIZE - cur_size);
1594                 }
1595         }
1596
1597         cur_size = atomic_read(&ap->cur_jumbo_bufs);
1598         if (ap->jumbo && (cur_size < RX_LOW_JUMBO_THRES) &&
1599             !test_and_set_bit(0, &ap->jumbo_refill_busy)) {
1600 #ifdef DEBUG
1601                 printk("refilling jumbo buffers (current %i)\n", cur_size);
1602 #endif
1603                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE - cur_size);
1604         }
1605         ap->tasklet_pending = 0;
1606 }
1607
1608
1609 /*
1610  * Copy the contents of the NIC's trace buffer to kernel memory.
1611  */
1612 static void ace_dump_trace(struct ace_private *ap)
1613 {
1614 #if 0
1615         if (!ap->trace_buf)
1616                 if (!(ap->trace_buf = kmalloc(ACE_TRACE_SIZE, GFP_KERNEL)))
1617                     return;
1618 #endif
1619 }
1620
1621
1622 /*
1623  * Load the standard rx ring.
1624  *
1625  * Loading rings is safe without holding the spin lock since this is
1626  * done only before the device is enabled, thus no interrupts are
1627  * generated and by the interrupt handler/tasklet handler.
1628  */
1629 static void ace_load_std_rx_ring(struct net_device *dev, int nr_bufs)
1630 {
1631         struct ace_private *ap = netdev_priv(dev);
1632         struct ace_regs __iomem *regs = ap->regs;
1633         short i, idx;
1634
1635
1636         prefetchw(&ap->cur_rx_bufs);
1637
1638         idx = ap->rx_std_skbprd;
1639
1640         for (i = 0; i < nr_bufs; i++) {
1641                 struct sk_buff *skb;
1642                 struct rx_desc *rd;
1643                 dma_addr_t mapping;
1644
1645                 skb = netdev_alloc_skb_ip_align(dev, ACE_STD_BUFSIZE);
1646                 if (!skb)
1647                         break;
1648
1649                 mapping = pci_map_page(ap->pdev, virt_to_page(skb->data),
1650                                        offset_in_page(skb->data),
1651                                        ACE_STD_BUFSIZE,
1652                                        PCI_DMA_FROMDEVICE);
1653                 ap->skb->rx_std_skbuff[idx].skb = skb;
1654                 dma_unmap_addr_set(&ap->skb->rx_std_skbuff[idx],
1655                                    mapping, mapping);
1656
1657                 rd = &ap->rx_std_ring[idx];
1658                 set_aceaddr(&rd->addr, mapping);
1659                 rd->size = ACE_STD_BUFSIZE;
1660                 rd->idx = idx;
1661                 idx = (idx + 1) % RX_STD_RING_ENTRIES;
1662         }
1663
1664         if (!i)
1665                 goto error_out;
1666
1667         atomic_add(i, &ap->cur_rx_bufs);
1668         ap->rx_std_skbprd = idx;
1669
1670         if (ACE_IS_TIGON_I(ap)) {
1671                 struct cmd cmd;
1672                 cmd.evt = C_SET_RX_PRD_IDX;
1673                 cmd.code = 0;
1674                 cmd.idx = ap->rx_std_skbprd;
1675                 ace_issue_cmd(regs, &cmd);
1676         } else {
1677                 writel(idx, &regs->RxStdPrd);
1678                 wmb();
1679         }
1680
1681  out:
1682         clear_bit(0, &ap->std_refill_busy);
1683         return;
1684
1685  error_out:
1686         printk(KERN_INFO "Out of memory when allocating "
1687                "standard receive buffers\n");
1688         goto out;
1689 }
1690
1691
1692 static void ace_load_mini_rx_ring(struct net_device *dev, int nr_bufs)
1693 {
1694         struct ace_private *ap = netdev_priv(dev);
1695         struct ace_regs __iomem *regs = ap->regs;
1696         short i, idx;
1697
1698         prefetchw(&ap->cur_mini_bufs);
1699
1700         idx = ap->rx_mini_skbprd;
1701         for (i = 0; i < nr_bufs; i++) {
1702                 struct sk_buff *skb;
1703                 struct rx_desc *rd;
1704                 dma_addr_t mapping;
1705
1706                 skb = netdev_alloc_skb_ip_align(dev, ACE_MINI_BUFSIZE);
1707                 if (!skb)
1708                         break;
1709
1710                 mapping = pci_map_page(ap->pdev, virt_to_page(skb->data),
1711                                        offset_in_page(skb->data),
1712                                        ACE_MINI_BUFSIZE,
1713                                        PCI_DMA_FROMDEVICE);
1714                 ap->skb->rx_mini_skbuff[idx].skb = skb;
1715                 dma_unmap_addr_set(&ap->skb->rx_mini_skbuff[idx],
1716                                    mapping, mapping);
1717
1718                 rd = &ap->rx_mini_ring[idx];
1719                 set_aceaddr(&rd->addr, mapping);
1720                 rd->size = ACE_MINI_BUFSIZE;
1721                 rd->idx = idx;
1722                 idx = (idx + 1) % RX_MINI_RING_ENTRIES;
1723         }
1724
1725         if (!i)
1726                 goto error_out;
1727
1728         atomic_add(i, &ap->cur_mini_bufs);
1729
1730         ap->rx_mini_skbprd = idx;
1731
1732         writel(idx, &regs->RxMiniPrd);
1733         wmb();
1734
1735  out:
1736         clear_bit(0, &ap->mini_refill_busy);
1737         return;
1738  error_out:
1739         printk(KERN_INFO "Out of memory when allocating "
1740                "mini receive buffers\n");
1741         goto out;
1742 }
1743
1744
1745 /*
1746  * Load the jumbo rx ring, this may happen at any time if the MTU
1747  * is changed to a value > 1500.
1748  */
1749 static void ace_load_jumbo_rx_ring(struct net_device *dev, int nr_bufs)
1750 {
1751         struct ace_private *ap = netdev_priv(dev);
1752         struct ace_regs __iomem *regs = ap->regs;
1753         short i, idx;
1754
1755         idx = ap->rx_jumbo_skbprd;
1756
1757         for (i = 0; i < nr_bufs; i++) {
1758                 struct sk_buff *skb;
1759                 struct rx_desc *rd;
1760                 dma_addr_t mapping;
1761
1762                 skb = netdev_alloc_skb_ip_align(dev, ACE_JUMBO_BUFSIZE);
1763                 if (!skb)
1764                         break;
1765
1766                 mapping = pci_map_page(ap->pdev, virt_to_page(skb->data),
1767                                        offset_in_page(skb->data),
1768                                        ACE_JUMBO_BUFSIZE,
1769                                        PCI_DMA_FROMDEVICE);
1770                 ap->skb->rx_jumbo_skbuff[idx].skb = skb;
1771                 dma_unmap_addr_set(&ap->skb->rx_jumbo_skbuff[idx],
1772                                    mapping, mapping);
1773
1774                 rd = &ap->rx_jumbo_ring[idx];
1775                 set_aceaddr(&rd->addr, mapping);
1776                 rd->size = ACE_JUMBO_BUFSIZE;
1777                 rd->idx = idx;
1778                 idx = (idx + 1) % RX_JUMBO_RING_ENTRIES;
1779         }
1780
1781         if (!i)
1782                 goto error_out;
1783
1784         atomic_add(i, &ap->cur_jumbo_bufs);
1785         ap->rx_jumbo_skbprd = idx;
1786
1787         if (ACE_IS_TIGON_I(ap)) {
1788                 struct cmd cmd;
1789                 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1790                 cmd.code = 0;
1791                 cmd.idx = ap->rx_jumbo_skbprd;
1792                 ace_issue_cmd(regs, &cmd);
1793         } else {
1794                 writel(idx, &regs->RxJumboPrd);
1795                 wmb();
1796         }
1797
1798  out:
1799         clear_bit(0, &ap->jumbo_refill_busy);
1800         return;
1801  error_out:
1802         if (net_ratelimit())
1803                 printk(KERN_INFO "Out of memory when allocating "
1804                        "jumbo receive buffers\n");
1805         goto out;
1806 }
1807
1808
1809 /*
1810  * All events are considered to be slow (RX/TX ints do not generate
1811  * events) and are handled here, outside the main interrupt handler,
1812  * to reduce the size of the handler.
1813  */
1814 static u32 ace_handle_event(struct net_device *dev, u32 evtcsm, u32 evtprd)
1815 {
1816         struct ace_private *ap;
1817
1818         ap = netdev_priv(dev);
1819
1820         while (evtcsm != evtprd) {
1821                 switch (ap->evt_ring[evtcsm].evt) {
1822                 case E_FW_RUNNING:
1823                         printk(KERN_INFO "%s: Firmware up and running\n",
1824                                ap->name);
1825                         ap->fw_running = 1;
1826                         wmb();
1827                         break;
1828                 case E_STATS_UPDATED:
1829                         break;
1830                 case E_LNK_STATE:
1831                 {
1832                         u16 code = ap->evt_ring[evtcsm].code;
1833                         switch (code) {
1834                         case E_C_LINK_UP:
1835                         {
1836                                 u32 state = readl(&ap->regs->GigLnkState);
1837                                 printk(KERN_WARNING "%s: Optical link UP "
1838                                        "(%s Duplex, Flow Control: %s%s)\n",
1839                                        ap->name,
1840                                        state & LNK_FULL_DUPLEX ? "Full":"Half",
1841                                        state & LNK_TX_FLOW_CTL_Y ? "TX " : "",
1842                                        state & LNK_RX_FLOW_CTL_Y ? "RX" : "");
1843                                 break;
1844                         }
1845                         case E_C_LINK_DOWN:
1846                                 printk(KERN_WARNING "%s: Optical link DOWN\n",
1847                                        ap->name);
1848                                 break;
1849                         case E_C_LINK_10_100:
1850                                 printk(KERN_WARNING "%s: 10/100BaseT link "
1851                                        "UP\n", ap->name);
1852                                 break;
1853                         default:
1854                                 printk(KERN_ERR "%s: Unknown optical link "
1855                                        "state %02x\n", ap->name, code);
1856                         }
1857                         break;
1858                 }
1859                 case E_ERROR:
1860                         switch(ap->evt_ring[evtcsm].code) {
1861                         case E_C_ERR_INVAL_CMD:
1862                                 printk(KERN_ERR "%s: invalid command error\n",
1863                                        ap->name);
1864                                 break;
1865                         case E_C_ERR_UNIMP_CMD:
1866                                 printk(KERN_ERR "%s: unimplemented command "
1867                                        "error\n", ap->name);
1868                                 break;
1869                         case E_C_ERR_BAD_CFG:
1870                                 printk(KERN_ERR "%s: bad config error\n",
1871                                        ap->name);
1872                                 break;
1873                         default:
1874                                 printk(KERN_ERR "%s: unknown error %02x\n",
1875                                        ap->name, ap->evt_ring[evtcsm].code);
1876                         }
1877                         break;
1878                 case E_RESET_JUMBO_RNG:
1879                 {
1880                         int i;
1881                         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
1882                                 if (ap->skb->rx_jumbo_skbuff[i].skb) {
1883                                         ap->rx_jumbo_ring[i].size = 0;
1884                                         set_aceaddr(&ap->rx_jumbo_ring[i].addr, 0);
1885                                         dev_kfree_skb(ap->skb->rx_jumbo_skbuff[i].skb);
1886                                         ap->skb->rx_jumbo_skbuff[i].skb = NULL;
1887                                 }
1888                         }
1889
1890                         if (ACE_IS_TIGON_I(ap)) {
1891                                 struct cmd cmd;
1892                                 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1893                                 cmd.code = 0;
1894                                 cmd.idx = 0;
1895                                 ace_issue_cmd(ap->regs, &cmd);
1896                         } else {
1897                                 writel(0, &((ap->regs)->RxJumboPrd));
1898                                 wmb();
1899                         }
1900
1901                         ap->jumbo = 0;
1902                         ap->rx_jumbo_skbprd = 0;
1903                         printk(KERN_INFO "%s: Jumbo ring flushed\n",
1904                                ap->name);
1905                         clear_bit(0, &ap->jumbo_refill_busy);
1906                         break;
1907                 }
1908                 default:
1909                         printk(KERN_ERR "%s: Unhandled event 0x%02x\n",
1910                                ap->name, ap->evt_ring[evtcsm].evt);
1911                 }
1912                 evtcsm = (evtcsm + 1) % EVT_RING_ENTRIES;
1913         }
1914
1915         return evtcsm;
1916 }
1917
1918
1919 static void ace_rx_int(struct net_device *dev, u32 rxretprd, u32 rxretcsm)
1920 {
1921         struct ace_private *ap = netdev_priv(dev);
1922         u32 idx;
1923         int mini_count = 0, std_count = 0;
1924
1925         idx = rxretcsm;
1926
1927         prefetchw(&ap->cur_rx_bufs);
1928         prefetchw(&ap->cur_mini_bufs);
1929
1930         while (idx != rxretprd) {
1931                 struct ring_info *rip;
1932                 struct sk_buff *skb;
1933                 struct rx_desc *retdesc;
1934                 u32 skbidx;
1935                 int bd_flags, desc_type, mapsize;
1936                 u16 csum;
1937
1938
1939                 /* make sure the rx descriptor isn't read before rxretprd */
1940                 if (idx == rxretcsm)
1941                         rmb();
1942
1943                 retdesc = &ap->rx_return_ring[idx];
1944                 skbidx = retdesc->idx;
1945                 bd_flags = retdesc->flags;
1946                 desc_type = bd_flags & (BD_FLG_JUMBO | BD_FLG_MINI);
1947
1948                 switch(desc_type) {
1949                         /*
1950                          * Normal frames do not have any flags set
1951                          *
1952                          * Mini and normal frames arrive frequently,
1953                          * so use a local counter to avoid doing
1954                          * atomic operations for each packet arriving.
1955                          */
1956                 case 0:
1957                         rip = &ap->skb->rx_std_skbuff[skbidx];
1958                         mapsize = ACE_STD_BUFSIZE;
1959                         std_count++;
1960                         break;
1961                 case BD_FLG_JUMBO:
1962                         rip = &ap->skb->rx_jumbo_skbuff[skbidx];
1963                         mapsize = ACE_JUMBO_BUFSIZE;
1964                         atomic_dec(&ap->cur_jumbo_bufs);
1965                         break;
1966                 case BD_FLG_MINI:
1967                         rip = &ap->skb->rx_mini_skbuff[skbidx];
1968                         mapsize = ACE_MINI_BUFSIZE;
1969                         mini_count++;
1970                         break;
1971                 default:
1972                         printk(KERN_INFO "%s: unknown frame type (0x%02x) "
1973                                "returned by NIC\n", dev->name,
1974                                retdesc->flags);
1975                         goto error;
1976                 }
1977
1978                 skb = rip->skb;
1979                 rip->skb = NULL;
1980                 pci_unmap_page(ap->pdev,
1981                                dma_unmap_addr(rip, mapping),
1982                                mapsize,
1983                                PCI_DMA_FROMDEVICE);
1984                 skb_put(skb, retdesc->size);
1985
1986                 /*
1987                  * Fly baby, fly!
1988                  */
1989                 csum = retdesc->tcp_udp_csum;
1990
1991                 skb->protocol = eth_type_trans(skb, dev);
1992
1993                 /*
1994                  * Instead of forcing the poor tigon mips cpu to calculate
1995                  * pseudo hdr checksum, we do this ourselves.
1996                  */
1997                 if (bd_flags & BD_FLG_TCP_UDP_SUM) {
1998                         skb->csum = htons(csum);
1999                         skb->ip_summed = CHECKSUM_COMPLETE;
2000                 } else {
2001                         skb_checksum_none_assert(skb);
2002                 }
2003
2004                 /* send it up */
2005                 if ((bd_flags & BD_FLG_VLAN_TAG))
2006                         __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), retdesc->vlan);
2007                 netif_rx(skb);
2008
2009                 dev->stats.rx_packets++;
2010                 dev->stats.rx_bytes += retdesc->size;
2011
2012                 idx = (idx + 1) % RX_RETURN_RING_ENTRIES;
2013         }
2014
2015         atomic_sub(std_count, &ap->cur_rx_bufs);
2016         if (!ACE_IS_TIGON_I(ap))
2017                 atomic_sub(mini_count, &ap->cur_mini_bufs);
2018
2019  out:
2020         /*
2021          * According to the documentation RxRetCsm is obsolete with
2022          * the 12.3.x Firmware - my Tigon I NICs seem to disagree!
2023          */
2024         if (ACE_IS_TIGON_I(ap)) {
2025                 writel(idx, &ap->regs->RxRetCsm);
2026         }
2027         ap->cur_rx = idx;
2028
2029         return;
2030  error:
2031         idx = rxretprd;
2032         goto out;
2033 }
2034
2035
2036 static inline void ace_tx_int(struct net_device *dev,
2037                               u32 txcsm, u32 idx)
2038 {
2039         struct ace_private *ap = netdev_priv(dev);
2040
2041         do {
2042                 struct sk_buff *skb;
2043                 struct tx_ring_info *info;
2044
2045                 info = ap->skb->tx_skbuff + idx;
2046                 skb = info->skb;
2047
2048                 if (dma_unmap_len(info, maplen)) {
2049                         pci_unmap_page(ap->pdev, dma_unmap_addr(info, mapping),
2050                                        dma_unmap_len(info, maplen),
2051                                        PCI_DMA_TODEVICE);
2052                         dma_unmap_len_set(info, maplen, 0);
2053                 }
2054
2055                 if (skb) {
2056                         dev->stats.tx_packets++;
2057                         dev->stats.tx_bytes += skb->len;
2058                         dev_consume_skb_irq(skb);
2059                         info->skb = NULL;
2060                 }
2061
2062                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2063         } while (idx != txcsm);
2064
2065         if (netif_queue_stopped(dev))
2066                 netif_wake_queue(dev);
2067
2068         wmb();
2069         ap->tx_ret_csm = txcsm;
2070
2071         /* So... tx_ret_csm is advanced _after_ check for device wakeup.
2072          *
2073          * We could try to make it before. In this case we would get
2074          * the following race condition: hard_start_xmit on other cpu
2075          * enters after we advanced tx_ret_csm and fills space,
2076          * which we have just freed, so that we make illegal device wakeup.
2077          * There is no good way to workaround this (at entry
2078          * to ace_start_xmit detects this condition and prevents
2079          * ring corruption, but it is not a good workaround.)
2080          *
2081          * When tx_ret_csm is advanced after, we wake up device _only_
2082          * if we really have some space in ring (though the core doing
2083          * hard_start_xmit can see full ring for some period and has to
2084          * synchronize.) Superb.
2085          * BUT! We get another subtle race condition. hard_start_xmit
2086          * may think that ring is full between wakeup and advancing
2087          * tx_ret_csm and will stop device instantly! It is not so bad.
2088          * We are guaranteed that there is something in ring, so that
2089          * the next irq will resume transmission. To speedup this we could
2090          * mark descriptor, which closes ring with BD_FLG_COAL_NOW
2091          * (see ace_start_xmit).
2092          *
2093          * Well, this dilemma exists in all lock-free devices.
2094          * We, following scheme used in drivers by Donald Becker,
2095          * select the least dangerous.
2096          *                                                      --ANK
2097          */
2098 }
2099
2100
2101 static irqreturn_t ace_interrupt(int irq, void *dev_id)
2102 {
2103         struct net_device *dev = (struct net_device *)dev_id;
2104         struct ace_private *ap = netdev_priv(dev);
2105         struct ace_regs __iomem *regs = ap->regs;
2106         u32 idx;
2107         u32 txcsm, rxretcsm, rxretprd;
2108         u32 evtcsm, evtprd;
2109
2110         /*
2111          * In case of PCI shared interrupts or spurious interrupts,
2112          * we want to make sure it is actually our interrupt before
2113          * spending any time in here.
2114          */
2115         if (!(readl(&regs->HostCtrl) & IN_INT))
2116                 return IRQ_NONE;
2117
2118         /*
2119          * ACK intr now. Otherwise we will lose updates to rx_ret_prd,
2120          * which happened _after_ rxretprd = *ap->rx_ret_prd; but before
2121          * writel(0, &regs->Mb0Lo).
2122          *
2123          * "IRQ avoidance" recommended in docs applies to IRQs served
2124          * threads and it is wrong even for that case.
2125          */
2126         writel(0, &regs->Mb0Lo);
2127         readl(&regs->Mb0Lo);
2128
2129         /*
2130          * There is no conflict between transmit handling in
2131          * start_xmit and receive processing, thus there is no reason
2132          * to take a spin lock for RX handling. Wait until we start
2133          * working on the other stuff - hey we don't need a spin lock
2134          * anymore.
2135          */
2136         rxretprd = *ap->rx_ret_prd;
2137         rxretcsm = ap->cur_rx;
2138
2139         if (rxretprd != rxretcsm)
2140                 ace_rx_int(dev, rxretprd, rxretcsm);
2141
2142         txcsm = *ap->tx_csm;
2143         idx = ap->tx_ret_csm;
2144
2145         if (txcsm != idx) {
2146                 /*
2147                  * If each skb takes only one descriptor this check degenerates
2148                  * to identity, because new space has just been opened.
2149                  * But if skbs are fragmented we must check that this index
2150                  * update releases enough of space, otherwise we just
2151                  * wait for device to make more work.
2152                  */
2153                 if (!tx_ring_full(ap, txcsm, ap->tx_prd))
2154                         ace_tx_int(dev, txcsm, idx);
2155         }
2156
2157         evtcsm = readl(&regs->EvtCsm);
2158         evtprd = *ap->evt_prd;
2159
2160         if (evtcsm != evtprd) {
2161                 evtcsm = ace_handle_event(dev, evtcsm, evtprd);
2162                 writel(evtcsm, &regs->EvtCsm);
2163         }
2164
2165         /*
2166          * This has to go last in the interrupt handler and run with
2167          * the spin lock released ... what lock?
2168          */
2169         if (netif_running(dev)) {
2170                 int cur_size;
2171                 int run_tasklet = 0;
2172
2173                 cur_size = atomic_read(&ap->cur_rx_bufs);
2174                 if (cur_size < RX_LOW_STD_THRES) {
2175                         if ((cur_size < RX_PANIC_STD_THRES) &&
2176                             !test_and_set_bit(0, &ap->std_refill_busy)) {
2177 #ifdef DEBUG
2178                                 printk("low on std buffers %i\n", cur_size);
2179 #endif
2180                                 ace_load_std_rx_ring(dev,
2181                                                      RX_RING_SIZE - cur_size);
2182                         } else
2183                                 run_tasklet = 1;
2184                 }
2185
2186                 if (!ACE_IS_TIGON_I(ap)) {
2187                         cur_size = atomic_read(&ap->cur_mini_bufs);
2188                         if (cur_size < RX_LOW_MINI_THRES) {
2189                                 if ((cur_size < RX_PANIC_MINI_THRES) &&
2190                                     !test_and_set_bit(0,
2191                                                       &ap->mini_refill_busy)) {
2192 #ifdef DEBUG
2193                                         printk("low on mini buffers %i\n",
2194                                                cur_size);
2195 #endif
2196                                         ace_load_mini_rx_ring(dev,
2197                                                               RX_MINI_SIZE - cur_size);
2198                                 } else
2199                                         run_tasklet = 1;
2200                         }
2201                 }
2202
2203                 if (ap->jumbo) {
2204                         cur_size = atomic_read(&ap->cur_jumbo_bufs);
2205                         if (cur_size < RX_LOW_JUMBO_THRES) {
2206                                 if ((cur_size < RX_PANIC_JUMBO_THRES) &&
2207                                     !test_and_set_bit(0,
2208                                                       &ap->jumbo_refill_busy)){
2209 #ifdef DEBUG
2210                                         printk("low on jumbo buffers %i\n",
2211                                                cur_size);
2212 #endif
2213                                         ace_load_jumbo_rx_ring(dev,
2214                                                                RX_JUMBO_SIZE - cur_size);
2215                                 } else
2216                                         run_tasklet = 1;
2217                         }
2218                 }
2219                 if (run_tasklet && !ap->tasklet_pending) {
2220                         ap->tasklet_pending = 1;
2221                         tasklet_schedule(&ap->ace_tasklet);
2222                 }
2223         }
2224
2225         return IRQ_HANDLED;
2226 }
2227
2228 static int ace_open(struct net_device *dev)
2229 {
2230         struct ace_private *ap = netdev_priv(dev);
2231         struct ace_regs __iomem *regs = ap->regs;
2232         struct cmd cmd;
2233
2234         if (!(ap->fw_running)) {
2235                 printk(KERN_WARNING "%s: Firmware not running!\n", dev->name);
2236                 return -EBUSY;
2237         }
2238
2239         writel(dev->mtu + ETH_HLEN + 4, &regs->IfMtu);
2240
2241         cmd.evt = C_CLEAR_STATS;
2242         cmd.code = 0;
2243         cmd.idx = 0;
2244         ace_issue_cmd(regs, &cmd);
2245
2246         cmd.evt = C_HOST_STATE;
2247         cmd.code = C_C_STACK_UP;
2248         cmd.idx = 0;
2249         ace_issue_cmd(regs, &cmd);
2250
2251         if (ap->jumbo &&
2252             !test_and_set_bit(0, &ap->jumbo_refill_busy))
2253                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2254
2255         if (dev->flags & IFF_PROMISC) {
2256                 cmd.evt = C_SET_PROMISC_MODE;
2257                 cmd.code = C_C_PROMISC_ENABLE;
2258                 cmd.idx = 0;
2259                 ace_issue_cmd(regs, &cmd);
2260
2261                 ap->promisc = 1;
2262         }else
2263                 ap->promisc = 0;
2264         ap->mcast_all = 0;
2265
2266 #if 0
2267         cmd.evt = C_LNK_NEGOTIATION;
2268         cmd.code = 0;
2269         cmd.idx = 0;
2270         ace_issue_cmd(regs, &cmd);
2271 #endif
2272
2273         netif_start_queue(dev);
2274
2275         /*
2276          * Setup the bottom half rx ring refill handler
2277          */
2278         tasklet_init(&ap->ace_tasklet, ace_tasklet, (unsigned long)dev);
2279         return 0;
2280 }
2281
2282
2283 static int ace_close(struct net_device *dev)
2284 {
2285         struct ace_private *ap = netdev_priv(dev);
2286         struct ace_regs __iomem *regs = ap->regs;
2287         struct cmd cmd;
2288         unsigned long flags;
2289         short i;
2290
2291         /*
2292          * Without (or before) releasing irq and stopping hardware, this
2293          * is an absolute non-sense, by the way. It will be reset instantly
2294          * by the first irq.
2295          */
2296         netif_stop_queue(dev);
2297
2298
2299         if (ap->promisc) {
2300                 cmd.evt = C_SET_PROMISC_MODE;
2301                 cmd.code = C_C_PROMISC_DISABLE;
2302                 cmd.idx = 0;
2303                 ace_issue_cmd(regs, &cmd);
2304                 ap->promisc = 0;
2305         }
2306
2307         cmd.evt = C_HOST_STATE;
2308         cmd.code = C_C_STACK_DOWN;
2309         cmd.idx = 0;
2310         ace_issue_cmd(regs, &cmd);
2311
2312         tasklet_kill(&ap->ace_tasklet);
2313
2314         /*
2315          * Make sure one CPU is not processing packets while
2316          * buffers are being released by another.
2317          */
2318
2319         local_irq_save(flags);
2320         ace_mask_irq(dev);
2321
2322         for (i = 0; i < ACE_TX_RING_ENTRIES(ap); i++) {
2323                 struct sk_buff *skb;
2324                 struct tx_ring_info *info;
2325
2326                 info = ap->skb->tx_skbuff + i;
2327                 skb = info->skb;
2328
2329                 if (dma_unmap_len(info, maplen)) {
2330                         if (ACE_IS_TIGON_I(ap)) {
2331                                 /* NB: TIGON_1 is special, tx_ring is in io space */
2332                                 struct tx_desc __iomem *tx;
2333                                 tx = (__force struct tx_desc __iomem *) &ap->tx_ring[i];
2334                                 writel(0, &tx->addr.addrhi);
2335                                 writel(0, &tx->addr.addrlo);
2336                                 writel(0, &tx->flagsize);
2337                         } else
2338                                 memset(ap->tx_ring + i, 0,
2339                                        sizeof(struct tx_desc));
2340                         pci_unmap_page(ap->pdev, dma_unmap_addr(info, mapping),
2341                                        dma_unmap_len(info, maplen),
2342                                        PCI_DMA_TODEVICE);
2343                         dma_unmap_len_set(info, maplen, 0);
2344                 }
2345                 if (skb) {
2346                         dev_kfree_skb(skb);
2347                         info->skb = NULL;
2348                 }
2349         }
2350
2351         if (ap->jumbo) {
2352                 cmd.evt = C_RESET_JUMBO_RNG;
2353                 cmd.code = 0;
2354                 cmd.idx = 0;
2355                 ace_issue_cmd(regs, &cmd);
2356         }
2357
2358         ace_unmask_irq(dev);
2359         local_irq_restore(flags);
2360
2361         return 0;
2362 }
2363
2364
2365 static inline dma_addr_t
2366 ace_map_tx_skb(struct ace_private *ap, struct sk_buff *skb,
2367                struct sk_buff *tail, u32 idx)
2368 {
2369         dma_addr_t mapping;
2370         struct tx_ring_info *info;
2371
2372         mapping = pci_map_page(ap->pdev, virt_to_page(skb->data),
2373                                offset_in_page(skb->data),
2374                                skb->len, PCI_DMA_TODEVICE);
2375
2376         info = ap->skb->tx_skbuff + idx;
2377         info->skb = tail;
2378         dma_unmap_addr_set(info, mapping, mapping);
2379         dma_unmap_len_set(info, maplen, skb->len);
2380         return mapping;
2381 }
2382
2383
2384 static inline void
2385 ace_load_tx_bd(struct ace_private *ap, struct tx_desc *desc, u64 addr,
2386                u32 flagsize, u32 vlan_tag)
2387 {
2388 #if !USE_TX_COAL_NOW
2389         flagsize &= ~BD_FLG_COAL_NOW;
2390 #endif
2391
2392         if (ACE_IS_TIGON_I(ap)) {
2393                 struct tx_desc __iomem *io = (__force struct tx_desc __iomem *) desc;
2394                 writel(addr >> 32, &io->addr.addrhi);
2395                 writel(addr & 0xffffffff, &io->addr.addrlo);
2396                 writel(flagsize, &io->flagsize);
2397                 writel(vlan_tag, &io->vlanres);
2398         } else {
2399                 desc->addr.addrhi = addr >> 32;
2400                 desc->addr.addrlo = addr;
2401                 desc->flagsize = flagsize;
2402                 desc->vlanres = vlan_tag;
2403         }
2404 }
2405
2406
2407 static netdev_tx_t ace_start_xmit(struct sk_buff *skb,
2408                                   struct net_device *dev)
2409 {
2410         struct ace_private *ap = netdev_priv(dev);
2411         struct ace_regs __iomem *regs = ap->regs;
2412         struct tx_desc *desc;
2413         u32 idx, flagsize;
2414         unsigned long maxjiff = jiffies + 3*HZ;
2415
2416 restart:
2417         idx = ap->tx_prd;
2418
2419         if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2420                 goto overflow;
2421
2422         if (!skb_shinfo(skb)->nr_frags) {
2423                 dma_addr_t mapping;
2424                 u32 vlan_tag = 0;
2425
2426                 mapping = ace_map_tx_skb(ap, skb, skb, idx);
2427                 flagsize = (skb->len << 16) | (BD_FLG_END);
2428                 if (skb->ip_summed == CHECKSUM_PARTIAL)
2429                         flagsize |= BD_FLG_TCP_UDP_SUM;
2430                 if (skb_vlan_tag_present(skb)) {
2431                         flagsize |= BD_FLG_VLAN_TAG;
2432                         vlan_tag = skb_vlan_tag_get(skb);
2433                 }
2434                 desc = ap->tx_ring + idx;
2435                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2436
2437                 /* Look at ace_tx_int for explanations. */
2438                 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2439                         flagsize |= BD_FLG_COAL_NOW;
2440
2441                 ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2442         } else {
2443                 dma_addr_t mapping;
2444                 u32 vlan_tag = 0;
2445                 int i, len = 0;
2446
2447                 mapping = ace_map_tx_skb(ap, skb, NULL, idx);
2448                 flagsize = (skb_headlen(skb) << 16);
2449                 if (skb->ip_summed == CHECKSUM_PARTIAL)
2450                         flagsize |= BD_FLG_TCP_UDP_SUM;
2451                 if (skb_vlan_tag_present(skb)) {
2452                         flagsize |= BD_FLG_VLAN_TAG;
2453                         vlan_tag = skb_vlan_tag_get(skb);
2454                 }
2455
2456                 ace_load_tx_bd(ap, ap->tx_ring + idx, mapping, flagsize, vlan_tag);
2457
2458                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2459
2460                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2461                         const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2462                         struct tx_ring_info *info;
2463
2464                         len += skb_frag_size(frag);
2465                         info = ap->skb->tx_skbuff + idx;
2466                         desc = ap->tx_ring + idx;
2467
2468                         mapping = skb_frag_dma_map(&ap->pdev->dev, frag, 0,
2469                                                    skb_frag_size(frag),
2470                                                    DMA_TO_DEVICE);
2471
2472                         flagsize = skb_frag_size(frag) << 16;
2473                         if (skb->ip_summed == CHECKSUM_PARTIAL)
2474                                 flagsize |= BD_FLG_TCP_UDP_SUM;
2475                         idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2476
2477                         if (i == skb_shinfo(skb)->nr_frags - 1) {
2478                                 flagsize |= BD_FLG_END;
2479                                 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2480                                         flagsize |= BD_FLG_COAL_NOW;
2481
2482                                 /*
2483                                  * Only the last fragment frees
2484                                  * the skb!
2485                                  */
2486                                 info->skb = skb;
2487                         } else {
2488                                 info->skb = NULL;
2489                         }
2490                         dma_unmap_addr_set(info, mapping, mapping);
2491                         dma_unmap_len_set(info, maplen, skb_frag_size(frag));
2492                         ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2493                 }
2494         }
2495
2496         wmb();
2497         ap->tx_prd = idx;
2498         ace_set_txprd(regs, ap, idx);
2499
2500         if (flagsize & BD_FLG_COAL_NOW) {
2501                 netif_stop_queue(dev);
2502
2503                 /*
2504                  * A TX-descriptor producer (an IRQ) might have gotten
2505                  * between, making the ring free again. Since xmit is
2506                  * serialized, this is the only situation we have to
2507                  * re-test.
2508                  */
2509                 if (!tx_ring_full(ap, ap->tx_ret_csm, idx))
2510                         netif_wake_queue(dev);
2511         }
2512
2513         return NETDEV_TX_OK;
2514
2515 overflow:
2516         /*
2517          * This race condition is unavoidable with lock-free drivers.
2518          * We wake up the queue _before_ tx_prd is advanced, so that we can
2519          * enter hard_start_xmit too early, while tx ring still looks closed.
2520          * This happens ~1-4 times per 100000 packets, so that we can allow
2521          * to loop syncing to other CPU. Probably, we need an additional
2522          * wmb() in ace_tx_intr as well.
2523          *
2524          * Note that this race is relieved by reserving one more entry
2525          * in tx ring than it is necessary (see original non-SG driver).
2526          * However, with SG we need to reserve 2*MAX_SKB_FRAGS+1, which
2527          * is already overkill.
2528          *
2529          * Alternative is to return with 1 not throttling queue. In this
2530          * case loop becomes longer, no more useful effects.
2531          */
2532         if (time_before(jiffies, maxjiff)) {
2533                 barrier();
2534                 cpu_relax();
2535                 goto restart;
2536         }
2537
2538         /* The ring is stuck full. */
2539         printk(KERN_WARNING "%s: Transmit ring stuck full\n", dev->name);
2540         return NETDEV_TX_BUSY;
2541 }
2542
2543
2544 static int ace_change_mtu(struct net_device *dev, int new_mtu)
2545 {
2546         struct ace_private *ap = netdev_priv(dev);
2547         struct ace_regs __iomem *regs = ap->regs;
2548
2549         writel(new_mtu + ETH_HLEN + 4, &regs->IfMtu);
2550         dev->mtu = new_mtu;
2551
2552         if (new_mtu > ACE_STD_MTU) {
2553                 if (!(ap->jumbo)) {
2554                         printk(KERN_INFO "%s: Enabling Jumbo frame "
2555                                "support\n", dev->name);
2556                         ap->jumbo = 1;
2557                         if (!test_and_set_bit(0, &ap->jumbo_refill_busy))
2558                                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2559                         ace_set_rxtx_parms(dev, 1);
2560                 }
2561         } else {
2562                 while (test_and_set_bit(0, &ap->jumbo_refill_busy));
2563                 ace_sync_irq(dev->irq);
2564                 ace_set_rxtx_parms(dev, 0);
2565                 if (ap->jumbo) {
2566                         struct cmd cmd;
2567
2568                         cmd.evt = C_RESET_JUMBO_RNG;
2569                         cmd.code = 0;
2570                         cmd.idx = 0;
2571                         ace_issue_cmd(regs, &cmd);
2572                 }
2573         }
2574
2575         return 0;
2576 }
2577
2578 static int ace_get_link_ksettings(struct net_device *dev,
2579                                   struct ethtool_link_ksettings *cmd)
2580 {
2581         struct ace_private *ap = netdev_priv(dev);
2582         struct ace_regs __iomem *regs = ap->regs;
2583         u32 link;
2584         u32 supported;
2585
2586         memset(cmd, 0, sizeof(struct ethtool_link_ksettings));
2587
2588         supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
2589                      SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
2590                      SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full |
2591                      SUPPORTED_Autoneg | SUPPORTED_FIBRE);
2592
2593         cmd->base.port = PORT_FIBRE;
2594
2595         link = readl(&regs->GigLnkState);
2596         if (link & LNK_1000MB) {
2597                 cmd->base.speed = SPEED_1000;
2598         } else {
2599                 link = readl(&regs->FastLnkState);
2600                 if (link & LNK_100MB)
2601                         cmd->base.speed = SPEED_100;
2602                 else if (link & LNK_10MB)
2603                         cmd->base.speed = SPEED_10;
2604                 else
2605                         cmd->base.speed = 0;
2606         }
2607         if (link & LNK_FULL_DUPLEX)
2608                 cmd->base.duplex = DUPLEX_FULL;
2609         else
2610                 cmd->base.duplex = DUPLEX_HALF;
2611
2612         if (link & LNK_NEGOTIATE)
2613                 cmd->base.autoneg = AUTONEG_ENABLE;
2614         else
2615                 cmd->base.autoneg = AUTONEG_DISABLE;
2616
2617 #if 0
2618         /*
2619          * Current struct ethtool_cmd is insufficient
2620          */
2621         ecmd->trace = readl(&regs->TuneTrace);
2622
2623         ecmd->txcoal = readl(&regs->TuneTxCoalTicks);
2624         ecmd->rxcoal = readl(&regs->TuneRxCoalTicks);
2625 #endif
2626
2627         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
2628                                                 supported);
2629
2630         return 0;
2631 }
2632
2633 static int ace_set_link_ksettings(struct net_device *dev,
2634                                   const struct ethtool_link_ksettings *cmd)
2635 {
2636         struct ace_private *ap = netdev_priv(dev);
2637         struct ace_regs __iomem *regs = ap->regs;
2638         u32 link, speed;
2639
2640         link = readl(&regs->GigLnkState);
2641         if (link & LNK_1000MB)
2642                 speed = SPEED_1000;
2643         else {
2644                 link = readl(&regs->FastLnkState);
2645                 if (link & LNK_100MB)
2646                         speed = SPEED_100;
2647                 else if (link & LNK_10MB)
2648                         speed = SPEED_10;
2649                 else
2650                         speed = SPEED_100;
2651         }
2652
2653         link = LNK_ENABLE | LNK_1000MB | LNK_100MB | LNK_10MB |
2654                 LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL;
2655         if (!ACE_IS_TIGON_I(ap))
2656                 link |= LNK_TX_FLOW_CTL_Y;
2657         if (cmd->base.autoneg == AUTONEG_ENABLE)
2658                 link |= LNK_NEGOTIATE;
2659         if (cmd->base.speed != speed) {
2660                 link &= ~(LNK_1000MB | LNK_100MB | LNK_10MB);
2661                 switch (cmd->base.speed) {
2662                 case SPEED_1000:
2663                         link |= LNK_1000MB;
2664                         break;
2665                 case SPEED_100:
2666                         link |= LNK_100MB;
2667                         break;
2668                 case SPEED_10:
2669                         link |= LNK_10MB;
2670                         break;
2671                 }
2672         }
2673
2674         if (cmd->base.duplex == DUPLEX_FULL)
2675                 link |= LNK_FULL_DUPLEX;
2676
2677         if (link != ap->link) {
2678                 struct cmd cmd;
2679                 printk(KERN_INFO "%s: Renegotiating link state\n",
2680                        dev->name);
2681
2682                 ap->link = link;
2683                 writel(link, &regs->TuneLink);
2684                 if (!ACE_IS_TIGON_I(ap))
2685                         writel(link, &regs->TuneFastLink);
2686                 wmb();
2687
2688                 cmd.evt = C_LNK_NEGOTIATION;
2689                 cmd.code = 0;
2690                 cmd.idx = 0;
2691                 ace_issue_cmd(regs, &cmd);
2692         }
2693         return 0;
2694 }
2695
2696 static void ace_get_drvinfo(struct net_device *dev,
2697                             struct ethtool_drvinfo *info)
2698 {
2699         struct ace_private *ap = netdev_priv(dev);
2700
2701         strlcpy(info->driver, "acenic", sizeof(info->driver));
2702         snprintf(info->version, sizeof(info->version), "%i.%i.%i",
2703                  ap->firmware_major, ap->firmware_minor,
2704                  ap->firmware_fix);
2705
2706         if (ap->pdev)
2707                 strlcpy(info->bus_info, pci_name(ap->pdev),
2708                         sizeof(info->bus_info));
2709
2710 }
2711
2712 /*
2713  * Set the hardware MAC address.
2714  */
2715 static int ace_set_mac_addr(struct net_device *dev, void *p)
2716 {
2717         struct ace_private *ap = netdev_priv(dev);
2718         struct ace_regs __iomem *regs = ap->regs;
2719         struct sockaddr *addr=p;
2720         u8 *da;
2721         struct cmd cmd;
2722
2723         if(netif_running(dev))
2724                 return -EBUSY;
2725
2726         memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
2727
2728         da = (u8 *)dev->dev_addr;
2729
2730         writel(da[0] << 8 | da[1], &regs->MacAddrHi);
2731         writel((da[2] << 24) | (da[3] << 16) | (da[4] << 8) | da[5],
2732                &regs->MacAddrLo);
2733
2734         cmd.evt = C_SET_MAC_ADDR;
2735         cmd.code = 0;
2736         cmd.idx = 0;
2737         ace_issue_cmd(regs, &cmd);
2738
2739         return 0;
2740 }
2741
2742
2743 static void ace_set_multicast_list(struct net_device *dev)
2744 {
2745         struct ace_private *ap = netdev_priv(dev);
2746         struct ace_regs __iomem *regs = ap->regs;
2747         struct cmd cmd;
2748
2749         if ((dev->flags & IFF_ALLMULTI) && !(ap->mcast_all)) {
2750                 cmd.evt = C_SET_MULTICAST_MODE;
2751                 cmd.code = C_C_MCAST_ENABLE;
2752                 cmd.idx = 0;
2753                 ace_issue_cmd(regs, &cmd);
2754                 ap->mcast_all = 1;
2755         } else if (ap->mcast_all) {
2756                 cmd.evt = C_SET_MULTICAST_MODE;
2757                 cmd.code = C_C_MCAST_DISABLE;
2758                 cmd.idx = 0;
2759                 ace_issue_cmd(regs, &cmd);
2760                 ap->mcast_all = 0;
2761         }
2762
2763         if ((dev->flags & IFF_PROMISC) && !(ap->promisc)) {
2764                 cmd.evt = C_SET_PROMISC_MODE;
2765                 cmd.code = C_C_PROMISC_ENABLE;
2766                 cmd.idx = 0;
2767                 ace_issue_cmd(regs, &cmd);
2768                 ap->promisc = 1;
2769         }else if (!(dev->flags & IFF_PROMISC) && (ap->promisc)) {
2770                 cmd.evt = C_SET_PROMISC_MODE;
2771                 cmd.code = C_C_PROMISC_DISABLE;
2772                 cmd.idx = 0;
2773                 ace_issue_cmd(regs, &cmd);
2774                 ap->promisc = 0;
2775         }
2776
2777         /*
2778          * For the time being multicast relies on the upper layers
2779          * filtering it properly. The Firmware does not allow one to
2780          * set the entire multicast list at a time and keeping track of
2781          * it here is going to be messy.
2782          */
2783         if (!netdev_mc_empty(dev) && !ap->mcast_all) {
2784                 cmd.evt = C_SET_MULTICAST_MODE;
2785                 cmd.code = C_C_MCAST_ENABLE;
2786                 cmd.idx = 0;
2787                 ace_issue_cmd(regs, &cmd);
2788         }else if (!ap->mcast_all) {
2789                 cmd.evt = C_SET_MULTICAST_MODE;
2790                 cmd.code = C_C_MCAST_DISABLE;
2791                 cmd.idx = 0;
2792                 ace_issue_cmd(regs, &cmd);
2793         }
2794 }
2795
2796
2797 static struct net_device_stats *ace_get_stats(struct net_device *dev)
2798 {
2799         struct ace_private *ap = netdev_priv(dev);
2800         struct ace_mac_stats __iomem *mac_stats =
2801                 (struct ace_mac_stats __iomem *)ap->regs->Stats;
2802
2803         dev->stats.rx_missed_errors = readl(&mac_stats->drop_space);
2804         dev->stats.multicast = readl(&mac_stats->kept_mc);
2805         dev->stats.collisions = readl(&mac_stats->coll);
2806
2807         return &dev->stats;
2808 }
2809
2810
2811 static void ace_copy(struct ace_regs __iomem *regs, const __be32 *src,
2812                      u32 dest, int size)
2813 {
2814         void __iomem *tdest;
2815         short tsize, i;
2816
2817         if (size <= 0)
2818                 return;
2819
2820         while (size > 0) {
2821                 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2822                             min_t(u32, size, ACE_WINDOW_SIZE));
2823                 tdest = (void __iomem *) &regs->Window +
2824                         (dest & (ACE_WINDOW_SIZE - 1));
2825                 writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
2826                 for (i = 0; i < (tsize / 4); i++) {
2827                         /* Firmware is big-endian */
2828                         writel(be32_to_cpup(src), tdest);
2829                         src++;
2830                         tdest += 4;
2831                         dest += 4;
2832                         size -= 4;
2833                 }
2834         }
2835 }
2836
2837
2838 static void ace_clear(struct ace_regs __iomem *regs, u32 dest, int size)
2839 {
2840         void __iomem *tdest;
2841         short tsize = 0, i;
2842
2843         if (size <= 0)
2844                 return;
2845
2846         while (size > 0) {
2847                 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2848                                 min_t(u32, size, ACE_WINDOW_SIZE));
2849                 tdest = (void __iomem *) &regs->Window +
2850                         (dest & (ACE_WINDOW_SIZE - 1));
2851                 writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
2852
2853                 for (i = 0; i < (tsize / 4); i++) {
2854                         writel(0, tdest + i*4);
2855                 }
2856
2857                 dest += tsize;
2858                 size -= tsize;
2859         }
2860 }
2861
2862
2863 /*
2864  * Download the firmware into the SRAM on the NIC
2865  *
2866  * This operation requires the NIC to be halted and is performed with
2867  * interrupts disabled and with the spinlock hold.
2868  */
2869 static int ace_load_firmware(struct net_device *dev)
2870 {
2871         const struct firmware *fw;
2872         const char *fw_name = "acenic/tg2.bin";
2873         struct ace_private *ap = netdev_priv(dev);
2874         struct ace_regs __iomem *regs = ap->regs;
2875         const __be32 *fw_data;
2876         u32 load_addr;
2877         int ret;
2878
2879         if (!(readl(&regs->CpuCtrl) & CPU_HALTED)) {
2880                 printk(KERN_ERR "%s: trying to download firmware while the "
2881                        "CPU is running!\n", ap->name);
2882                 return -EFAULT;
2883         }
2884
2885         if (ACE_IS_TIGON_I(ap))
2886                 fw_name = "acenic/tg1.bin";
2887
2888         ret = request_firmware(&fw, fw_name, &ap->pdev->dev);
2889         if (ret) {
2890                 printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
2891                        ap->name, fw_name);
2892                 return ret;
2893         }
2894
2895         fw_data = (void *)fw->data;
2896
2897         /* Firmware blob starts with version numbers, followed by
2898            load and start address. Remainder is the blob to be loaded
2899            contiguously from load address. We don't bother to represent
2900            the BSS/SBSS sections any more, since we were clearing the
2901            whole thing anyway. */
2902         ap->firmware_major = fw->data[0];
2903         ap->firmware_minor = fw->data[1];
2904         ap->firmware_fix = fw->data[2];
2905
2906         ap->firmware_start = be32_to_cpu(fw_data[1]);
2907         if (ap->firmware_start < 0x4000 || ap->firmware_start >= 0x80000) {
2908                 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2909                        ap->name, ap->firmware_start, fw_name);
2910                 ret = -EINVAL;
2911                 goto out;
2912         }
2913
2914         load_addr = be32_to_cpu(fw_data[2]);
2915         if (load_addr < 0x4000 || load_addr >= 0x80000) {
2916                 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2917                        ap->name, load_addr, fw_name);
2918                 ret = -EINVAL;
2919                 goto out;
2920         }
2921
2922         /*
2923          * Do not try to clear more than 512KiB or we end up seeing
2924          * funny things on NICs with only 512KiB SRAM
2925          */
2926         ace_clear(regs, 0x2000, 0x80000-0x2000);
2927         ace_copy(regs, &fw_data[3], load_addr, fw->size-12);
2928  out:
2929         release_firmware(fw);
2930         return ret;
2931 }
2932
2933
2934 /*
2935  * The eeprom on the AceNIC is an Atmel i2c EEPROM.
2936  *
2937  * Accessing the EEPROM is `interesting' to say the least - don't read
2938  * this code right after dinner.
2939  *
2940  * This is all about black magic and bit-banging the device .... I
2941  * wonder in what hospital they have put the guy who designed the i2c
2942  * specs.
2943  *
2944  * Oh yes, this is only the beginning!
2945  *
2946  * Thanks to Stevarino Webinski for helping tracking down the bugs in the
2947  * code i2c readout code by beta testing all my hacks.
2948  */
2949 static void eeprom_start(struct ace_regs __iomem *regs)
2950 {
2951         u32 local;
2952
2953         readl(&regs->LocalCtrl);
2954         udelay(ACE_SHORT_DELAY);
2955         local = readl(&regs->LocalCtrl);
2956         local |= EEPROM_DATA_OUT | EEPROM_WRITE_ENABLE;
2957         writel(local, &regs->LocalCtrl);
2958         readl(&regs->LocalCtrl);
2959         mb();
2960         udelay(ACE_SHORT_DELAY);
2961         local |= EEPROM_CLK_OUT;
2962         writel(local, &regs->LocalCtrl);
2963         readl(&regs->LocalCtrl);
2964         mb();
2965         udelay(ACE_SHORT_DELAY);
2966         local &= ~EEPROM_DATA_OUT;
2967         writel(local, &regs->LocalCtrl);
2968         readl(&regs->LocalCtrl);
2969         mb();
2970         udelay(ACE_SHORT_DELAY);
2971         local &= ~EEPROM_CLK_OUT;
2972         writel(local, &regs->LocalCtrl);
2973         readl(&regs->LocalCtrl);
2974         mb();
2975 }
2976
2977
2978 static void eeprom_prep(struct ace_regs __iomem *regs, u8 magic)
2979 {
2980         short i;
2981         u32 local;
2982
2983         udelay(ACE_SHORT_DELAY);
2984         local = readl(&regs->LocalCtrl);
2985         local &= ~EEPROM_DATA_OUT;
2986         local |= EEPROM_WRITE_ENABLE;
2987         writel(local, &regs->LocalCtrl);
2988         readl(&regs->LocalCtrl);
2989         mb();
2990
2991         for (i = 0; i < 8; i++, magic <<= 1) {
2992                 udelay(ACE_SHORT_DELAY);
2993                 if (magic & 0x80)
2994                         local |= EEPROM_DATA_OUT;
2995                 else
2996                         local &= ~EEPROM_DATA_OUT;
2997                 writel(local, &regs->LocalCtrl);
2998                 readl(&regs->LocalCtrl);
2999                 mb();
3000
3001                 udelay(ACE_SHORT_DELAY);
3002                 local |= EEPROM_CLK_OUT;
3003                 writel(local, &regs->LocalCtrl);
3004                 readl(&regs->LocalCtrl);
3005                 mb();
3006                 udelay(ACE_SHORT_DELAY);
3007                 local &= ~(EEPROM_CLK_OUT | EEPROM_DATA_OUT);
3008                 writel(local, &regs->LocalCtrl);
3009                 readl(&regs->LocalCtrl);
3010                 mb();
3011         }
3012 }
3013
3014
3015 static int eeprom_check_ack(struct ace_regs __iomem *regs)
3016 {
3017         int state;
3018         u32 local;
3019
3020         local = readl(&regs->LocalCtrl);
3021         local &= ~EEPROM_WRITE_ENABLE;
3022         writel(local, &regs->LocalCtrl);
3023         readl(&regs->LocalCtrl);
3024         mb();
3025         udelay(ACE_LONG_DELAY);
3026         local |= EEPROM_CLK_OUT;
3027         writel(local, &regs->LocalCtrl);
3028         readl(&regs->LocalCtrl);
3029         mb();
3030         udelay(ACE_SHORT_DELAY);
3031         /* sample data in middle of high clk */
3032         state = (readl(&regs->LocalCtrl) & EEPROM_DATA_IN) != 0;
3033         udelay(ACE_SHORT_DELAY);
3034         mb();
3035         writel(readl(&regs->LocalCtrl) & ~EEPROM_CLK_OUT, &regs->LocalCtrl);
3036         readl(&regs->LocalCtrl);
3037         mb();
3038
3039         return state;
3040 }
3041
3042
3043 static void eeprom_stop(struct ace_regs __iomem *regs)
3044 {
3045         u32 local;
3046
3047         udelay(ACE_SHORT_DELAY);
3048         local = readl(&regs->LocalCtrl);
3049         local |= EEPROM_WRITE_ENABLE;
3050         writel(local, &regs->LocalCtrl);
3051         readl(&regs->LocalCtrl);
3052         mb();
3053         udelay(ACE_SHORT_DELAY);
3054         local &= ~EEPROM_DATA_OUT;
3055         writel(local, &regs->LocalCtrl);
3056         readl(&regs->LocalCtrl);
3057         mb();
3058         udelay(ACE_SHORT_DELAY);
3059         local |= EEPROM_CLK_OUT;
3060         writel(local, &regs->LocalCtrl);
3061         readl(&regs->LocalCtrl);
3062         mb();
3063         udelay(ACE_SHORT_DELAY);
3064         local |= EEPROM_DATA_OUT;
3065         writel(local, &regs->LocalCtrl);
3066         readl(&regs->LocalCtrl);
3067         mb();
3068         udelay(ACE_LONG_DELAY);
3069         local &= ~EEPROM_CLK_OUT;
3070         writel(local, &regs->LocalCtrl);
3071         mb();
3072 }
3073
3074
3075 /*
3076  * Read a whole byte from the EEPROM.
3077  */
3078 static int read_eeprom_byte(struct net_device *dev, unsigned long offset)
3079 {
3080         struct ace_private *ap = netdev_priv(dev);
3081         struct ace_regs __iomem *regs = ap->regs;
3082         unsigned long flags;
3083         u32 local;
3084         int result = 0;
3085         short i;
3086
3087         /*
3088          * Don't take interrupts on this CPU will bit banging
3089          * the %#%#@$ I2C device
3090          */
3091         local_irq_save(flags);
3092
3093         eeprom_start(regs);
3094
3095         eeprom_prep(regs, EEPROM_WRITE_SELECT);
3096         if (eeprom_check_ack(regs)) {
3097                 local_irq_restore(flags);
3098                 printk(KERN_ERR "%s: Unable to sync eeprom\n", ap->name);
3099                 result = -EIO;
3100                 goto eeprom_read_error;
3101         }
3102
3103         eeprom_prep(regs, (offset >> 8) & 0xff);
3104         if (eeprom_check_ack(regs)) {
3105                 local_irq_restore(flags);
3106                 printk(KERN_ERR "%s: Unable to set address byte 0\n",
3107                        ap->name);
3108                 result = -EIO;
3109                 goto eeprom_read_error;
3110         }
3111
3112         eeprom_prep(regs, offset & 0xff);
3113         if (eeprom_check_ack(regs)) {
3114                 local_irq_restore(flags);
3115                 printk(KERN_ERR "%s: Unable to set address byte 1\n",
3116                        ap->name);
3117                 result = -EIO;
3118                 goto eeprom_read_error;
3119         }
3120
3121         eeprom_start(regs);
3122         eeprom_prep(regs, EEPROM_READ_SELECT);
3123         if (eeprom_check_ack(regs)) {
3124                 local_irq_restore(flags);
3125                 printk(KERN_ERR "%s: Unable to set READ_SELECT\n",
3126                        ap->name);
3127                 result = -EIO;
3128                 goto eeprom_read_error;
3129         }
3130
3131         for (i = 0; i < 8; i++) {
3132                 local = readl(&regs->LocalCtrl);
3133                 local &= ~EEPROM_WRITE_ENABLE;
3134                 writel(local, &regs->LocalCtrl);
3135                 readl(&regs->LocalCtrl);
3136                 udelay(ACE_LONG_DELAY);
3137                 mb();
3138                 local |= EEPROM_CLK_OUT;
3139                 writel(local, &regs->LocalCtrl);
3140                 readl(&regs->LocalCtrl);
3141                 mb();
3142                 udelay(ACE_SHORT_DELAY);
3143                 /* sample data mid high clk */
3144                 result = (result << 1) |
3145                         ((readl(&regs->LocalCtrl) & EEPROM_DATA_IN) != 0);
3146                 udelay(ACE_SHORT_DELAY);
3147                 mb();
3148                 local = readl(&regs->LocalCtrl);
3149                 local &= ~EEPROM_CLK_OUT;
3150                 writel(local, &regs->LocalCtrl);
3151                 readl(&regs->LocalCtrl);
3152                 udelay(ACE_SHORT_DELAY);
3153                 mb();
3154                 if (i == 7) {
3155                         local |= EEPROM_WRITE_ENABLE;
3156                         writel(local, &regs->LocalCtrl);
3157                         readl(&regs->LocalCtrl);
3158                         mb();
3159                         udelay(ACE_SHORT_DELAY);
3160                 }
3161         }
3162
3163         local |= EEPROM_DATA_OUT;
3164         writel(local, &regs->LocalCtrl);
3165         readl(&regs->LocalCtrl);
3166         mb();
3167         udelay(ACE_SHORT_DELAY);
3168         writel(readl(&regs->LocalCtrl) | EEPROM_CLK_OUT, &regs->LocalCtrl);
3169         readl(&regs->LocalCtrl);
3170         udelay(ACE_LONG_DELAY);
3171         writel(readl(&regs->LocalCtrl) & ~EEPROM_CLK_OUT, &regs->LocalCtrl);
3172         readl(&regs->LocalCtrl);
3173         mb();
3174         udelay(ACE_SHORT_DELAY);
3175         eeprom_stop(regs);
3176
3177         local_irq_restore(flags);
3178  out:
3179         return result;
3180
3181  eeprom_read_error:
3182         printk(KERN_ERR "%s: Unable to read eeprom byte 0x%02lx\n",
3183                ap->name, offset);
3184         goto out;
3185 }
3186
3187 module_pci_driver(acenic_pci_driver);