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, unsigned int txqueue);
 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->ndev = dev;
 469         ap->pdev = pdev;
 470         ap->name = pci_name(pdev);
 471
 472         dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
 473         dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
 474
 475         dev->watchdog_timeo = 5*HZ;
 476         dev->min_mtu = 0;
 477         dev->max_mtu = ACE_JUMBO_MTU;
 478
 479         dev->netdev_ops = &ace_netdev_ops;
 480         dev->ethtool_ops = &ace_ethtool_ops;
 481
 482         /* we only display this string ONCE */
 483         if (!boards_found)
 484                 printk(version);
 485
 486         if (pci_enable_device(pdev))
 487                 goto fail_free_netdev;
 488
 489         /*
 490          * Enable master mode before we start playing with the
 491          * pci_command word since pci_set_master() will modify
 492          * it.
 493          */
 494         pci_set_master(pdev);
 495
 496         pci_read_config_word(pdev, PCI_COMMAND, &ap->pci_command);
 497
 498         /* OpenFirmware on Mac's does not set this - DOH.. */
 499         if (!(ap->pci_command & PCI_COMMAND_MEMORY)) {
 500                 printk(KERN_INFO "%s: Enabling PCI Memory Mapped "
 501                        "access - was not enabled by BIOS/Firmware\n",
 502                        ap->name);
 503                 ap->pci_command = ap->pci_command | PCI_COMMAND_MEMORY;
 504                 pci_write_config_word(ap->pdev, PCI_COMMAND,
 505                                       ap->pci_command);
 506                 wmb();
 507         }
 508
 509         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ap->pci_latency);
 510         if (ap->pci_latency <= 0x40) {
 511                 ap->pci_latency = 0x40;
 512                 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ap->pci_latency);
 513         }
 514
 515         /*
 516          * Remap the regs into kernel space - this is abuse of
 517          * dev->base_addr since it was means for I/O port
 518          * addresses but who gives a damn.
 519          */
 520         dev->base_addr = pci_resource_start(pdev, 0);
 521         ap->regs = ioremap(dev->base_addr, 0x4000);
 522         if (!ap->regs) {
 523                 printk(KERN_ERR "%s:  Unable to map I/O register, "
 524                        "AceNIC %i will be disabled.\n",
 525                        ap->name, boards_found);
 526                 goto fail_free_netdev;
 527         }
 528
 529         switch(pdev->vendor) {
 530         case PCI_VENDOR_ID_ALTEON:
 531                 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9100T) {
 532                         printk(KERN_INFO "%s: Farallon PN9100-T ",
 533                                ap->name);
 534                 } else {
 535                         printk(KERN_INFO "%s: Alteon AceNIC ",
 536                                ap->name);
 537                 }
 538                 break;
 539         case PCI_VENDOR_ID_3COM:
 540                 printk(KERN_INFO "%s: 3Com 3C985 ", ap->name);
 541                 break;
 542         case PCI_VENDOR_ID_NETGEAR:
 543                 printk(KERN_INFO "%s: NetGear GA620 ", ap->name);
 544                 break;
 545         case PCI_VENDOR_ID_DEC:
 546                 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9000SX) {
 547                         printk(KERN_INFO "%s: Farallon PN9000-SX ",
 548                                ap->name);
 549                         break;
 550                 }
 551                 fallthrough;
 552         case PCI_VENDOR_ID_SGI:
 553                 printk(KERN_INFO "%s: SGI AceNIC ", ap->name);
 554                 break;
 555         default:
 556                 printk(KERN_INFO "%s: Unknown AceNIC ", ap->name);
 557                 break;
 558         }
 559
 560         printk("Gigabit Ethernet at 0x%08lx, ", dev->base_addr);
 561         printk("irq %d\n", pdev->irq);
 562
 563 #ifdef CONFIG_ACENIC_OMIT_TIGON_I
 564         if ((readl(&ap->regs->HostCtrl) >> 28) == 4) {
 565                 printk(KERN_ERR "%s: Driver compiled without Tigon I"
 566                        " support - NIC disabled\n", dev->name);
 567                 goto fail_uninit;
 568         }
 569 #endif
 570
 571         if (ace_allocate_descriptors(dev))
 572                 goto fail_free_netdev;
 573
 574 #ifdef MODULE
 575         if (boards_found >= ACE_MAX_MOD_PARMS)
 576                 ap->board_idx = BOARD_IDX_OVERFLOW;
 577         else
 578                 ap->board_idx = boards_found;
 579 #else
 580         ap->board_idx = BOARD_IDX_STATIC;
 581 #endif
 582
 583         if (ace_init(dev))
 584                 goto fail_free_netdev;
 585
 586         if (register_netdev(dev)) {
 587                 printk(KERN_ERR "acenic: device registration failed\n");
 588                 goto fail_uninit;
 589         }
 590         ap->name = dev->name;
 591
 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                         dma_unmap_page(&ap->pdev->dev, mapping,
 646                                        ACE_STD_BUFSIZE, DMA_FROM_DEVICE);
 647
 648                         ap->rx_std_ring[i].size = 0;
 649                         ap->skb->rx_std_skbuff[i].skb = NULL;
 650                         dev_kfree_skb(skb);
 651                 }
 652         }
 653
 654         if (ap->version >= 2) {
 655                 for (i = 0; i < RX_MINI_RING_ENTRIES; i++) {
 656                         struct sk_buff *skb = ap->skb->rx_mini_skbuff[i].skb;
 657
 658                         if (skb) {
 659                                 struct ring_info *ringp;
 660                                 dma_addr_t mapping;
 661
 662                                 ringp = &ap->skb->rx_mini_skbuff[i];
 663                                 mapping = dma_unmap_addr(ringp,mapping);
 664                                 dma_unmap_page(&ap->pdev->dev, mapping,
 665                                                ACE_MINI_BUFSIZE,
 666                                                DMA_FROM_DEVICE);
 667
 668                                 ap->rx_mini_ring[i].size = 0;
 669                                 ap->skb->rx_mini_skbuff[i].skb = NULL;
 670                                 dev_kfree_skb(skb);
 671                         }
 672                 }
 673         }
 674
 675         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
 676                 struct sk_buff *skb = ap->skb->rx_jumbo_skbuff[i].skb;
 677                 if (skb) {
 678                         struct ring_info *ringp;
 679                         dma_addr_t mapping;
 680
 681                         ringp = &ap->skb->rx_jumbo_skbuff[i];
 682                         mapping = dma_unmap_addr(ringp, mapping);
 683                         dma_unmap_page(&ap->pdev->dev, mapping,
 684                                        ACE_JUMBO_BUFSIZE, DMA_FROM_DEVICE);
 685
 686                         ap->rx_jumbo_ring[i].size = 0;
 687                         ap->skb->rx_jumbo_skbuff[i].skb = NULL;
 688                         dev_kfree_skb(skb);
 689                 }
 690         }
 691
 692         ace_init_cleanup(dev);
 693         free_netdev(dev);
 694 }
 695
 696 static struct pci_driver acenic_pci_driver = {
 697         .name           = "acenic",
 698         .id_table       = acenic_pci_tbl,
 699         .probe          = acenic_probe_one,
 700         .remove         = acenic_remove_one,
 701 };
 702
 703 static void ace_free_descriptors(struct net_device *dev)
 704 {
 705         struct ace_private *ap = netdev_priv(dev);
 706         int size;
 707
 708         if (ap->rx_std_ring != NULL) {
 709                 size = (sizeof(struct rx_desc) *
 710                         (RX_STD_RING_ENTRIES +
 711                          RX_JUMBO_RING_ENTRIES +
 712                          RX_MINI_RING_ENTRIES +
 713                          RX_RETURN_RING_ENTRIES));
 714                 dma_free_coherent(&ap->pdev->dev, size, ap->rx_std_ring,
 715                                   ap->rx_ring_base_dma);
 716                 ap->rx_std_ring = NULL;
 717                 ap->rx_jumbo_ring = NULL;
 718                 ap->rx_mini_ring = NULL;
 719                 ap->rx_return_ring = NULL;
 720         }
 721         if (ap->evt_ring != NULL) {
 722                 size = (sizeof(struct event) * EVT_RING_ENTRIES);
 723                 dma_free_coherent(&ap->pdev->dev, size, ap->evt_ring,
 724                                   ap->evt_ring_dma);
 725                 ap->evt_ring = NULL;
 726         }
 727         if (ap->tx_ring != NULL && !ACE_IS_TIGON_I(ap)) {
 728                 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
 729                 dma_free_coherent(&ap->pdev->dev, size, ap->tx_ring,
 730                                   ap->tx_ring_dma);
 731         }
 732         ap->tx_ring = NULL;
 733
 734         if (ap->evt_prd != NULL) {
 735                 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
 736                                   (void *)ap->evt_prd, ap->evt_prd_dma);
 737                 ap->evt_prd = NULL;
 738         }
 739         if (ap->rx_ret_prd != NULL) {
 740                 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
 741                                   (void *)ap->rx_ret_prd, ap->rx_ret_prd_dma);
 742                 ap->rx_ret_prd = NULL;
 743         }
 744         if (ap->tx_csm != NULL) {
 745                 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
 746                                   (void *)ap->tx_csm, ap->tx_csm_dma);
 747                 ap->tx_csm = NULL;
 748         }
 749 }
 750
 751
 752 static int ace_allocate_descriptors(struct net_device *dev)
 753 {
 754         struct ace_private *ap = netdev_priv(dev);
 755         int size;
 756
 757         size = (sizeof(struct rx_desc) *
 758                 (RX_STD_RING_ENTRIES +
 759                  RX_JUMBO_RING_ENTRIES +
 760                  RX_MINI_RING_ENTRIES +
 761                  RX_RETURN_RING_ENTRIES));
 762
 763         ap->rx_std_ring = dma_alloc_coherent(&ap->pdev->dev, size,
 764                                              &ap->rx_ring_base_dma, GFP_KERNEL);
 765         if (ap->rx_std_ring == NULL)
 766                 goto fail;
 767
 768         ap->rx_jumbo_ring = ap->rx_std_ring + RX_STD_RING_ENTRIES;
 769         ap->rx_mini_ring = ap->rx_jumbo_ring + RX_JUMBO_RING_ENTRIES;
 770         ap->rx_return_ring = ap->rx_mini_ring + RX_MINI_RING_ENTRIES;
 771
 772         size = (sizeof(struct event) * EVT_RING_ENTRIES);
 773
 774         ap->evt_ring = dma_alloc_coherent(&ap->pdev->dev, size,
 775                                           &ap->evt_ring_dma, GFP_KERNEL);
 776
 777         if (ap->evt_ring == NULL)
 778                 goto fail;
 779
 780         /*
 781          * Only allocate a host TX ring for the Tigon II, the Tigon I
 782          * has to use PCI registers for this ;-(
 783          */
 784         if (!ACE_IS_TIGON_I(ap)) {
 785                 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
 786
 787                 ap->tx_ring = dma_alloc_coherent(&ap->pdev->dev, size,
 788                                                  &ap->tx_ring_dma, GFP_KERNEL);
 789
 790                 if (ap->tx_ring == NULL)
 791                         goto fail;
 792         }
 793
 794         ap->evt_prd = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
 795                                          &ap->evt_prd_dma, GFP_KERNEL);
 796         if (ap->evt_prd == NULL)
 797                 goto fail;
 798
 799         ap->rx_ret_prd = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
 800                                             &ap->rx_ret_prd_dma, GFP_KERNEL);
 801         if (ap->rx_ret_prd == NULL)
 802                 goto fail;
 803
 804         ap->tx_csm = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
 805                                         &ap->tx_csm_dma, GFP_KERNEL);
 806         if (ap->tx_csm == NULL)
 807                 goto fail;
 808
 809         return 0;
 810
 811 fail:
 812         /* Clean up. */
 813         ace_init_cleanup(dev);
 814         return 1;
 815 }
 816
 817
 818 /*
 819  * Generic cleanup handling data allocated during init. Used when the
 820  * module is unloaded or if an error occurs during initialization
 821  */
 822 static void ace_init_cleanup(struct net_device *dev)
 823 {
 824         struct ace_private *ap;
 825
 826         ap = netdev_priv(dev);
 827
 828         ace_free_descriptors(dev);
 829
 830         if (ap->info)
 831                 dma_free_coherent(&ap->pdev->dev, sizeof(struct ace_info),
 832                                   ap->info, ap->info_dma);
 833         kfree(ap->skb);
 834         kfree(ap->trace_buf);
 835
 836         if (dev->irq)
 837                 free_irq(dev->irq, dev);
 838
 839         iounmap(ap->regs);
 840 }
 841
 842
 843 /*
 844  * Commands are considered to be slow.
 845  */
 846 static inline void ace_issue_cmd(struct ace_regs __iomem *regs, struct cmd *cmd)
 847 {
 848         u32 idx;
 849
 850         idx = readl(&regs->CmdPrd);
 851
 852         writel(*(u32 *)(cmd), &regs->CmdRng[idx]);
 853         idx = (idx + 1) % CMD_RING_ENTRIES;
 854
 855         writel(idx, &regs->CmdPrd);
 856 }
 857
 858
 859 static int ace_init(struct net_device *dev)
 860 {
 861         struct ace_private *ap;
 862         struct ace_regs __iomem *regs;
 863         struct ace_info *info = NULL;
 864         struct pci_dev *pdev;
 865         unsigned long myjif;
 866         u64 tmp_ptr;
 867         u32 tig_ver, mac1, mac2, tmp, pci_state;
 868         int board_idx, ecode = 0;
 869         short i;
 870         unsigned char cache_size;
 871         u8 addr[ETH_ALEN];
 872
 873         ap = netdev_priv(dev);
 874         regs = ap->regs;
 875
 876         board_idx = ap->board_idx;
 877
 878         /*
 879          * aman@sgi.com - its useful to do a NIC reset here to
 880          * address the `Firmware not running' problem subsequent
 881          * to any crashes involving the NIC
 882          */
 883         writel(HW_RESET | (HW_RESET << 24), &regs->HostCtrl);
 884         readl(&regs->HostCtrl);         /* PCI write posting */
 885         udelay(5);
 886
 887         /*
 888          * Don't access any other registers before this point!
 889          */
 890 #ifdef __BIG_ENDIAN
 891         /*
 892          * This will most likely need BYTE_SWAP once we switch
 893          * to using __raw_writel()
 894          */
 895         writel((WORD_SWAP | CLR_INT | ((WORD_SWAP | CLR_INT) << 24)),
 896                &regs->HostCtrl);
 897 #else
 898         writel((CLR_INT | WORD_SWAP | ((CLR_INT | WORD_SWAP) << 24)),
 899                &regs->HostCtrl);
 900 #endif
 901         readl(&regs->HostCtrl);         /* PCI write posting */
 902
 903         /*
 904          * Stop the NIC CPU and clear pending interrupts
 905          */
 906         writel(readl(&regs->CpuCtrl) | CPU_HALT, &regs->CpuCtrl);
 907         readl(&regs->CpuCtrl);          /* PCI write posting */
 908         writel(0, &regs->Mb0Lo);
 909
 910         tig_ver = readl(&regs->HostCtrl) >> 28;
 911
 912         switch(tig_ver){
 913 #ifndef CONFIG_ACENIC_OMIT_TIGON_I
 914         case 4:
 915         case 5:
 916                 printk(KERN_INFO "  Tigon I  (Rev. %i), Firmware: %i.%i.%i, ",
 917                        tig_ver, ap->firmware_major, ap->firmware_minor,
 918                        ap->firmware_fix);
 919                 writel(0, &regs->LocalCtrl);
 920                 ap->version = 1;
 921                 ap->tx_ring_entries = TIGON_I_TX_RING_ENTRIES;
 922                 break;
 923 #endif
 924         case 6:
 925                 printk(KERN_INFO "  Tigon II (Rev. %i), Firmware: %i.%i.%i, ",
 926                        tig_ver, ap->firmware_major, ap->firmware_minor,
 927                        ap->firmware_fix);
 928                 writel(readl(&regs->CpuBCtrl) | CPU_HALT, &regs->CpuBCtrl);
 929                 readl(&regs->CpuBCtrl);         /* PCI write posting */
 930                 /*
 931                  * The SRAM bank size does _not_ indicate the amount
 932                  * of memory on the card, it controls the _bank_ size!
 933                  * Ie. a 1MB AceNIC will have two banks of 512KB.
 934                  */
 935                 writel(SRAM_BANK_512K, &regs->LocalCtrl);
 936                 writel(SYNC_SRAM_TIMING, &regs->MiscCfg);
 937                 ap->version = 2;
 938                 ap->tx_ring_entries = MAX_TX_RING_ENTRIES;
 939                 break;
 940         default:
 941                 printk(KERN_WARNING "  Unsupported Tigon version detected "
 942                        "(%i)\n", tig_ver);
 943                 ecode = -ENODEV;
 944                 goto init_error;
 945         }
 946
 947         /*
 948          * ModeStat _must_ be set after the SRAM settings as this change
 949          * seems to corrupt the ModeStat and possible other registers.
 950          * The SRAM settings survive resets and setting it to the same
 951          * value a second time works as well. This is what caused the
 952          * `Firmware not running' problem on the Tigon II.
 953          */
 954 #ifdef __BIG_ENDIAN
 955         writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL | ACE_BYTE_SWAP_BD |
 956                ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, &regs->ModeStat);
 957 #else
 958         writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL |
 959                ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, &regs->ModeStat);
 960 #endif
 961         readl(&regs->ModeStat);         /* PCI write posting */
 962
 963         mac1 = 0;
 964         for(i = 0; i < 4; i++) {
 965                 int t;
 966
 967                 mac1 = mac1 << 8;
 968                 t = read_eeprom_byte(dev, 0x8c+i);
 969                 if (t < 0) {
 970                         ecode = -EIO;
 971                         goto init_error;
 972                 } else
 973                         mac1 |= (t & 0xff);
 974         }
 975         mac2 = 0;
 976         for(i = 4; i < 8; i++) {
 977                 int t;
 978
 979                 mac2 = mac2 << 8;
 980                 t = read_eeprom_byte(dev, 0x8c+i);
 981                 if (t < 0) {
 982                         ecode = -EIO;
 983                         goto init_error;
 984                 } else
 985                         mac2 |= (t & 0xff);
 986         }
 987
 988         writel(mac1, &regs->MacAddrHi);
 989         writel(mac2, &regs->MacAddrLo);
 990
 991         addr[0] = (mac1 >> 8) & 0xff;
 992         addr[1] = mac1 & 0xff;
 993         addr[2] = (mac2 >> 24) & 0xff;
 994         addr[3] = (mac2 >> 16) & 0xff;
 995         addr[4] = (mac2 >> 8) & 0xff;
 996         addr[5] = mac2 & 0xff;
 997         eth_hw_addr_set(dev, addr);
 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 (dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1133                 ecode = -ENODEV;
1134                 goto init_error;
1135         }
1136
1137         /*
1138          * Initialize the generic info block and the command+event rings
1139          * and the control blocks for the transmit and receive rings
1140          * as they need to be setup once and for all.
1141          */
1142         if (!(info = dma_alloc_coherent(&ap->pdev->dev, sizeof(struct ace_info),
1143                                         &ap->info_dma, GFP_KERNEL))) {
1144                 ecode = -EAGAIN;
1145                 goto init_error;
1146         }
1147         ap->info = info;
1148
1149         /*
1150          * Get the memory for the skb rings.
1151          */
1152         if (!(ap->skb = kzalloc(sizeof(struct ace_skb), GFP_KERNEL))) {
1153                 ecode = -EAGAIN;
1154                 goto init_error;
1155         }
1156
1157         ecode = request_irq(pdev->irq, ace_interrupt, IRQF_SHARED,
1158                             DRV_NAME, dev);
1159         if (ecode) {
1160                 printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
1161                        DRV_NAME, pdev->irq);
1162                 goto init_error;
1163         } else
1164                 dev->irq = pdev->irq;
1165
1166 #ifdef INDEX_DEBUG
1167         spin_lock_init(&ap->debug_lock);
1168         ap->last_tx = ACE_TX_RING_ENTRIES(ap) - 1;
1169         ap->last_std_rx = 0;
1170         ap->last_mini_rx = 0;
1171 #endif
1172
1173         ecode = ace_load_firmware(dev);
1174         if (ecode)
1175                 goto init_error;
1176
1177         ap->fw_running = 0;
1178
1179         tmp_ptr = ap->info_dma;
1180         writel(tmp_ptr >> 32, &regs->InfoPtrHi);
1181         writel(tmp_ptr & 0xffffffff, &regs->InfoPtrLo);
1182
1183         memset(ap->evt_ring, 0, EVT_RING_ENTRIES * sizeof(struct event));
1184
1185         set_aceaddr(&info->evt_ctrl.rngptr, ap->evt_ring_dma);
1186         info->evt_ctrl.flags = 0;
1187
1188         *(ap->evt_prd) = 0;
1189         wmb();
1190         set_aceaddr(&info->evt_prd_ptr, ap->evt_prd_dma);
1191         writel(0, &regs->EvtCsm);
1192
1193         set_aceaddr(&info->cmd_ctrl.rngptr, 0x100);
1194         info->cmd_ctrl.flags = 0;
1195         info->cmd_ctrl.max_len = 0;
1196
1197         for (i = 0; i < CMD_RING_ENTRIES; i++)
1198                 writel(0, &regs->CmdRng[i]);
1199
1200         writel(0, &regs->CmdPrd);
1201         writel(0, &regs->CmdCsm);
1202
1203         tmp_ptr = ap->info_dma;
1204         tmp_ptr += (unsigned long) &(((struct ace_info *)0)->s.stats);
1205         set_aceaddr(&info->stats2_ptr, (dma_addr_t) tmp_ptr);
1206
1207         set_aceaddr(&info->rx_std_ctrl.rngptr, ap->rx_ring_base_dma);
1208         info->rx_std_ctrl.max_len = ACE_STD_BUFSIZE;
1209         info->rx_std_ctrl.flags =
1210           RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1211
1212         memset(ap->rx_std_ring, 0,
1213                RX_STD_RING_ENTRIES * sizeof(struct rx_desc));
1214
1215         for (i = 0; i < RX_STD_RING_ENTRIES; i++)
1216                 ap->rx_std_ring[i].flags = BD_FLG_TCP_UDP_SUM;
1217
1218         ap->rx_std_skbprd = 0;
1219         atomic_set(&ap->cur_rx_bufs, 0);
1220
1221         set_aceaddr(&info->rx_jumbo_ctrl.rngptr,
1222                     (ap->rx_ring_base_dma +
1223                      (sizeof(struct rx_desc) * RX_STD_RING_ENTRIES)));
1224         info->rx_jumbo_ctrl.max_len = 0;
1225         info->rx_jumbo_ctrl.flags =
1226           RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1227
1228         memset(ap->rx_jumbo_ring, 0,
1229                RX_JUMBO_RING_ENTRIES * sizeof(struct rx_desc));
1230
1231         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++)
1232                 ap->rx_jumbo_ring[i].flags = BD_FLG_TCP_UDP_SUM | BD_FLG_JUMBO;
1233
1234         ap->rx_jumbo_skbprd = 0;
1235         atomic_set(&ap->cur_jumbo_bufs, 0);
1236
1237         memset(ap->rx_mini_ring, 0,
1238                RX_MINI_RING_ENTRIES * sizeof(struct rx_desc));
1239
1240         if (ap->version >= 2) {
1241                 set_aceaddr(&info->rx_mini_ctrl.rngptr,
1242                             (ap->rx_ring_base_dma +
1243                              (sizeof(struct rx_desc) *
1244                               (RX_STD_RING_ENTRIES +
1245                                RX_JUMBO_RING_ENTRIES))));
1246                 info->rx_mini_ctrl.max_len = ACE_MINI_SIZE;
1247                 info->rx_mini_ctrl.flags =
1248                   RCB_FLG_TCP_UDP_SUM|RCB_FLG_NO_PSEUDO_HDR|RCB_FLG_VLAN_ASSIST;
1249
1250                 for (i = 0; i < RX_MINI_RING_ENTRIES; i++)
1251                         ap->rx_mini_ring[i].flags =
1252                                 BD_FLG_TCP_UDP_SUM | BD_FLG_MINI;
1253         } else {
1254                 set_aceaddr(&info->rx_mini_ctrl.rngptr, 0);
1255                 info->rx_mini_ctrl.flags = RCB_FLG_RNG_DISABLE;
1256                 info->rx_mini_ctrl.max_len = 0;
1257         }
1258
1259         ap->rx_mini_skbprd = 0;
1260         atomic_set(&ap->cur_mini_bufs, 0);
1261
1262         set_aceaddr(&info->rx_return_ctrl.rngptr,
1263                     (ap->rx_ring_base_dma +
1264                      (sizeof(struct rx_desc) *
1265                       (RX_STD_RING_ENTRIES +
1266                        RX_JUMBO_RING_ENTRIES +
1267                        RX_MINI_RING_ENTRIES))));
1268         info->rx_return_ctrl.flags = 0;
1269         info->rx_return_ctrl.max_len = RX_RETURN_RING_ENTRIES;
1270
1271         memset(ap->rx_return_ring, 0,
1272                RX_RETURN_RING_ENTRIES * sizeof(struct rx_desc));
1273
1274         set_aceaddr(&info->rx_ret_prd_ptr, ap->rx_ret_prd_dma);
1275         *(ap->rx_ret_prd) = 0;
1276
1277         writel(TX_RING_BASE, &regs->WinBase);
1278
1279         if (ACE_IS_TIGON_I(ap)) {
1280                 ap->tx_ring = (__force struct tx_desc *) regs->Window;
1281                 for (i = 0; i < (TIGON_I_TX_RING_ENTRIES
1282                                  * sizeof(struct tx_desc)) / sizeof(u32); i++)
1283                         writel(0, (__force void __iomem *)ap->tx_ring  + i * 4);
1284
1285                 set_aceaddr(&info->tx_ctrl.rngptr, TX_RING_BASE);
1286         } else {
1287                 memset(ap->tx_ring, 0,
1288                        MAX_TX_RING_ENTRIES * sizeof(struct tx_desc));
1289
1290                 set_aceaddr(&info->tx_ctrl.rngptr, ap->tx_ring_dma);
1291         }
1292
1293         info->tx_ctrl.max_len = ACE_TX_RING_ENTRIES(ap);
1294         tmp = RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1295
1296         /*
1297          * The Tigon I does not like having the TX ring in host memory ;-(
1298          */
1299         if (!ACE_IS_TIGON_I(ap))
1300                 tmp |= RCB_FLG_TX_HOST_RING;
1301 #if TX_COAL_INTS_ONLY
1302         tmp |= RCB_FLG_COAL_INT_ONLY;
1303 #endif
1304         info->tx_ctrl.flags = tmp;
1305
1306         set_aceaddr(&info->tx_csm_ptr, ap->tx_csm_dma);
1307
1308         /*
1309          * Potential item for tuning parameter
1310          */
1311 #if 0 /* NO */
1312         writel(DMA_THRESH_16W, &regs->DmaReadCfg);
1313         writel(DMA_THRESH_16W, &regs->DmaWriteCfg);
1314 #else
1315         writel(DMA_THRESH_8W, &regs->DmaReadCfg);
1316         writel(DMA_THRESH_8W, &regs->DmaWriteCfg);
1317 #endif
1318
1319         writel(0, &regs->MaskInt);
1320         writel(1, &regs->IfIdx);
1321 #if 0
1322         /*
1323          * McKinley boxes do not like us fiddling with AssistState
1324          * this early
1325          */
1326         writel(1, &regs->AssistState);
1327 #endif
1328
1329         writel(DEF_STAT, &regs->TuneStatTicks);
1330         writel(DEF_TRACE, &regs->TuneTrace);
1331
1332         ace_set_rxtx_parms(dev, 0);
1333
1334         if (board_idx == BOARD_IDX_OVERFLOW) {
1335                 printk(KERN_WARNING "%s: more than %i NICs detected, "
1336                        "ignoring module parameters!\n",
1337                        ap->name, ACE_MAX_MOD_PARMS);
1338         } else if (board_idx >= 0) {
1339                 if (tx_coal_tick[board_idx])
1340                         writel(tx_coal_tick[board_idx],
1341                                &regs->TuneTxCoalTicks);
1342                 if (max_tx_desc[board_idx])
1343                         writel(max_tx_desc[board_idx], &regs->TuneMaxTxDesc);
1344
1345                 if (rx_coal_tick[board_idx])
1346                         writel(rx_coal_tick[board_idx],
1347                                &regs->TuneRxCoalTicks);
1348                 if (max_rx_desc[board_idx])
1349                         writel(max_rx_desc[board_idx], &regs->TuneMaxRxDesc);
1350
1351                 if (trace[board_idx])
1352                         writel(trace[board_idx], &regs->TuneTrace);
1353
1354                 if ((tx_ratio[board_idx] > 0) && (tx_ratio[board_idx] < 64))
1355                         writel(tx_ratio[board_idx], &regs->TxBufRat);
1356         }
1357
1358         /*
1359          * Default link parameters
1360          */
1361         tmp = LNK_ENABLE | LNK_FULL_DUPLEX | LNK_1000MB | LNK_100MB |
1362                 LNK_10MB | LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL | LNK_NEGOTIATE;
1363         if(ap->version >= 2)
1364                 tmp |= LNK_TX_FLOW_CTL_Y;
1365
1366         /*
1367          * Override link default parameters
1368          */
1369         if ((board_idx >= 0) && link_state[board_idx]) {
1370                 int option = link_state[board_idx];
1371
1372                 tmp = LNK_ENABLE;
1373
1374                 if (option & 0x01) {
1375                         printk(KERN_INFO "%s: Setting half duplex link\n",
1376                                ap->name);
1377                         tmp &= ~LNK_FULL_DUPLEX;
1378                 }
1379                 if (option & 0x02)
1380                         tmp &= ~LNK_NEGOTIATE;
1381                 if (option & 0x10)
1382                         tmp |= LNK_10MB;
1383                 if (option & 0x20)
1384                         tmp |= LNK_100MB;
1385                 if (option & 0x40)
1386                         tmp |= LNK_1000MB;
1387                 if ((option & 0x70) == 0) {
1388                         printk(KERN_WARNING "%s: No media speed specified, "
1389                                "forcing auto negotiation\n", ap->name);
1390                         tmp |= LNK_NEGOTIATE | LNK_1000MB |
1391                                 LNK_100MB | LNK_10MB;
1392                 }
1393                 if ((option & 0x100) == 0)
1394                         tmp |= LNK_NEG_FCTL;
1395                 else
1396                         printk(KERN_INFO "%s: Disabling flow control "
1397                                "negotiation\n", ap->name);
1398                 if (option & 0x200)
1399                         tmp |= LNK_RX_FLOW_CTL_Y;
1400                 if ((option & 0x400) && (ap->version >= 2)) {
1401                         printk(KERN_INFO "%s: Enabling TX flow control\n",
1402                                ap->name);
1403                         tmp |= LNK_TX_FLOW_CTL_Y;
1404                 }
1405         }
1406
1407         ap->link = tmp;
1408         writel(tmp, &regs->TuneLink);
1409         if (ap->version >= 2)
1410                 writel(tmp, &regs->TuneFastLink);
1411
1412         writel(ap->firmware_start, &regs->Pc);
1413
1414         writel(0, &regs->Mb0Lo);
1415
1416         /*
1417          * Set tx_csm before we start receiving interrupts, otherwise
1418          * the interrupt handler might think it is supposed to process
1419          * tx ints before we are up and running, which may cause a null
1420          * pointer access in the int handler.
1421          */
1422         ap->cur_rx = 0;
1423         ap->tx_prd = *(ap->tx_csm) = ap->tx_ret_csm = 0;
1424
1425         wmb();
1426         ace_set_txprd(regs, ap, 0);
1427         writel(0, &regs->RxRetCsm);
1428
1429         /*
1430          * Enable DMA engine now.
1431          * If we do this sooner, Mckinley box pukes.
1432          * I assume it's because Tigon II DMA engine wants to check
1433          * *something* even before the CPU is started.
1434          */
1435         writel(1, &regs->AssistState);  /* enable DMA */
1436
1437         /*
1438          * Start the NIC CPU
1439          */
1440         writel(readl(&regs->CpuCtrl) & ~(CPU_HALT|CPU_TRACE), &regs->CpuCtrl);
1441         readl(&regs->CpuCtrl);
1442
1443         /*
1444          * Wait for the firmware to spin up - max 3 seconds.
1445          */
1446         myjif = jiffies + 3 * HZ;
1447         while (time_before(jiffies, myjif) && !ap->fw_running)
1448                 cpu_relax();
1449
1450         if (!ap->fw_running) {
1451                 printk(KERN_ERR "%s: Firmware NOT running!\n", ap->name);
1452
1453                 ace_dump_trace(ap);
1454                 writel(readl(&regs->CpuCtrl) | CPU_HALT, &regs->CpuCtrl);
1455                 readl(&regs->CpuCtrl);
1456
1457                 /* aman@sgi.com - account for badly behaving firmware/NIC:
1458                  * - have observed that the NIC may continue to generate
1459                  *   interrupts for some reason; attempt to stop it - halt
1460                  *   second CPU for Tigon II cards, and also clear Mb0
1461                  * - if we're a module, we'll fail to load if this was
1462                  *   the only GbE card in the system => if the kernel does
1463                  *   see an interrupt from the NIC, code to handle it is
1464                  *   gone and OOps! - so free_irq also
1465                  */
1466                 if (ap->version >= 2)
1467                         writel(readl(&regs->CpuBCtrl) | CPU_HALT,
1468                                &regs->CpuBCtrl);
1469                 writel(0, &regs->Mb0Lo);
1470                 readl(&regs->Mb0Lo);
1471
1472                 ecode = -EBUSY;
1473                 goto init_error;
1474         }
1475
1476         /*
1477          * We load the ring here as there seem to be no way to tell the
1478          * firmware to wipe the ring without re-initializing it.
1479          */
1480         if (!test_and_set_bit(0, &ap->std_refill_busy))
1481                 ace_load_std_rx_ring(dev, RX_RING_SIZE);
1482         else
1483                 printk(KERN_ERR "%s: Someone is busy refilling the RX ring\n",
1484                        ap->name);
1485         if (ap->version >= 2) {
1486                 if (!test_and_set_bit(0, &ap->mini_refill_busy))
1487                         ace_load_mini_rx_ring(dev, RX_MINI_SIZE);
1488                 else
1489                         printk(KERN_ERR "%s: Someone is busy refilling "
1490                                "the RX mini ring\n", ap->name);
1491         }
1492         return 0;
1493
1494  init_error:
1495         ace_init_cleanup(dev);
1496         return ecode;
1497 }
1498
1499
1500 static void ace_set_rxtx_parms(struct net_device *dev, int jumbo)
1501 {
1502         struct ace_private *ap = netdev_priv(dev);
1503         struct ace_regs __iomem *regs = ap->regs;
1504         int board_idx = ap->board_idx;
1505
1506         if (board_idx >= 0) {
1507                 if (!jumbo) {
1508                         if (!tx_coal_tick[board_idx])
1509                                 writel(DEF_TX_COAL, &regs->TuneTxCoalTicks);
1510                         if (!max_tx_desc[board_idx])
1511                                 writel(DEF_TX_MAX_DESC, &regs->TuneMaxTxDesc);
1512                         if (!rx_coal_tick[board_idx])
1513                                 writel(DEF_RX_COAL, &regs->TuneRxCoalTicks);
1514                         if (!max_rx_desc[board_idx])
1515                                 writel(DEF_RX_MAX_DESC, &regs->TuneMaxRxDesc);
1516                         if (!tx_ratio[board_idx])
1517                                 writel(DEF_TX_RATIO, &regs->TxBufRat);
1518                 } else {
1519                         if (!tx_coal_tick[board_idx])
1520                                 writel(DEF_JUMBO_TX_COAL,
1521                                        &regs->TuneTxCoalTicks);
1522                         if (!max_tx_desc[board_idx])
1523                                 writel(DEF_JUMBO_TX_MAX_DESC,
1524                                        &regs->TuneMaxTxDesc);
1525                         if (!rx_coal_tick[board_idx])
1526                                 writel(DEF_JUMBO_RX_COAL,
1527                                        &regs->TuneRxCoalTicks);
1528                         if (!max_rx_desc[board_idx])
1529                                 writel(DEF_JUMBO_RX_MAX_DESC,
1530                                        &regs->TuneMaxRxDesc);
1531                         if (!tx_ratio[board_idx])
1532                                 writel(DEF_JUMBO_TX_RATIO, &regs->TxBufRat);
1533                 }
1534         }
1535 }
1536
1537
1538 static void ace_watchdog(struct net_device *data, unsigned int txqueue)
1539 {
1540         struct net_device *dev = data;
1541         struct ace_private *ap = netdev_priv(dev);
1542         struct ace_regs __iomem *regs = ap->regs;
1543
1544         /*
1545          * We haven't received a stats update event for more than 2.5
1546          * seconds and there is data in the transmit queue, thus we
1547          * assume the card is stuck.
1548          */
1549         if (*ap->tx_csm != ap->tx_ret_csm) {
1550                 printk(KERN_WARNING "%s: Transmitter is stuck, %08x\n",
1551                        dev->name, (unsigned int)readl(&regs->HostCtrl));
1552                 /* This can happen due to ieee flow control. */
1553         } else {
1554                 printk(KERN_DEBUG "%s: BUG... transmitter died. Kicking it.\n",
1555                        dev->name);
1556 #if 0
1557                 netif_wake_queue(dev);
1558 #endif
1559         }
1560 }
1561
1562
1563 static void ace_tasklet(struct tasklet_struct *t)
1564 {
1565         struct ace_private *ap = from_tasklet(ap, t, ace_tasklet);
1566         struct net_device *dev = ap->ndev;
1567         int cur_size;
1568
1569         cur_size = atomic_read(&ap->cur_rx_bufs);
1570         if ((cur_size < RX_LOW_STD_THRES) &&
1571             !test_and_set_bit(0, &ap->std_refill_busy)) {
1572 #ifdef DEBUG
1573                 printk("refilling buffers (current %i)\n", cur_size);
1574 #endif
1575                 ace_load_std_rx_ring(dev, RX_RING_SIZE - cur_size);
1576         }
1577
1578         if (ap->version >= 2) {
1579                 cur_size = atomic_read(&ap->cur_mini_bufs);
1580                 if ((cur_size < RX_LOW_MINI_THRES) &&
1581                     !test_and_set_bit(0, &ap->mini_refill_busy)) {
1582 #ifdef DEBUG
1583                         printk("refilling mini buffers (current %i)\n",
1584                                cur_size);
1585 #endif
1586                         ace_load_mini_rx_ring(dev, RX_MINI_SIZE - cur_size);
1587                 }
1588         }
1589
1590         cur_size = atomic_read(&ap->cur_jumbo_bufs);
1591         if (ap->jumbo && (cur_size < RX_LOW_JUMBO_THRES) &&
1592             !test_and_set_bit(0, &ap->jumbo_refill_busy)) {
1593 #ifdef DEBUG
1594                 printk("refilling jumbo buffers (current %i)\n", cur_size);
1595 #endif
1596                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE - cur_size);
1597         }
1598         ap->tasklet_pending = 0;
1599 }
1600
1601
1602 /*
1603  * Copy the contents of the NIC's trace buffer to kernel memory.
1604  */
1605 static void ace_dump_trace(struct ace_private *ap)
1606 {
1607 #if 0
1608         if (!ap->trace_buf)
1609                 if (!(ap->trace_buf = kmalloc(ACE_TRACE_SIZE, GFP_KERNEL)))
1610                     return;
1611 #endif
1612 }
1613
1614
1615 /*
1616  * Load the standard rx ring.
1617  *
1618  * Loading rings is safe without holding the spin lock since this is
1619  * done only before the device is enabled, thus no interrupts are
1620  * generated and by the interrupt handler/tasklet handler.
1621  */
1622 static void ace_load_std_rx_ring(struct net_device *dev, int nr_bufs)
1623 {
1624         struct ace_private *ap = netdev_priv(dev);
1625         struct ace_regs __iomem *regs = ap->regs;
1626         short i, idx;
1627
1628
1629         prefetchw(&ap->cur_rx_bufs);
1630
1631         idx = ap->rx_std_skbprd;
1632
1633         for (i = 0; i < nr_bufs; i++) {
1634                 struct sk_buff *skb;
1635                 struct rx_desc *rd;
1636                 dma_addr_t mapping;
1637
1638                 skb = netdev_alloc_skb_ip_align(dev, ACE_STD_BUFSIZE);
1639                 if (!skb)
1640                         break;
1641
1642                 mapping = dma_map_page(&ap->pdev->dev,
1643                                        virt_to_page(skb->data),
1644                                        offset_in_page(skb->data),
1645                                        ACE_STD_BUFSIZE, DMA_FROM_DEVICE);
1646                 ap->skb->rx_std_skbuff[idx].skb = skb;
1647                 dma_unmap_addr_set(&ap->skb->rx_std_skbuff[idx],
1648                                    mapping, mapping);
1649
1650                 rd = &ap->rx_std_ring[idx];
1651                 set_aceaddr(&rd->addr, mapping);
1652                 rd->size = ACE_STD_BUFSIZE;
1653                 rd->idx = idx;
1654                 idx = (idx + 1) % RX_STD_RING_ENTRIES;
1655         }
1656
1657         if (!i)
1658                 goto error_out;
1659
1660         atomic_add(i, &ap->cur_rx_bufs);
1661         ap->rx_std_skbprd = idx;
1662
1663         if (ACE_IS_TIGON_I(ap)) {
1664                 struct cmd cmd;
1665                 cmd.evt = C_SET_RX_PRD_IDX;
1666                 cmd.code = 0;
1667                 cmd.idx = ap->rx_std_skbprd;
1668                 ace_issue_cmd(regs, &cmd);
1669         } else {
1670                 writel(idx, &regs->RxStdPrd);
1671                 wmb();
1672         }
1673
1674  out:
1675         clear_bit(0, &ap->std_refill_busy);
1676         return;
1677
1678  error_out:
1679         printk(KERN_INFO "Out of memory when allocating "
1680                "standard receive buffers\n");
1681         goto out;
1682 }
1683
1684
1685 static void ace_load_mini_rx_ring(struct net_device *dev, int nr_bufs)
1686 {
1687         struct ace_private *ap = netdev_priv(dev);
1688         struct ace_regs __iomem *regs = ap->regs;
1689         short i, idx;
1690
1691         prefetchw(&ap->cur_mini_bufs);
1692
1693         idx = ap->rx_mini_skbprd;
1694         for (i = 0; i < nr_bufs; i++) {
1695                 struct sk_buff *skb;
1696                 struct rx_desc *rd;
1697                 dma_addr_t mapping;
1698
1699                 skb = netdev_alloc_skb_ip_align(dev, ACE_MINI_BUFSIZE);
1700                 if (!skb)
1701                         break;
1702
1703                 mapping = dma_map_page(&ap->pdev->dev,
1704                                        virt_to_page(skb->data),
1705                                        offset_in_page(skb->data),
1706                                        ACE_MINI_BUFSIZE, DMA_FROM_DEVICE);
1707                 ap->skb->rx_mini_skbuff[idx].skb = skb;
1708                 dma_unmap_addr_set(&ap->skb->rx_mini_skbuff[idx],
1709                                    mapping, mapping);
1710
1711                 rd = &ap->rx_mini_ring[idx];
1712                 set_aceaddr(&rd->addr, mapping);
1713                 rd->size = ACE_MINI_BUFSIZE;
1714                 rd->idx = idx;
1715                 idx = (idx + 1) % RX_MINI_RING_ENTRIES;
1716         }
1717
1718         if (!i)
1719                 goto error_out;
1720
1721         atomic_add(i, &ap->cur_mini_bufs);
1722
1723         ap->rx_mini_skbprd = idx;
1724
1725         writel(idx, &regs->RxMiniPrd);
1726         wmb();
1727
1728  out:
1729         clear_bit(0, &ap->mini_refill_busy);
1730         return;
1731  error_out:
1732         printk(KERN_INFO "Out of memory when allocating "
1733                "mini receive buffers\n");
1734         goto out;
1735 }
1736
1737
1738 /*
1739  * Load the jumbo rx ring, this may happen at any time if the MTU
1740  * is changed to a value > 1500.
1741  */
1742 static void ace_load_jumbo_rx_ring(struct net_device *dev, int nr_bufs)
1743 {
1744         struct ace_private *ap = netdev_priv(dev);
1745         struct ace_regs __iomem *regs = ap->regs;
1746         short i, idx;
1747
1748         idx = ap->rx_jumbo_skbprd;
1749
1750         for (i = 0; i < nr_bufs; i++) {
1751                 struct sk_buff *skb;
1752                 struct rx_desc *rd;
1753                 dma_addr_t mapping;
1754
1755                 skb = netdev_alloc_skb_ip_align(dev, ACE_JUMBO_BUFSIZE);
1756                 if (!skb)
1757                         break;
1758
1759                 mapping = dma_map_page(&ap->pdev->dev,
1760                                        virt_to_page(skb->data),
1761                                        offset_in_page(skb->data),
1762                                        ACE_JUMBO_BUFSIZE, DMA_FROM_DEVICE);
1763                 ap->skb->rx_jumbo_skbuff[idx].skb = skb;
1764                 dma_unmap_addr_set(&ap->skb->rx_jumbo_skbuff[idx],
1765                                    mapping, mapping);
1766
1767                 rd = &ap->rx_jumbo_ring[idx];
1768                 set_aceaddr(&rd->addr, mapping);
1769                 rd->size = ACE_JUMBO_BUFSIZE;
1770                 rd->idx = idx;
1771                 idx = (idx + 1) % RX_JUMBO_RING_ENTRIES;
1772         }
1773
1774         if (!i)
1775                 goto error_out;
1776
1777         atomic_add(i, &ap->cur_jumbo_bufs);
1778         ap->rx_jumbo_skbprd = idx;
1779
1780         if (ACE_IS_TIGON_I(ap)) {
1781                 struct cmd cmd;
1782                 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1783                 cmd.code = 0;
1784                 cmd.idx = ap->rx_jumbo_skbprd;
1785                 ace_issue_cmd(regs, &cmd);
1786         } else {
1787                 writel(idx, &regs->RxJumboPrd);
1788                 wmb();
1789         }
1790
1791  out:
1792         clear_bit(0, &ap->jumbo_refill_busy);
1793         return;
1794  error_out:
1795         if (net_ratelimit())
1796                 printk(KERN_INFO "Out of memory when allocating "
1797                        "jumbo receive buffers\n");
1798         goto out;
1799 }
1800
1801
1802 /*
1803  * All events are considered to be slow (RX/TX ints do not generate
1804  * events) and are handled here, outside the main interrupt handler,
1805  * to reduce the size of the handler.
1806  */
1807 static u32 ace_handle_event(struct net_device *dev, u32 evtcsm, u32 evtprd)
1808 {
1809         struct ace_private *ap;
1810
1811         ap = netdev_priv(dev);
1812
1813         while (evtcsm != evtprd) {
1814                 switch (ap->evt_ring[evtcsm].evt) {
1815                 case E_FW_RUNNING:
1816                         printk(KERN_INFO "%s: Firmware up and running\n",
1817                                ap->name);
1818                         ap->fw_running = 1;
1819                         wmb();
1820                         break;
1821                 case E_STATS_UPDATED:
1822                         break;
1823                 case E_LNK_STATE:
1824                 {
1825                         u16 code = ap->evt_ring[evtcsm].code;
1826                         switch (code) {
1827                         case E_C_LINK_UP:
1828                         {
1829                                 u32 state = readl(&ap->regs->GigLnkState);
1830                                 printk(KERN_WARNING "%s: Optical link UP "
1831                                        "(%s Duplex, Flow Control: %s%s)\n",
1832                                        ap->name,
1833                                        state & LNK_FULL_DUPLEX ? "Full":"Half",
1834                                        state & LNK_TX_FLOW_CTL_Y ? "TX " : "",
1835                                        state & LNK_RX_FLOW_CTL_Y ? "RX" : "");
1836                                 break;
1837                         }
1838                         case E_C_LINK_DOWN:
1839                                 printk(KERN_WARNING "%s: Optical link DOWN\n",
1840                                        ap->name);
1841                                 break;
1842                         case E_C_LINK_10_100:
1843                                 printk(KERN_WARNING "%s: 10/100BaseT link "
1844                                        "UP\n", ap->name);
1845                                 break;
1846                         default:
1847                                 printk(KERN_ERR "%s: Unknown optical link "
1848                                        "state %02x\n", ap->name, code);
1849                         }
1850                         break;
1851                 }
1852                 case E_ERROR:
1853                         switch(ap->evt_ring[evtcsm].code) {
1854                         case E_C_ERR_INVAL_CMD:
1855                                 printk(KERN_ERR "%s: invalid command error\n",
1856                                        ap->name);
1857                                 break;
1858                         case E_C_ERR_UNIMP_CMD:
1859                                 printk(KERN_ERR "%s: unimplemented command "
1860                                        "error\n", ap->name);
1861                                 break;
1862                         case E_C_ERR_BAD_CFG:
1863                                 printk(KERN_ERR "%s: bad config error\n",
1864                                        ap->name);
1865                                 break;
1866                         default:
1867                                 printk(KERN_ERR "%s: unknown error %02x\n",
1868                                        ap->name, ap->evt_ring[evtcsm].code);
1869                         }
1870                         break;
1871                 case E_RESET_JUMBO_RNG:
1872                 {
1873                         int i;
1874                         for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
1875                                 if (ap->skb->rx_jumbo_skbuff[i].skb) {
1876                                         ap->rx_jumbo_ring[i].size = 0;
1877                                         set_aceaddr(&ap->rx_jumbo_ring[i].addr, 0);
1878                                         dev_kfree_skb(ap->skb->rx_jumbo_skbuff[i].skb);
1879                                         ap->skb->rx_jumbo_skbuff[i].skb = NULL;
1880                                 }
1881                         }
1882
1883                         if (ACE_IS_TIGON_I(ap)) {
1884                                 struct cmd cmd;
1885                                 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1886                                 cmd.code = 0;
1887                                 cmd.idx = 0;
1888                                 ace_issue_cmd(ap->regs, &cmd);
1889                         } else {
1890                                 writel(0, &((ap->regs)->RxJumboPrd));
1891                                 wmb();
1892                         }
1893
1894                         ap->jumbo = 0;
1895                         ap->rx_jumbo_skbprd = 0;
1896                         printk(KERN_INFO "%s: Jumbo ring flushed\n",
1897                                ap->name);
1898                         clear_bit(0, &ap->jumbo_refill_busy);
1899                         break;
1900                 }
1901                 default:
1902                         printk(KERN_ERR "%s: Unhandled event 0x%02x\n",
1903                                ap->name, ap->evt_ring[evtcsm].evt);
1904                 }
1905                 evtcsm = (evtcsm + 1) % EVT_RING_ENTRIES;
1906         }
1907
1908         return evtcsm;
1909 }
1910
1911
1912 static void ace_rx_int(struct net_device *dev, u32 rxretprd, u32 rxretcsm)
1913 {
1914         struct ace_private *ap = netdev_priv(dev);
1915         u32 idx;
1916         int mini_count = 0, std_count = 0;
1917
1918         idx = rxretcsm;
1919
1920         prefetchw(&ap->cur_rx_bufs);
1921         prefetchw(&ap->cur_mini_bufs);
1922
1923         while (idx != rxretprd) {
1924                 struct ring_info *rip;
1925                 struct sk_buff *skb;
1926                 struct rx_desc *retdesc;
1927                 u32 skbidx;
1928                 int bd_flags, desc_type, mapsize;
1929                 u16 csum;
1930
1931
1932                 /* make sure the rx descriptor isn't read before rxretprd */
1933                 if (idx == rxretcsm)
1934                         rmb();
1935
1936                 retdesc = &ap->rx_return_ring[idx];
1937                 skbidx = retdesc->idx;
1938                 bd_flags = retdesc->flags;
1939                 desc_type = bd_flags & (BD_FLG_JUMBO | BD_FLG_MINI);
1940
1941                 switch(desc_type) {
1942                         /*
1943                          * Normal frames do not have any flags set
1944                          *
1945                          * Mini and normal frames arrive frequently,
1946                          * so use a local counter to avoid doing
1947                          * atomic operations for each packet arriving.
1948                          */
1949                 case 0:
1950                         rip = &ap->skb->rx_std_skbuff[skbidx];
1951                         mapsize = ACE_STD_BUFSIZE;
1952                         std_count++;
1953                         break;
1954                 case BD_FLG_JUMBO:
1955                         rip = &ap->skb->rx_jumbo_skbuff[skbidx];
1956                         mapsize = ACE_JUMBO_BUFSIZE;
1957                         atomic_dec(&ap->cur_jumbo_bufs);
1958                         break;
1959                 case BD_FLG_MINI:
1960                         rip = &ap->skb->rx_mini_skbuff[skbidx];
1961                         mapsize = ACE_MINI_BUFSIZE;
1962                         mini_count++;
1963                         break;
1964                 default:
1965                         printk(KERN_INFO "%s: unknown frame type (0x%02x) "
1966                                "returned by NIC\n", dev->name,
1967                                retdesc->flags);
1968                         goto error;
1969                 }
1970
1971                 skb = rip->skb;
1972                 rip->skb = NULL;
1973                 dma_unmap_page(&ap->pdev->dev, dma_unmap_addr(rip, mapping),
1974                                mapsize, DMA_FROM_DEVICE);
1975                 skb_put(skb, retdesc->size);
1976
1977                 /*
1978                  * Fly baby, fly!
1979                  */
1980                 csum = retdesc->tcp_udp_csum;
1981
1982                 skb->protocol = eth_type_trans(skb, dev);
1983
1984                 /*
1985                  * Instead of forcing the poor tigon mips cpu to calculate
1986                  * pseudo hdr checksum, we do this ourselves.
1987                  */
1988                 if (bd_flags & BD_FLG_TCP_UDP_SUM) {
1989                         skb->csum = htons(csum);
1990                         skb->ip_summed = CHECKSUM_COMPLETE;
1991                 } else {
1992                         skb_checksum_none_assert(skb);
1993                 }
1994
1995                 /* send it up */
1996                 if ((bd_flags & BD_FLG_VLAN_TAG))
1997                         __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), retdesc->vlan);
1998                 netif_rx(skb);
1999
2000                 dev->stats.rx_packets++;
2001                 dev->stats.rx_bytes += retdesc->size;
2002
2003                 idx = (idx + 1) % RX_RETURN_RING_ENTRIES;
2004         }
2005
2006         atomic_sub(std_count, &ap->cur_rx_bufs);
2007         if (!ACE_IS_TIGON_I(ap))
2008                 atomic_sub(mini_count, &ap->cur_mini_bufs);
2009
2010  out:
2011         /*
2012          * According to the documentation RxRetCsm is obsolete with
2013          * the 12.3.x Firmware - my Tigon I NICs seem to disagree!
2014          */
2015         if (ACE_IS_TIGON_I(ap)) {
2016                 writel(idx, &ap->regs->RxRetCsm);
2017         }
2018         ap->cur_rx = idx;
2019
2020         return;
2021  error:
2022         idx = rxretprd;
2023         goto out;
2024 }
2025
2026
2027 static inline void ace_tx_int(struct net_device *dev,
2028                               u32 txcsm, u32 idx)
2029 {
2030         struct ace_private *ap = netdev_priv(dev);
2031
2032         do {
2033                 struct sk_buff *skb;
2034                 struct tx_ring_info *info;
2035
2036                 info = ap->skb->tx_skbuff + idx;
2037                 skb = info->skb;
2038
2039                 if (dma_unmap_len(info, maplen)) {
2040                         dma_unmap_page(&ap->pdev->dev,
2041                                        dma_unmap_addr(info, mapping),
2042                                        dma_unmap_len(info, maplen),
2043                                        DMA_TO_DEVICE);
2044                         dma_unmap_len_set(info, maplen, 0);
2045                 }
2046
2047                 if (skb) {
2048                         dev->stats.tx_packets++;
2049                         dev->stats.tx_bytes += skb->len;
2050                         dev_consume_skb_irq(skb);
2051                         info->skb = NULL;
2052                 }
2053
2054                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2055         } while (idx != txcsm);
2056
2057         if (netif_queue_stopped(dev))
2058                 netif_wake_queue(dev);
2059
2060         wmb();
2061         ap->tx_ret_csm = txcsm;
2062
2063         /* So... tx_ret_csm is advanced _after_ check for device wakeup.
2064          *
2065          * We could try to make it before. In this case we would get
2066          * the following race condition: hard_start_xmit on other cpu
2067          * enters after we advanced tx_ret_csm and fills space,
2068          * which we have just freed, so that we make illegal device wakeup.
2069          * There is no good way to workaround this (at entry
2070          * to ace_start_xmit detects this condition and prevents
2071          * ring corruption, but it is not a good workaround.)
2072          *
2073          * When tx_ret_csm is advanced after, we wake up device _only_
2074          * if we really have some space in ring (though the core doing
2075          * hard_start_xmit can see full ring for some period and has to
2076          * synchronize.) Superb.
2077          * BUT! We get another subtle race condition. hard_start_xmit
2078          * may think that ring is full between wakeup and advancing
2079          * tx_ret_csm and will stop device instantly! It is not so bad.
2080          * We are guaranteed that there is something in ring, so that
2081          * the next irq will resume transmission. To speedup this we could
2082          * mark descriptor, which closes ring with BD_FLG_COAL_NOW
2083          * (see ace_start_xmit).
2084          *
2085          * Well, this dilemma exists in all lock-free devices.
2086          * We, following scheme used in drivers by Donald Becker,
2087          * select the least dangerous.
2088          *                                                      --ANK
2089          */
2090 }
2091
2092
2093 static irqreturn_t ace_interrupt(int irq, void *dev_id)
2094 {
2095         struct net_device *dev = (struct net_device *)dev_id;
2096         struct ace_private *ap = netdev_priv(dev);
2097         struct ace_regs __iomem *regs = ap->regs;
2098         u32 idx;
2099         u32 txcsm, rxretcsm, rxretprd;
2100         u32 evtcsm, evtprd;
2101
2102         /*
2103          * In case of PCI shared interrupts or spurious interrupts,
2104          * we want to make sure it is actually our interrupt before
2105          * spending any time in here.
2106          */
2107         if (!(readl(&regs->HostCtrl) & IN_INT))
2108                 return IRQ_NONE;
2109
2110         /*
2111          * ACK intr now. Otherwise we will lose updates to rx_ret_prd,
2112          * which happened _after_ rxretprd = *ap->rx_ret_prd; but before
2113          * writel(0, &regs->Mb0Lo).
2114          *
2115          * "IRQ avoidance" recommended in docs applies to IRQs served
2116          * threads and it is wrong even for that case.
2117          */
2118         writel(0, &regs->Mb0Lo);
2119         readl(&regs->Mb0Lo);
2120
2121         /*
2122          * There is no conflict between transmit handling in
2123          * start_xmit and receive processing, thus there is no reason
2124          * to take a spin lock for RX handling. Wait until we start
2125          * working on the other stuff - hey we don't need a spin lock
2126          * anymore.
2127          */
2128         rxretprd = *ap->rx_ret_prd;
2129         rxretcsm = ap->cur_rx;
2130
2131         if (rxretprd != rxretcsm)
2132                 ace_rx_int(dev, rxretprd, rxretcsm);
2133
2134         txcsm = *ap->tx_csm;
2135         idx = ap->tx_ret_csm;
2136
2137         if (txcsm != idx) {
2138                 /*
2139                  * If each skb takes only one descriptor this check degenerates
2140                  * to identity, because new space has just been opened.
2141                  * But if skbs are fragmented we must check that this index
2142                  * update releases enough of space, otherwise we just
2143                  * wait for device to make more work.
2144                  */
2145                 if (!tx_ring_full(ap, txcsm, ap->tx_prd))
2146                         ace_tx_int(dev, txcsm, idx);
2147         }
2148
2149         evtcsm = readl(&regs->EvtCsm);
2150         evtprd = *ap->evt_prd;
2151
2152         if (evtcsm != evtprd) {
2153                 evtcsm = ace_handle_event(dev, evtcsm, evtprd);
2154                 writel(evtcsm, &regs->EvtCsm);
2155         }
2156
2157         /*
2158          * This has to go last in the interrupt handler and run with
2159          * the spin lock released ... what lock?
2160          */
2161         if (netif_running(dev)) {
2162                 int cur_size;
2163                 int run_tasklet = 0;
2164
2165                 cur_size = atomic_read(&ap->cur_rx_bufs);
2166                 if (cur_size < RX_LOW_STD_THRES) {
2167                         if ((cur_size < RX_PANIC_STD_THRES) &&
2168                             !test_and_set_bit(0, &ap->std_refill_busy)) {
2169 #ifdef DEBUG
2170                                 printk("low on std buffers %i\n", cur_size);
2171 #endif
2172                                 ace_load_std_rx_ring(dev,
2173                                                      RX_RING_SIZE - cur_size);
2174                         } else
2175                                 run_tasklet = 1;
2176                 }
2177
2178                 if (!ACE_IS_TIGON_I(ap)) {
2179                         cur_size = atomic_read(&ap->cur_mini_bufs);
2180                         if (cur_size < RX_LOW_MINI_THRES) {
2181                                 if ((cur_size < RX_PANIC_MINI_THRES) &&
2182                                     !test_and_set_bit(0,
2183                                                       &ap->mini_refill_busy)) {
2184 #ifdef DEBUG
2185                                         printk("low on mini buffers %i\n",
2186                                                cur_size);
2187 #endif
2188                                         ace_load_mini_rx_ring(dev,
2189                                                               RX_MINI_SIZE - cur_size);
2190                                 } else
2191                                         run_tasklet = 1;
2192                         }
2193                 }
2194
2195                 if (ap->jumbo) {
2196                         cur_size = atomic_read(&ap->cur_jumbo_bufs);
2197                         if (cur_size < RX_LOW_JUMBO_THRES) {
2198                                 if ((cur_size < RX_PANIC_JUMBO_THRES) &&
2199                                     !test_and_set_bit(0,
2200                                                       &ap->jumbo_refill_busy)){
2201 #ifdef DEBUG
2202                                         printk("low on jumbo buffers %i\n",
2203                                                cur_size);
2204 #endif
2205                                         ace_load_jumbo_rx_ring(dev,
2206                                                                RX_JUMBO_SIZE - cur_size);
2207                                 } else
2208                                         run_tasklet = 1;
2209                         }
2210                 }
2211                 if (run_tasklet && !ap->tasklet_pending) {
2212                         ap->tasklet_pending = 1;
2213                         tasklet_schedule(&ap->ace_tasklet);
2214                 }
2215         }
2216
2217         return IRQ_HANDLED;
2218 }
2219
2220 static int ace_open(struct net_device *dev)
2221 {
2222         struct ace_private *ap = netdev_priv(dev);
2223         struct ace_regs __iomem *regs = ap->regs;
2224         struct cmd cmd;
2225
2226         if (!(ap->fw_running)) {
2227                 printk(KERN_WARNING "%s: Firmware not running!\n", dev->name);
2228                 return -EBUSY;
2229         }
2230
2231         writel(dev->mtu + ETH_HLEN + 4, &regs->IfMtu);
2232
2233         cmd.evt = C_CLEAR_STATS;
2234         cmd.code = 0;
2235         cmd.idx = 0;
2236         ace_issue_cmd(regs, &cmd);
2237
2238         cmd.evt = C_HOST_STATE;
2239         cmd.code = C_C_STACK_UP;
2240         cmd.idx = 0;
2241         ace_issue_cmd(regs, &cmd);
2242
2243         if (ap->jumbo &&
2244             !test_and_set_bit(0, &ap->jumbo_refill_busy))
2245                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2246
2247         if (dev->flags & IFF_PROMISC) {
2248                 cmd.evt = C_SET_PROMISC_MODE;
2249                 cmd.code = C_C_PROMISC_ENABLE;
2250                 cmd.idx = 0;
2251                 ace_issue_cmd(regs, &cmd);
2252
2253                 ap->promisc = 1;
2254         }else
2255                 ap->promisc = 0;
2256         ap->mcast_all = 0;
2257
2258 #if 0
2259         cmd.evt = C_LNK_NEGOTIATION;
2260         cmd.code = 0;
2261         cmd.idx = 0;
2262         ace_issue_cmd(regs, &cmd);
2263 #endif
2264
2265         netif_start_queue(dev);
2266
2267         /*
2268          * Setup the bottom half rx ring refill handler
2269          */
2270         tasklet_setup(&ap->ace_tasklet, ace_tasklet);
2271         return 0;
2272 }
2273
2274
2275 static int ace_close(struct net_device *dev)
2276 {
2277         struct ace_private *ap = netdev_priv(dev);
2278         struct ace_regs __iomem *regs = ap->regs;
2279         struct cmd cmd;
2280         unsigned long flags;
2281         short i;
2282
2283         /*
2284          * Without (or before) releasing irq and stopping hardware, this
2285          * is an absolute non-sense, by the way. It will be reset instantly
2286          * by the first irq.
2287          */
2288         netif_stop_queue(dev);
2289
2290
2291         if (ap->promisc) {
2292                 cmd.evt = C_SET_PROMISC_MODE;
2293                 cmd.code = C_C_PROMISC_DISABLE;
2294                 cmd.idx = 0;
2295                 ace_issue_cmd(regs, &cmd);
2296                 ap->promisc = 0;
2297         }
2298
2299         cmd.evt = C_HOST_STATE;
2300         cmd.code = C_C_STACK_DOWN;
2301         cmd.idx = 0;
2302         ace_issue_cmd(regs, &cmd);
2303
2304         tasklet_kill(&ap->ace_tasklet);
2305
2306         /*
2307          * Make sure one CPU is not processing packets while
2308          * buffers are being released by another.
2309          */
2310
2311         local_irq_save(flags);
2312         ace_mask_irq(dev);
2313
2314         for (i = 0; i < ACE_TX_RING_ENTRIES(ap); i++) {
2315                 struct sk_buff *skb;
2316                 struct tx_ring_info *info;
2317
2318                 info = ap->skb->tx_skbuff + i;
2319                 skb = info->skb;
2320
2321                 if (dma_unmap_len(info, maplen)) {
2322                         if (ACE_IS_TIGON_I(ap)) {
2323                                 /* NB: TIGON_1 is special, tx_ring is in io space */
2324                                 struct tx_desc __iomem *tx;
2325                                 tx = (__force struct tx_desc __iomem *) &ap->tx_ring[i];
2326                                 writel(0, &tx->addr.addrhi);
2327                                 writel(0, &tx->addr.addrlo);
2328                                 writel(0, &tx->flagsize);
2329                         } else
2330                                 memset(ap->tx_ring + i, 0,
2331                                        sizeof(struct tx_desc));
2332                         dma_unmap_page(&ap->pdev->dev,
2333                                        dma_unmap_addr(info, mapping),
2334                                        dma_unmap_len(info, maplen),
2335                                        DMA_TO_DEVICE);
2336                         dma_unmap_len_set(info, maplen, 0);
2337                 }
2338                 if (skb) {
2339                         dev_kfree_skb(skb);
2340                         info->skb = NULL;
2341                 }
2342         }
2343
2344         if (ap->jumbo) {
2345                 cmd.evt = C_RESET_JUMBO_RNG;
2346                 cmd.code = 0;
2347                 cmd.idx = 0;
2348                 ace_issue_cmd(regs, &cmd);
2349         }
2350
2351         ace_unmask_irq(dev);
2352         local_irq_restore(flags);
2353
2354         return 0;
2355 }
2356
2357
2358 static inline dma_addr_t
2359 ace_map_tx_skb(struct ace_private *ap, struct sk_buff *skb,
2360                struct sk_buff *tail, u32 idx)
2361 {
2362         dma_addr_t mapping;
2363         struct tx_ring_info *info;
2364
2365         mapping = dma_map_page(&ap->pdev->dev, virt_to_page(skb->data),
2366                                offset_in_page(skb->data), skb->len,
2367                                DMA_TO_DEVICE);
2368
2369         info = ap->skb->tx_skbuff + idx;
2370         info->skb = tail;
2371         dma_unmap_addr_set(info, mapping, mapping);
2372         dma_unmap_len_set(info, maplen, skb->len);
2373         return mapping;
2374 }
2375
2376
2377 static inline void
2378 ace_load_tx_bd(struct ace_private *ap, struct tx_desc *desc, u64 addr,
2379                u32 flagsize, u32 vlan_tag)
2380 {
2381 #if !USE_TX_COAL_NOW
2382         flagsize &= ~BD_FLG_COAL_NOW;
2383 #endif
2384
2385         if (ACE_IS_TIGON_I(ap)) {
2386                 struct tx_desc __iomem *io = (__force struct tx_desc __iomem *) desc;
2387                 writel(addr >> 32, &io->addr.addrhi);
2388                 writel(addr & 0xffffffff, &io->addr.addrlo);
2389                 writel(flagsize, &io->flagsize);
2390                 writel(vlan_tag, &io->vlanres);
2391         } else {
2392                 desc->addr.addrhi = addr >> 32;
2393                 desc->addr.addrlo = addr;
2394                 desc->flagsize = flagsize;
2395                 desc->vlanres = vlan_tag;
2396         }
2397 }
2398
2399
2400 static netdev_tx_t ace_start_xmit(struct sk_buff *skb,
2401                                   struct net_device *dev)
2402 {
2403         struct ace_private *ap = netdev_priv(dev);
2404         struct ace_regs __iomem *regs = ap->regs;
2405         struct tx_desc *desc;
2406         u32 idx, flagsize;
2407         unsigned long maxjiff = jiffies + 3*HZ;
2408
2409 restart:
2410         idx = ap->tx_prd;
2411
2412         if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2413                 goto overflow;
2414
2415         if (!skb_shinfo(skb)->nr_frags) {
2416                 dma_addr_t mapping;
2417                 u32 vlan_tag = 0;
2418
2419                 mapping = ace_map_tx_skb(ap, skb, skb, idx);
2420                 flagsize = (skb->len << 16) | (BD_FLG_END);
2421                 if (skb->ip_summed == CHECKSUM_PARTIAL)
2422                         flagsize |= BD_FLG_TCP_UDP_SUM;
2423                 if (skb_vlan_tag_present(skb)) {
2424                         flagsize |= BD_FLG_VLAN_TAG;
2425                         vlan_tag = skb_vlan_tag_get(skb);
2426                 }
2427                 desc = ap->tx_ring + idx;
2428                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2429
2430                 /* Look at ace_tx_int for explanations. */
2431                 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2432                         flagsize |= BD_FLG_COAL_NOW;
2433
2434                 ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2435         } else {
2436                 dma_addr_t mapping;
2437                 u32 vlan_tag = 0;
2438                 int i;
2439
2440                 mapping = ace_map_tx_skb(ap, skb, NULL, idx);
2441                 flagsize = (skb_headlen(skb) << 16);
2442                 if (skb->ip_summed == CHECKSUM_PARTIAL)
2443                         flagsize |= BD_FLG_TCP_UDP_SUM;
2444                 if (skb_vlan_tag_present(skb)) {
2445                         flagsize |= BD_FLG_VLAN_TAG;
2446                         vlan_tag = skb_vlan_tag_get(skb);
2447                 }
2448
2449                 ace_load_tx_bd(ap, ap->tx_ring + idx, mapping, flagsize, vlan_tag);
2450
2451                 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2452
2453                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2454                         const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2455                         struct tx_ring_info *info;
2456
2457                         info = ap->skb->tx_skbuff + idx;
2458                         desc = ap->tx_ring + idx;
2459
2460                         mapping = skb_frag_dma_map(&ap->pdev->dev, frag, 0,
2461                                                    skb_frag_size(frag),
2462                                                    DMA_TO_DEVICE);
2463
2464                         flagsize = skb_frag_size(frag) << 16;
2465                         if (skb->ip_summed == CHECKSUM_PARTIAL)
2466                                 flagsize |= BD_FLG_TCP_UDP_SUM;
2467                         idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2468
2469                         if (i == skb_shinfo(skb)->nr_frags - 1) {
2470                                 flagsize |= BD_FLG_END;
2471                                 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2472                                         flagsize |= BD_FLG_COAL_NOW;
2473
2474                                 /*
2475                                  * Only the last fragment frees
2476                                  * the skb!
2477                                  */
2478                                 info->skb = skb;
2479                         } else {
2480                                 info->skb = NULL;
2481                         }
2482                         dma_unmap_addr_set(info, mapping, mapping);
2483                         dma_unmap_len_set(info, maplen, skb_frag_size(frag));
2484                         ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2485                 }
2486         }
2487
2488         wmb();
2489         ap->tx_prd = idx;
2490         ace_set_txprd(regs, ap, idx);
2491
2492         if (flagsize & BD_FLG_COAL_NOW) {
2493                 netif_stop_queue(dev);
2494
2495                 /*
2496                  * A TX-descriptor producer (an IRQ) might have gotten
2497                  * between, making the ring free again. Since xmit is
2498                  * serialized, this is the only situation we have to
2499                  * re-test.
2500                  */
2501                 if (!tx_ring_full(ap, ap->tx_ret_csm, idx))
2502                         netif_wake_queue(dev);
2503         }
2504
2505         return NETDEV_TX_OK;
2506
2507 overflow:
2508         /*
2509          * This race condition is unavoidable with lock-free drivers.
2510          * We wake up the queue _before_ tx_prd is advanced, so that we can
2511          * enter hard_start_xmit too early, while tx ring still looks closed.
2512          * This happens ~1-4 times per 100000 packets, so that we can allow
2513          * to loop syncing to other CPU. Probably, we need an additional
2514          * wmb() in ace_tx_intr as well.
2515          *
2516          * Note that this race is relieved by reserving one more entry
2517          * in tx ring than it is necessary (see original non-SG driver).
2518          * However, with SG we need to reserve 2*MAX_SKB_FRAGS+1, which
2519          * is already overkill.
2520          *
2521          * Alternative is to return with 1 not throttling queue. In this
2522          * case loop becomes longer, no more useful effects.
2523          */
2524         if (time_before(jiffies, maxjiff)) {
2525                 barrier();
2526                 cpu_relax();
2527                 goto restart;
2528         }
2529
2530         /* The ring is stuck full. */
2531         printk(KERN_WARNING "%s: Transmit ring stuck full\n", dev->name);
2532         return NETDEV_TX_BUSY;
2533 }
2534
2535
2536 static int ace_change_mtu(struct net_device *dev, int new_mtu)
2537 {
2538         struct ace_private *ap = netdev_priv(dev);
2539         struct ace_regs __iomem *regs = ap->regs;
2540
2541         writel(new_mtu + ETH_HLEN + 4, &regs->IfMtu);
2542         dev->mtu = new_mtu;
2543
2544         if (new_mtu > ACE_STD_MTU) {
2545                 if (!(ap->jumbo)) {
2546                         printk(KERN_INFO "%s: Enabling Jumbo frame "
2547                                "support\n", dev->name);
2548                         ap->jumbo = 1;
2549                         if (!test_and_set_bit(0, &ap->jumbo_refill_busy))
2550                                 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2551                         ace_set_rxtx_parms(dev, 1);
2552                 }
2553         } else {
2554                 while (test_and_set_bit(0, &ap->jumbo_refill_busy));
2555                 ace_sync_irq(dev->irq);
2556                 ace_set_rxtx_parms(dev, 0);
2557                 if (ap->jumbo) {
2558                         struct cmd cmd;
2559
2560                         cmd.evt = C_RESET_JUMBO_RNG;
2561                         cmd.code = 0;
2562                         cmd.idx = 0;
2563                         ace_issue_cmd(regs, &cmd);
2564                 }
2565         }
2566
2567         return 0;
2568 }
2569
2570 static int ace_get_link_ksettings(struct net_device *dev,
2571                                   struct ethtool_link_ksettings *cmd)
2572 {
2573         struct ace_private *ap = netdev_priv(dev);
2574         struct ace_regs __iomem *regs = ap->regs;
2575         u32 link;
2576         u32 supported;
2577
2578         memset(cmd, 0, sizeof(struct ethtool_link_ksettings));
2579
2580         supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
2581                      SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
2582                      SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full |
2583                      SUPPORTED_Autoneg | SUPPORTED_FIBRE);
2584
2585         cmd->base.port = PORT_FIBRE;
2586
2587         link = readl(&regs->GigLnkState);
2588         if (link & LNK_1000MB) {
2589                 cmd->base.speed = SPEED_1000;
2590         } else {
2591                 link = readl(&regs->FastLnkState);
2592                 if (link & LNK_100MB)
2593                         cmd->base.speed = SPEED_100;
2594                 else if (link & LNK_10MB)
2595                         cmd->base.speed = SPEED_10;
2596                 else
2597                         cmd->base.speed = 0;
2598         }
2599         if (link & LNK_FULL_DUPLEX)
2600                 cmd->base.duplex = DUPLEX_FULL;
2601         else
2602                 cmd->base.duplex = DUPLEX_HALF;
2603
2604         if (link & LNK_NEGOTIATE)
2605                 cmd->base.autoneg = AUTONEG_ENABLE;
2606         else
2607                 cmd->base.autoneg = AUTONEG_DISABLE;
2608
2609 #if 0
2610         /*
2611          * Current struct ethtool_cmd is insufficient
2612          */
2613         ecmd->trace = readl(&regs->TuneTrace);
2614
2615         ecmd->txcoal = readl(&regs->TuneTxCoalTicks);
2616         ecmd->rxcoal = readl(&regs->TuneRxCoalTicks);
2617 #endif
2618
2619         ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
2620                                                 supported);
2621
2622         return 0;
2623 }
2624
2625 static int ace_set_link_ksettings(struct net_device *dev,
2626                                   const struct ethtool_link_ksettings *cmd)
2627 {
2628         struct ace_private *ap = netdev_priv(dev);
2629         struct ace_regs __iomem *regs = ap->regs;
2630         u32 link, speed;
2631
2632         link = readl(&regs->GigLnkState);
2633         if (link & LNK_1000MB)
2634                 speed = SPEED_1000;
2635         else {
2636                 link = readl(&regs->FastLnkState);
2637                 if (link & LNK_100MB)
2638                         speed = SPEED_100;
2639                 else if (link & LNK_10MB)
2640                         speed = SPEED_10;
2641                 else
2642                         speed = SPEED_100;
2643         }
2644
2645         link = LNK_ENABLE | LNK_1000MB | LNK_100MB | LNK_10MB |
2646                 LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL;
2647         if (!ACE_IS_TIGON_I(ap))
2648                 link |= LNK_TX_FLOW_CTL_Y;
2649         if (cmd->base.autoneg == AUTONEG_ENABLE)
2650                 link |= LNK_NEGOTIATE;
2651         if (cmd->base.speed != speed) {
2652                 link &= ~(LNK_1000MB | LNK_100MB | LNK_10MB);
2653                 switch (cmd->base.speed) {
2654                 case SPEED_1000:
2655                         link |= LNK_1000MB;
2656                         break;
2657                 case SPEED_100:
2658                         link |= LNK_100MB;
2659                         break;
2660                 case SPEED_10:
2661                         link |= LNK_10MB;
2662                         break;
2663                 }
2664         }
2665
2666         if (cmd->base.duplex == DUPLEX_FULL)
2667                 link |= LNK_FULL_DUPLEX;
2668
2669         if (link != ap->link) {
2670                 struct cmd cmd;
2671                 printk(KERN_INFO "%s: Renegotiating link state\n",
2672                        dev->name);
2673
2674                 ap->link = link;
2675                 writel(link, &regs->TuneLink);
2676                 if (!ACE_IS_TIGON_I(ap))
2677                         writel(link, &regs->TuneFastLink);
2678                 wmb();
2679
2680                 cmd.evt = C_LNK_NEGOTIATION;
2681                 cmd.code = 0;
2682                 cmd.idx = 0;
2683                 ace_issue_cmd(regs, &cmd);
2684         }
2685         return 0;
2686 }
2687
2688 static void ace_get_drvinfo(struct net_device *dev,
2689                             struct ethtool_drvinfo *info)
2690 {
2691         struct ace_private *ap = netdev_priv(dev);
2692
2693         strscpy(info->driver, "acenic", sizeof(info->driver));
2694         snprintf(info->fw_version, sizeof(info->version), "%i.%i.%i",
2695                  ap->firmware_major, ap->firmware_minor, ap->firmware_fix);
2696
2697         if (ap->pdev)
2698                 strscpy(info->bus_info, pci_name(ap->pdev),
2699                         sizeof(info->bus_info));
2700
2701 }
2702
2703 /*
2704  * Set the hardware MAC address.
2705  */
2706 static int ace_set_mac_addr(struct net_device *dev, void *p)
2707 {
2708         struct ace_private *ap = netdev_priv(dev);
2709         struct ace_regs __iomem *regs = ap->regs;
2710         struct sockaddr *addr=p;
2711         const u8 *da;
2712         struct cmd cmd;
2713
2714         if(netif_running(dev))
2715                 return -EBUSY;
2716
2717         eth_hw_addr_set(dev, addr->sa_data);
2718
2719         da = (const u8 *)dev->dev_addr;
2720
2721         writel(da[0] << 8 | da[1], &regs->MacAddrHi);
2722         writel((da[2] << 24) | (da[3] << 16) | (da[4] << 8) | da[5],
2723                &regs->MacAddrLo);
2724
2725         cmd.evt = C_SET_MAC_ADDR;
2726         cmd.code = 0;
2727         cmd.idx = 0;
2728         ace_issue_cmd(regs, &cmd);
2729
2730         return 0;
2731 }
2732
2733
2734 static void ace_set_multicast_list(struct net_device *dev)
2735 {
2736         struct ace_private *ap = netdev_priv(dev);
2737         struct ace_regs __iomem *regs = ap->regs;
2738         struct cmd cmd;
2739
2740         if ((dev->flags & IFF_ALLMULTI) && !(ap->mcast_all)) {
2741                 cmd.evt = C_SET_MULTICAST_MODE;
2742                 cmd.code = C_C_MCAST_ENABLE;
2743                 cmd.idx = 0;
2744                 ace_issue_cmd(regs, &cmd);
2745                 ap->mcast_all = 1;
2746         } else if (ap->mcast_all) {
2747                 cmd.evt = C_SET_MULTICAST_MODE;
2748                 cmd.code = C_C_MCAST_DISABLE;
2749                 cmd.idx = 0;
2750                 ace_issue_cmd(regs, &cmd);
2751                 ap->mcast_all = 0;
2752         }
2753
2754         if ((dev->flags & IFF_PROMISC) && !(ap->promisc)) {
2755                 cmd.evt = C_SET_PROMISC_MODE;
2756                 cmd.code = C_C_PROMISC_ENABLE;
2757                 cmd.idx = 0;
2758                 ace_issue_cmd(regs, &cmd);
2759                 ap->promisc = 1;
2760         }else if (!(dev->flags & IFF_PROMISC) && (ap->promisc)) {
2761                 cmd.evt = C_SET_PROMISC_MODE;
2762                 cmd.code = C_C_PROMISC_DISABLE;
2763                 cmd.idx = 0;
2764                 ace_issue_cmd(regs, &cmd);
2765                 ap->promisc = 0;
2766         }
2767
2768         /*
2769          * For the time being multicast relies on the upper layers
2770          * filtering it properly. The Firmware does not allow one to
2771          * set the entire multicast list at a time and keeping track of
2772          * it here is going to be messy.
2773          */
2774         if (!netdev_mc_empty(dev) && !ap->mcast_all) {
2775                 cmd.evt = C_SET_MULTICAST_MODE;
2776                 cmd.code = C_C_MCAST_ENABLE;
2777                 cmd.idx = 0;
2778                 ace_issue_cmd(regs, &cmd);
2779         }else if (!ap->mcast_all) {
2780                 cmd.evt = C_SET_MULTICAST_MODE;
2781                 cmd.code = C_C_MCAST_DISABLE;
2782                 cmd.idx = 0;
2783                 ace_issue_cmd(regs, &cmd);
2784         }
2785 }
2786
2787
2788 static struct net_device_stats *ace_get_stats(struct net_device *dev)
2789 {
2790         struct ace_private *ap = netdev_priv(dev);
2791         struct ace_mac_stats __iomem *mac_stats =
2792                 (struct ace_mac_stats __iomem *)ap->regs->Stats;
2793
2794         dev->stats.rx_missed_errors = readl(&mac_stats->drop_space);
2795         dev->stats.multicast = readl(&mac_stats->kept_mc);
2796         dev->stats.collisions = readl(&mac_stats->coll);
2797
2798         return &dev->stats;
2799 }
2800
2801
2802 static void ace_copy(struct ace_regs __iomem *regs, const __be32 *src,
2803                      u32 dest, int size)
2804 {
2805         void __iomem *tdest;
2806         short tsize, i;
2807
2808         if (size <= 0)
2809                 return;
2810
2811         while (size > 0) {
2812                 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2813                             min_t(u32, size, ACE_WINDOW_SIZE));
2814                 tdest = (void __iomem *) &regs->Window +
2815                         (dest & (ACE_WINDOW_SIZE - 1));
2816                 writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
2817                 for (i = 0; i < (tsize / 4); i++) {
2818                         /* Firmware is big-endian */
2819                         writel(be32_to_cpup(src), tdest);
2820                         src++;
2821                         tdest += 4;
2822                         dest += 4;
2823                         size -= 4;
2824                 }
2825         }
2826 }
2827
2828
2829 static void ace_clear(struct ace_regs __iomem *regs, u32 dest, int size)
2830 {
2831         void __iomem *tdest;
2832         short tsize = 0, i;
2833
2834         if (size <= 0)
2835                 return;
2836
2837         while (size > 0) {
2838                 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2839                                 min_t(u32, size, ACE_WINDOW_SIZE));
2840                 tdest = (void __iomem *) &regs->Window +
2841                         (dest & (ACE_WINDOW_SIZE - 1));
2842                 writel(dest & ~(ACE_WINDOW_SIZE - 1), &regs->WinBase);
2843
2844                 for (i = 0; i < (tsize / 4); i++) {
2845                         writel(0, tdest + i*4);
2846                 }
2847
2848                 dest += tsize;
2849                 size -= tsize;
2850         }
2851 }
2852
2853
2854 /*
2855  * Download the firmware into the SRAM on the NIC
2856  *
2857  * This operation requires the NIC to be halted and is performed with
2858  * interrupts disabled and with the spinlock hold.
2859  */
2860 static int ace_load_firmware(struct net_device *dev)
2861 {
2862         const struct firmware *fw;
2863         const char *fw_name = "acenic/tg2.bin";
2864         struct ace_private *ap = netdev_priv(dev);
2865         struct ace_regs __iomem *regs = ap->regs;
2866         const __be32 *fw_data;
2867         u32 load_addr;
2868         int ret;
2869
2870         if (!(readl(&regs->CpuCtrl) & CPU_HALTED)) {
2871                 printk(KERN_ERR "%s: trying to download firmware while the "
2872                        "CPU is running!\n", ap->name);
2873                 return -EFAULT;
2874         }
2875
2876         if (ACE_IS_TIGON_I(ap))
2877                 fw_name = "acenic/tg1.bin";
2878
2879         ret = request_firmware(&fw, fw_name, &ap->pdev->dev);
2880         if (ret) {
2881                 printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
2882                        ap->name, fw_name);
2883                 return ret;
2884         }
2885
2886         fw_data = (void *)fw->data;
2887
2888         /* Firmware blob starts with version numbers, followed by
2889            load and start address. Remainder is the blob to be loaded
2890            contiguously from load address. We don't bother to represent
2891            the BSS/SBSS sections any more, since we were clearing the
2892            whole thing anyway. */
2893         ap->firmware_major = fw->data[0];
2894         ap->firmware_minor = fw->data[1];
2895         ap->firmware_fix = fw->data[2];
2896
2897         ap->firmware_start = be32_to_cpu(fw_data[1]);
2898         if (ap->firmware_start < 0x4000 || ap->firmware_start >= 0x80000) {
2899                 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2900                        ap->name, ap->firmware_start, fw_name);
2901                 ret = -EINVAL;
2902                 goto out;
2903         }
2904
2905         load_addr = be32_to_cpu(fw_data[2]);
2906         if (load_addr < 0x4000 || load_addr >= 0x80000) {
2907                 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2908                        ap->name, load_addr, fw_name);
2909                 ret = -EINVAL;
2910                 goto out;
2911         }
2912
2913         /*
2914          * Do not try to clear more than 512KiB or we end up seeing
2915          * funny things on NICs with only 512KiB SRAM
2916          */
2917         ace_clear(regs, 0x2000, 0x80000-0x2000);
2918         ace_copy(regs, &fw_data[3], load_addr, fw->size-12);
2919  out:
2920         release_firmware(fw);
2921         return ret;
2922 }
2923
2924
2925 /*
2926  * The eeprom on the AceNIC is an Atmel i2c EEPROM.
2927  *
2928  * Accessing the EEPROM is `interesting' to say the least - don't read
2929  * this code right after dinner.
2930  *
2931  * This is all about black magic and bit-banging the device .... I
2932  * wonder in what hospital they have put the guy who designed the i2c
2933  * specs.
2934  *
2935  * Oh yes, this is only the beginning!
2936  *
2937  * Thanks to Stevarino Webinski for helping tracking down the bugs in the
2938  * code i2c readout code by beta testing all my hacks.
2939  */
2940 static void eeprom_start(struct ace_regs __iomem *regs)
2941 {
2942         u32 local;
2943
2944         readl(&regs->LocalCtrl);
2945         udelay(ACE_SHORT_DELAY);
2946         local = readl(&regs->LocalCtrl);
2947         local |= EEPROM_DATA_OUT | EEPROM_WRITE_ENABLE;
2948         writel(local, &regs->LocalCtrl);
2949         readl(&regs->LocalCtrl);
2950         mb();
2951         udelay(ACE_SHORT_DELAY);
2952         local |= EEPROM_CLK_OUT;
2953         writel(local, &regs->LocalCtrl);
2954         readl(&regs->LocalCtrl);
2955         mb();
2956         udelay(ACE_SHORT_DELAY);
2957         local &= ~EEPROM_DATA_OUT;
2958         writel(local, &regs->LocalCtrl);
2959         readl(&regs->LocalCtrl);
2960         mb();
2961         udelay(ACE_SHORT_DELAY);
2962         local &= ~EEPROM_CLK_OUT;
2963         writel(local, &regs->LocalCtrl);
2964         readl(&regs->LocalCtrl);
2965         mb();
2966 }
2967
2968
2969 static void eeprom_prep(struct ace_regs __iomem *regs, u8 magic)
2970 {
2971         short i;
2972         u32 local;
2973
2974         udelay(ACE_SHORT_DELAY);
2975         local = readl(&regs->LocalCtrl);
2976         local &= ~EEPROM_DATA_OUT;
2977         local |= EEPROM_WRITE_ENABLE;
2978         writel(local, &regs->LocalCtrl);
2979         readl(&regs->LocalCtrl);
2980         mb();
2981
2982         for (i = 0; i < 8; i++, magic <<= 1) {
2983                 udelay(ACE_SHORT_DELAY);
2984                 if (magic & 0x80)
2985                         local |= EEPROM_DATA_OUT;
2986                 else
2987                         local &= ~EEPROM_DATA_OUT;
2988                 writel(local, &regs->LocalCtrl);
2989                 readl(&regs->LocalCtrl);
2990                 mb();
2991
2992                 udelay(ACE_SHORT_DELAY);
2993                 local |= EEPROM_CLK_OUT;
2994                 writel(local, &regs->LocalCtrl);
2995                 readl(&regs->LocalCtrl);
2996                 mb();
2997                 udelay(ACE_SHORT_DELAY);
2998                 local &= ~(EEPROM_CLK_OUT | EEPROM_DATA_OUT);
2999                 writel(local, &regs->LocalCtrl);
3000                 readl(&regs->LocalCtrl);
3001                 mb();
3002         }
3003 }
3004
3005
3006 static int eeprom_check_ack(struct ace_regs __iomem *regs)
3007 {
3008         int state;
3009         u32 local;
3010
3011         local = readl(&regs->LocalCtrl);
3012         local &= ~EEPROM_WRITE_ENABLE;
3013         writel(local, &regs->LocalCtrl);
3014         readl(&regs->LocalCtrl);
3015         mb();
3016         udelay(ACE_LONG_DELAY);
3017         local |= EEPROM_CLK_OUT;
3018         writel(local, &regs->LocalCtrl);
3019         readl(&regs->LocalCtrl);
3020         mb();
3021         udelay(ACE_SHORT_DELAY);
3022         /* sample data in middle of high clk */
3023         state = (readl(&regs->LocalCtrl) & EEPROM_DATA_IN) != 0;
3024         udelay(ACE_SHORT_DELAY);
3025         mb();
3026         writel(readl(&regs->LocalCtrl) & ~EEPROM_CLK_OUT, &regs->LocalCtrl);
3027         readl(&regs->LocalCtrl);
3028         mb();
3029
3030         return state;
3031 }
3032
3033
3034 static void eeprom_stop(struct ace_regs __iomem *regs)
3035 {
3036         u32 local;
3037
3038         udelay(ACE_SHORT_DELAY);
3039         local = readl(&regs->LocalCtrl);
3040         local |= EEPROM_WRITE_ENABLE;
3041         writel(local, &regs->LocalCtrl);
3042         readl(&regs->LocalCtrl);
3043         mb();
3044         udelay(ACE_SHORT_DELAY);
3045         local &= ~EEPROM_DATA_OUT;
3046         writel(local, &regs->LocalCtrl);
3047         readl(&regs->LocalCtrl);
3048         mb();
3049         udelay(ACE_SHORT_DELAY);
3050         local |= EEPROM_CLK_OUT;
3051         writel(local, &regs->LocalCtrl);
3052         readl(&regs->LocalCtrl);
3053         mb();
3054         udelay(ACE_SHORT_DELAY);
3055         local |= EEPROM_DATA_OUT;
3056         writel(local, &regs->LocalCtrl);
3057         readl(&regs->LocalCtrl);
3058         mb();
3059         udelay(ACE_LONG_DELAY);
3060         local &= ~EEPROM_CLK_OUT;
3061         writel(local, &regs->LocalCtrl);
3062         mb();
3063 }
3064
3065
3066 /*
3067  * Read a whole byte from the EEPROM.
3068  */
3069 static int read_eeprom_byte(struct net_device *dev, unsigned long offset)
3070 {
3071         struct ace_private *ap = netdev_priv(dev);
3072         struct ace_regs __iomem *regs = ap->regs;
3073         unsigned long flags;
3074         u32 local;
3075         int result = 0;
3076         short i;
3077
3078         /*
3079          * Don't take interrupts on this CPU will bit banging
3080          * the %#%#@$ I2C device
3081          */
3082         local_irq_save(flags);
3083
3084         eeprom_start(regs);
3085
3086         eeprom_prep(regs, EEPROM_WRITE_SELECT);
3087         if (eeprom_check_ack(regs)) {
3088                 local_irq_restore(flags);
3089                 printk(KERN_ERR "%s: Unable to sync eeprom\n", ap->name);
3090                 result = -EIO;
3091                 goto eeprom_read_error;
3092         }
3093
3094         eeprom_prep(regs, (offset >> 8) & 0xff);
3095         if (eeprom_check_ack(regs)) {
3096                 local_irq_restore(flags);
3097                 printk(KERN_ERR "%s: Unable to set address byte 0\n",
3098                        ap->name);
3099                 result = -EIO;
3100                 goto eeprom_read_error;
3101         }
3102
3103         eeprom_prep(regs, offset & 0xff);
3104         if (eeprom_check_ack(regs)) {
3105                 local_irq_restore(flags);
3106                 printk(KERN_ERR "%s: Unable to set address byte 1\n",
3107                        ap->name);
3108                 result = -EIO;
3109                 goto eeprom_read_error;
3110         }
3111
3112         eeprom_start(regs);
3113         eeprom_prep(regs, EEPROM_READ_SELECT);
3114         if (eeprom_check_ack(regs)) {
3115                 local_irq_restore(flags);
3116                 printk(KERN_ERR "%s: Unable to set READ_SELECT\n",
3117                        ap->name);
3118                 result = -EIO;
3119                 goto eeprom_read_error;
3120         }
3121
3122         for (i = 0; i < 8; i++) {
3123                 local = readl(&regs->LocalCtrl);
3124                 local &= ~EEPROM_WRITE_ENABLE;
3125                 writel(local, &regs->LocalCtrl);
3126                 readl(&regs->LocalCtrl);
3127                 udelay(ACE_LONG_DELAY);
3128                 mb();
3129                 local |= EEPROM_CLK_OUT;
3130                 writel(local, &regs->LocalCtrl);
3131                 readl(&regs->LocalCtrl);
3132                 mb();
3133                 udelay(ACE_SHORT_DELAY);
3134                 /* sample data mid high clk */
3135                 result = (result << 1) |
3136                         ((readl(&regs->LocalCtrl) & EEPROM_DATA_IN) != 0);
3137                 udelay(ACE_SHORT_DELAY);
3138                 mb();
3139                 local = readl(&regs->LocalCtrl);
3140                 local &= ~EEPROM_CLK_OUT;
3141                 writel(local, &regs->LocalCtrl);
3142                 readl(&regs->LocalCtrl);
3143                 udelay(ACE_SHORT_DELAY);
3144                 mb();
3145                 if (i == 7) {
3146                         local |= EEPROM_WRITE_ENABLE;
3147                         writel(local, &regs->LocalCtrl);
3148                         readl(&regs->LocalCtrl);
3149                         mb();
3150                         udelay(ACE_SHORT_DELAY);
3151                 }
3152         }
3153
3154         local |= EEPROM_DATA_OUT;
3155         writel(local, &regs->LocalCtrl);
3156         readl(&regs->LocalCtrl);
3157         mb();
3158         udelay(ACE_SHORT_DELAY);
3159         writel(readl(&regs->LocalCtrl) | EEPROM_CLK_OUT, &regs->LocalCtrl);
3160         readl(&regs->LocalCtrl);
3161         udelay(ACE_LONG_DELAY);
3162         writel(readl(&regs->LocalCtrl) & ~EEPROM_CLK_OUT, &regs->LocalCtrl);
3163         readl(&regs->LocalCtrl);
3164         mb();
3165         udelay(ACE_SHORT_DELAY);
3166         eeprom_stop(regs);
3167
3168         local_irq_restore(flags);
3169  out:
3170         return result;
3171
3172  eeprom_read_error:
3173         printk(KERN_ERR "%s: Unable to read eeprom byte 0x%02lx\n",
3174                ap->name, offset);
3175         goto out;
3176 }
3177
3178 module_pci_driver(acenic_pci_driver);