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