drivers/net/acenic.c

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