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