1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * acenic.c: Linux driver for the Alteon AceNIC Gigabit Ethernet card
4 * and other Tigon based cards.
6 * Copyright 1998-2002 by Jes Sorensen, <jes@trained-monkey.org>.
8 * Thanks to Alteon and 3Com for providing hardware and documentation
9 * enabling me to write this driver.
11 * A mailing list for discussing the use of this driver has been
12 * setup, please subscribe to the lists if you have any questions
13 * about the driver. Send mail to linux-acenic-help@sunsite.auc.dk to
14 * see how to subscribe.
17 * Pete Wyckoff <wyckoff@ca.sandia.gov>: Initial Linux/Alpha and trace
18 * dump support. The trace dump support has not been
19 * integrated yet however.
20 * Troy Benjegerdes: Big Endian (PPC) patches.
21 * Nate Stahl: Better out of memory handling and stats support.
22 * Aman Singla: Nasty race between interrupt handler and tx code dealing
23 * with 'testing the tx_ret_csm and setting tx_full'
24 * David S. Miller <davem@redhat.com>: conversion to new PCI dma mapping
25 * infrastructure and Sparc support
26 * Pierrick Pinasseau (CERN): For lending me an Ultra 5 to test the
27 * driver under Linux/Sparc64
28 * Matt Domsch <Matt_Domsch@dell.com>: Detect Alteon 1000baseT cards
29 * ETHTOOL_GDRVINFO support
30 * Chip Salzenberg <chip@valinux.com>: Fix race condition between tx
31 * handler and close() cleanup.
32 * Ken Aaker <kdaaker@rchland.vnet.ibm.com>: Correct check for whether
33 * memory mapped IO is enabled to
34 * make the driver work on RS/6000.
35 * Takayoshi Kouchi <kouchi@hpc.bs1.fc.nec.co.jp>: Identifying problem
36 * where the driver would disable
37 * bus master mode if it had to disable
38 * write and invalidate.
39 * Stephen Hack <stephen_hack@hp.com>: Fixed ace_set_mac_addr for little
41 * Val Henson <vhenson@esscom.com>: Reset Jumbo skb producer and
42 * rx producer index when
43 * flushing the Jumbo ring.
44 * Hans Grobler <grobh@sun.ac.za>: Memory leak fixes in the
46 * Grant Grundler <grundler@cup.hp.com>: PCI write posting fixes.
49 #include <linux/module.h>
50 #include <linux/moduleparam.h>
51 #include <linux/types.h>
52 #include <linux/errno.h>
53 #include <linux/ioport.h>
54 #include <linux/pci.h>
55 #include <linux/dma-mapping.h>
56 #include <linux/kernel.h>
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59 #include <linux/skbuff.h>
60 #include <linux/delay.h>
62 #include <linux/highmem.h>
63 #include <linux/sockios.h>
64 #include <linux/firmware.h>
65 #include <linux/slab.h>
66 #include <linux/prefetch.h>
67 #include <linux/if_vlan.h>
70 #include <linux/ethtool.h>
78 #include <asm/byteorder.h>
79 #include <linux/uaccess.h>
82 #define DRV_NAME "acenic"
86 #ifdef CONFIG_ACENIC_OMIT_TIGON_I
87 #define ACE_IS_TIGON_I(ap) 0
88 #define ACE_TX_RING_ENTRIES(ap) MAX_TX_RING_ENTRIES
90 #define ACE_IS_TIGON_I(ap) (ap->version == 1)
91 #define ACE_TX_RING_ENTRIES(ap) ap->tx_ring_entries
94 #ifndef PCI_VENDOR_ID_ALTEON
95 #define PCI_VENDOR_ID_ALTEON 0x12ae
97 #ifndef PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE
98 #define PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE 0x0001
99 #define PCI_DEVICE_ID_ALTEON_ACENIC_COPPER 0x0002
101 #ifndef PCI_DEVICE_ID_3COM_3C985
102 #define PCI_DEVICE_ID_3COM_3C985 0x0001
104 #ifndef PCI_VENDOR_ID_NETGEAR
105 #define PCI_VENDOR_ID_NETGEAR 0x1385
106 #define PCI_DEVICE_ID_NETGEAR_GA620 0x620a
108 #ifndef PCI_DEVICE_ID_NETGEAR_GA620T
109 #define PCI_DEVICE_ID_NETGEAR_GA620T 0x630a
114 * Farallon used the DEC vendor ID by mistake and they seem not
117 #ifndef PCI_DEVICE_ID_FARALLON_PN9000SX
118 #define PCI_DEVICE_ID_FARALLON_PN9000SX 0x1a
120 #ifndef PCI_DEVICE_ID_FARALLON_PN9100T
121 #define PCI_DEVICE_ID_FARALLON_PN9100T 0xfa
123 #ifndef PCI_VENDOR_ID_SGI
124 #define PCI_VENDOR_ID_SGI 0x10a9
126 #ifndef PCI_DEVICE_ID_SGI_ACENIC
127 #define PCI_DEVICE_ID_SGI_ACENIC 0x0009
130 static const struct pci_device_id acenic_pci_tbl[] = {
131 { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_FIBRE,
132 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
133 { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_ALTEON_ACENIC_COPPER,
134 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
135 { PCI_VENDOR_ID_3COM, PCI_DEVICE_ID_3COM_3C985,
136 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
137 { PCI_VENDOR_ID_NETGEAR, PCI_DEVICE_ID_NETGEAR_GA620,
138 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
139 { PCI_VENDOR_ID_NETGEAR, PCI_DEVICE_ID_NETGEAR_GA620T,
140 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
142 * Farallon used the DEC vendor ID on their cards incorrectly,
143 * then later Alteon's ID.
145 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_FARALLON_PN9000SX,
146 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
147 { PCI_VENDOR_ID_ALTEON, PCI_DEVICE_ID_FARALLON_PN9100T,
148 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
149 { PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_ACENIC,
150 PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, },
153 MODULE_DEVICE_TABLE(pci, acenic_pci_tbl);
155 #define ace_sync_irq(irq) synchronize_irq(irq)
157 #ifndef offset_in_page
158 #define offset_in_page(ptr) ((unsigned long)(ptr) & ~PAGE_MASK)
161 #define ACE_MAX_MOD_PARMS 8
162 #define BOARD_IDX_STATIC 0
163 #define BOARD_IDX_OVERFLOW -1
168 * These must be defined before the firmware is included.
170 #define MAX_TEXT_LEN 96*1024
171 #define MAX_RODATA_LEN 8*1024
172 #define MAX_DATA_LEN 2*1024
174 #ifndef tigon2FwReleaseLocal
175 #define tigon2FwReleaseLocal 0
179 * This driver currently supports Tigon I and Tigon II based cards
180 * including the Alteon AceNIC, the 3Com 3C985[B] and NetGear
181 * GA620. The driver should also work on the SGI, DEC and Farallon
182 * versions of the card, however I have not been able to test that
185 * This card is really neat, it supports receive hardware checksumming
186 * and jumbo frames (up to 9000 bytes) and does a lot of work in the
187 * firmware. Also the programming interface is quite neat, except for
188 * the parts dealing with the i2c eeprom on the card ;-)
190 * Using jumbo frames:
192 * To enable jumbo frames, simply specify an mtu between 1500 and 9000
193 * bytes to ifconfig. Jumbo frames can be enabled or disabled at any time
194 * by running `ifconfig eth<X> mtu <MTU>' with <X> being the Ethernet
195 * interface number and <MTU> being the MTU value.
199 * When compiled as a loadable module, the driver allows for a number
200 * of module parameters to be specified. The driver supports the
201 * following module parameters:
203 * trace=<val> - Firmware trace level. This requires special traced
204 * firmware to replace the firmware supplied with
205 * the driver - for debugging purposes only.
207 * link=<val> - Link state. Normally you want to use the default link
208 * parameters set by the driver. This can be used to
209 * override these in case your switch doesn't negotiate
210 * the link properly. Valid values are:
211 * 0x0001 - Force half duplex link.
212 * 0x0002 - Do not negotiate line speed with the other end.
213 * 0x0010 - 10Mbit/sec link.
214 * 0x0020 - 100Mbit/sec link.
215 * 0x0040 - 1000Mbit/sec link.
216 * 0x0100 - Do not negotiate flow control.
217 * 0x0200 - Enable RX flow control Y
218 * 0x0400 - Enable TX flow control Y (Tigon II NICs only).
219 * Default value is 0x0270, ie. enable link+flow
220 * control negotiation. Negotiating the highest
221 * possible link speed with RX flow control enabled.
223 * When disabling link speed negotiation, only one link
224 * speed is allowed to be specified!
226 * tx_coal_tick=<val> - number of coalescing clock ticks (us) allowed
227 * to wait for more packets to arive before
228 * interrupting the host, from the time the first
231 * rx_coal_tick=<val> - number of coalescing clock ticks (us) allowed
232 * to wait for more packets to arive in the transmit ring,
233 * before interrupting the host, after transmitting the
234 * first packet in the ring.
236 * max_tx_desc=<val> - maximum number of transmit descriptors
237 * (packets) transmitted before interrupting the host.
239 * max_rx_desc=<val> - maximum number of receive descriptors
240 * (packets) received before interrupting the host.
242 * tx_ratio=<val> - 7 bit value (0 - 63) specifying the split in 64th
243 * increments of the NIC's on board memory to be used for
244 * transmit and receive buffers. For the 1MB NIC app. 800KB
245 * is available, on the 1/2MB NIC app. 300KB is available.
246 * 68KB will always be available as a minimum for both
247 * directions. The default value is a 50/50 split.
248 * dis_pci_mem_inval=<val> - disable PCI memory write and invalidate
249 * operations, default (1) is to always disable this as
250 * that is what Alteon does on NT. I have not been able
251 * to measure any real performance differences with
252 * this on my systems. Set <val>=0 if you want to
253 * enable these operations.
255 * If you use more than one NIC, specify the parameters for the
256 * individual NICs with a comma, ie. trace=0,0x00001fff,0 you want to
257 * run tracing on NIC #2 but not on NIC #1 and #3.
261 * - Proper multicast support.
262 * - NIC dump support.
263 * - More tuning parameters.
265 * The mini ring is not used under Linux and I am not sure it makes sense
266 * to actually use it.
268 * New interrupt handler strategy:
270 * The old interrupt handler worked using the traditional method of
271 * replacing an skbuff with a new one when a packet arrives. However
272 * the rx rings do not need to contain a static number of buffer
273 * descriptors, thus it makes sense to move the memory allocation out
274 * of the main interrupt handler and do it in a bottom half handler
275 * and only allocate new buffers when the number of buffers in the
276 * ring is below a certain threshold. In order to avoid starving the
277 * NIC under heavy load it is however necessary to force allocation
278 * when hitting a minimum threshold. The strategy for alloction is as
281 * RX_LOW_BUF_THRES - allocate buffers in the bottom half
282 * RX_PANIC_LOW_THRES - we are very low on buffers, allocate
283 * the buffers in the interrupt handler
284 * RX_RING_THRES - maximum number of buffers in the rx ring
285 * RX_MINI_THRES - maximum number of buffers in the mini ring
286 * RX_JUMBO_THRES - maximum number of buffers in the jumbo ring
288 * One advantagous side effect of this allocation approach is that the
289 * entire rx processing can be done without holding any spin lock
290 * since the rx rings and registers are totally independent of the tx
291 * ring and its registers. This of course includes the kmalloc's of
292 * new skb's. Thus start_xmit can run in parallel with rx processing
293 * and the memory allocation on SMP systems.
295 * Note that running the skb reallocation in a bottom half opens up
296 * another can of races which needs to be handled properly. In
297 * particular it can happen that the interrupt handler tries to run
298 * the reallocation while the bottom half is either running on another
299 * CPU or was interrupted on the same CPU. To get around this the
300 * driver uses bitops to prevent the reallocation routines from being
303 * TX handling can also be done without holding any spin lock, wheee
304 * this is fun! since tx_ret_csm is only written to by the interrupt
305 * handler. The case to be aware of is when shutting down the device
306 * and cleaning up where it is necessary to make sure that
307 * start_xmit() is not running while this is happening. Well DaveM
308 * informs me that this case is already protected against ... bye bye
309 * Mr. Spin Lock, it was nice to know you.
311 * TX interrupts are now partly disabled so the NIC will only generate
312 * TX interrupts for the number of coal ticks, not for the number of
313 * TX packets in the queue. This should reduce the number of TX only,
314 * ie. when no RX processing is done, interrupts seen.
318 * Threshold values for RX buffer allocation - the low water marks for
319 * when to start refilling the rings are set to 75% of the ring
320 * sizes. It seems to make sense to refill the rings entirely from the
321 * intrrupt handler once it gets below the panic threshold, that way
322 * we don't risk that the refilling is moved to another CPU when the
323 * one running the interrupt handler just got the slab code hot in its
326 #define RX_RING_SIZE 72
327 #define RX_MINI_SIZE 64
328 #define RX_JUMBO_SIZE 48
330 #define RX_PANIC_STD_THRES 16
331 #define RX_PANIC_STD_REFILL (3*RX_PANIC_STD_THRES)/2
332 #define RX_LOW_STD_THRES (3*RX_RING_SIZE)/4
333 #define RX_PANIC_MINI_THRES 12
334 #define RX_PANIC_MINI_REFILL (3*RX_PANIC_MINI_THRES)/2
335 #define RX_LOW_MINI_THRES (3*RX_MINI_SIZE)/4
336 #define RX_PANIC_JUMBO_THRES 6
337 #define RX_PANIC_JUMBO_REFILL (3*RX_PANIC_JUMBO_THRES)/2
338 #define RX_LOW_JUMBO_THRES (3*RX_JUMBO_SIZE)/4
342 * Size of the mini ring entries, basically these just should be big
343 * enough to take TCP ACKs
345 #define ACE_MINI_SIZE 100
347 #define ACE_MINI_BUFSIZE ACE_MINI_SIZE
348 #define ACE_STD_BUFSIZE (ACE_STD_MTU + ETH_HLEN + 4)
349 #define ACE_JUMBO_BUFSIZE (ACE_JUMBO_MTU + ETH_HLEN + 4)
352 * There seems to be a magic difference in the effect between 995 and 996
353 * but little difference between 900 and 995 ... no idea why.
355 * There is now a default set of tuning parameters which is set, depending
356 * on whether or not the user enables Jumbo frames. It's assumed that if
357 * Jumbo frames are enabled, the user wants optimal tuning for that case.
359 #define DEF_TX_COAL 400 /* 996 */
360 #define DEF_TX_MAX_DESC 60 /* was 40 */
361 #define DEF_RX_COAL 120 /* 1000 */
362 #define DEF_RX_MAX_DESC 25
363 #define DEF_TX_RATIO 21 /* 24 */
365 #define DEF_JUMBO_TX_COAL 20
366 #define DEF_JUMBO_TX_MAX_DESC 60
367 #define DEF_JUMBO_RX_COAL 30
368 #define DEF_JUMBO_RX_MAX_DESC 6
369 #define DEF_JUMBO_TX_RATIO 21
371 #if tigon2FwReleaseLocal < 20001118
373 * Standard firmware and early modifications duplicate
374 * IRQ load without this flag (coal timer is never reset).
375 * Note that with this flag tx_coal should be less than
376 * time to xmit full tx ring.
377 * 400usec is not so bad for tx ring size of 128.
379 #define TX_COAL_INTS_ONLY 1 /* worth it */
382 * With modified firmware, this is not necessary, but still useful.
384 #define TX_COAL_INTS_ONLY 1
388 #define DEF_STAT (2 * TICKS_PER_SEC)
391 static int link_state[ACE_MAX_MOD_PARMS];
392 static int trace[ACE_MAX_MOD_PARMS];
393 static int tx_coal_tick[ACE_MAX_MOD_PARMS];
394 static int rx_coal_tick[ACE_MAX_MOD_PARMS];
395 static int max_tx_desc[ACE_MAX_MOD_PARMS];
396 static int max_rx_desc[ACE_MAX_MOD_PARMS];
397 static int tx_ratio[ACE_MAX_MOD_PARMS];
398 static int dis_pci_mem_inval[ACE_MAX_MOD_PARMS] = {1, 1, 1, 1, 1, 1, 1, 1};
400 MODULE_AUTHOR("Jes Sorensen <jes@trained-monkey.org>");
401 MODULE_LICENSE("GPL");
402 MODULE_DESCRIPTION("AceNIC/3C985/GA620 Gigabit Ethernet driver");
403 #ifndef CONFIG_ACENIC_OMIT_TIGON_I
408 module_param_array_named(link, link_state, int, NULL, 0);
409 module_param_array(trace, int, NULL, 0);
410 module_param_array(tx_coal_tick, int, NULL, 0);
411 module_param_array(max_tx_desc, int, NULL, 0);
412 module_param_array(rx_coal_tick, int, NULL, 0);
413 module_param_array(max_rx_desc, int, NULL, 0);
414 module_param_array(tx_ratio, int, NULL, 0);
415 MODULE_PARM_DESC(link, "AceNIC/3C985/NetGear link state");
416 MODULE_PARM_DESC(trace, "AceNIC/3C985/NetGear firmware trace level");
417 MODULE_PARM_DESC(tx_coal_tick, "AceNIC/3C985/GA620 max clock ticks to wait from first tx descriptor arrives");
418 MODULE_PARM_DESC(max_tx_desc, "AceNIC/3C985/GA620 max number of transmit descriptors to wait");
419 MODULE_PARM_DESC(rx_coal_tick, "AceNIC/3C985/GA620 max clock ticks to wait from first rx descriptor arrives");
420 MODULE_PARM_DESC(max_rx_desc, "AceNIC/3C985/GA620 max number of receive descriptors to wait");
421 MODULE_PARM_DESC(tx_ratio, "AceNIC/3C985/GA620 ratio of NIC memory used for TX/RX descriptors (range 0-63)");
424 static const char version[] =
425 "acenic.c: v0.92 08/05/2002 Jes Sorensen, linux-acenic@SunSITE.dk\n"
426 " http://home.cern.ch/~jes/gige/acenic.html\n";
428 static int ace_get_link_ksettings(struct net_device *,
429 struct ethtool_link_ksettings *);
430 static int ace_set_link_ksettings(struct net_device *,
431 const struct ethtool_link_ksettings *);
432 static void ace_get_drvinfo(struct net_device *, struct ethtool_drvinfo *);
434 static const struct ethtool_ops ace_ethtool_ops = {
435 .get_drvinfo = ace_get_drvinfo,
436 .get_link_ksettings = ace_get_link_ksettings,
437 .set_link_ksettings = ace_set_link_ksettings,
440 static void ace_watchdog(struct net_device *dev, unsigned int txqueue);
442 static const struct net_device_ops ace_netdev_ops = {
443 .ndo_open = ace_open,
444 .ndo_stop = ace_close,
445 .ndo_tx_timeout = ace_watchdog,
446 .ndo_get_stats = ace_get_stats,
447 .ndo_start_xmit = ace_start_xmit,
448 .ndo_set_rx_mode = ace_set_multicast_list,
449 .ndo_validate_addr = eth_validate_addr,
450 .ndo_set_mac_address = ace_set_mac_addr,
451 .ndo_change_mtu = ace_change_mtu,
454 static int acenic_probe_one(struct pci_dev *pdev,
455 const struct pci_device_id *id)
457 struct net_device *dev;
458 struct ace_private *ap;
459 static int boards_found;
461 dev = alloc_etherdev(sizeof(struct ace_private));
465 SET_NETDEV_DEV(dev, &pdev->dev);
467 ap = netdev_priv(dev);
470 ap->name = pci_name(pdev);
472 dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
473 dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX;
475 dev->watchdog_timeo = 5*HZ;
477 dev->max_mtu = ACE_JUMBO_MTU;
479 dev->netdev_ops = &ace_netdev_ops;
480 dev->ethtool_ops = &ace_ethtool_ops;
482 /* we only display this string ONCE */
486 if (pci_enable_device(pdev))
487 goto fail_free_netdev;
490 * Enable master mode before we start playing with the
491 * pci_command word since pci_set_master() will modify
494 pci_set_master(pdev);
496 pci_read_config_word(pdev, PCI_COMMAND, &ap->pci_command);
498 /* OpenFirmware on Mac's does not set this - DOH.. */
499 if (!(ap->pci_command & PCI_COMMAND_MEMORY)) {
500 printk(KERN_INFO "%s: Enabling PCI Memory Mapped "
501 "access - was not enabled by BIOS/Firmware\n",
503 ap->pci_command = ap->pci_command | PCI_COMMAND_MEMORY;
504 pci_write_config_word(ap->pdev, PCI_COMMAND,
509 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ap->pci_latency);
510 if (ap->pci_latency <= 0x40) {
511 ap->pci_latency = 0x40;
512 pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ap->pci_latency);
516 * Remap the regs into kernel space - this is abuse of
517 * dev->base_addr since it was means for I/O port
518 * addresses but who gives a damn.
520 dev->base_addr = pci_resource_start(pdev, 0);
521 ap->regs = ioremap(dev->base_addr, 0x4000);
523 printk(KERN_ERR "%s: Unable to map I/O register, "
524 "AceNIC %i will be disabled.\n",
525 ap->name, boards_found);
526 goto fail_free_netdev;
529 switch(pdev->vendor) {
530 case PCI_VENDOR_ID_ALTEON:
531 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9100T) {
532 printk(KERN_INFO "%s: Farallon PN9100-T ",
535 printk(KERN_INFO "%s: Alteon AceNIC ",
539 case PCI_VENDOR_ID_3COM:
540 printk(KERN_INFO "%s: 3Com 3C985 ", ap->name);
542 case PCI_VENDOR_ID_NETGEAR:
543 printk(KERN_INFO "%s: NetGear GA620 ", ap->name);
545 case PCI_VENDOR_ID_DEC:
546 if (pdev->device == PCI_DEVICE_ID_FARALLON_PN9000SX) {
547 printk(KERN_INFO "%s: Farallon PN9000-SX ",
552 case PCI_VENDOR_ID_SGI:
553 printk(KERN_INFO "%s: SGI AceNIC ", ap->name);
556 printk(KERN_INFO "%s: Unknown AceNIC ", ap->name);
560 printk("Gigabit Ethernet at 0x%08lx, ", dev->base_addr);
561 printk("irq %d\n", pdev->irq);
563 #ifdef CONFIG_ACENIC_OMIT_TIGON_I
564 if ((readl(&ap->regs->HostCtrl) >> 28) == 4) {
565 printk(KERN_ERR "%s: Driver compiled without Tigon I"
566 " support - NIC disabled\n", dev->name);
571 if (ace_allocate_descriptors(dev))
572 goto fail_free_netdev;
575 if (boards_found >= ACE_MAX_MOD_PARMS)
576 ap->board_idx = BOARD_IDX_OVERFLOW;
578 ap->board_idx = boards_found;
580 ap->board_idx = BOARD_IDX_STATIC;
584 goto fail_free_netdev;
586 if (register_netdev(dev)) {
587 printk(KERN_ERR "acenic: device registration failed\n");
590 ap->name = dev->name;
592 if (ap->pci_using_dac)
593 dev->features |= NETIF_F_HIGHDMA;
595 pci_set_drvdata(pdev, dev);
601 ace_init_cleanup(dev);
607 static void acenic_remove_one(struct pci_dev *pdev)
609 struct net_device *dev = pci_get_drvdata(pdev);
610 struct ace_private *ap = netdev_priv(dev);
611 struct ace_regs __iomem *regs = ap->regs;
614 unregister_netdev(dev);
616 writel(readl(®s->CpuCtrl) | CPU_HALT, ®s->CpuCtrl);
617 if (ap->version >= 2)
618 writel(readl(®s->CpuBCtrl) | CPU_HALT, ®s->CpuBCtrl);
621 * This clears any pending interrupts
623 writel(1, ®s->Mb0Lo);
624 readl(®s->CpuCtrl); /* flush */
627 * Make sure no other CPUs are processing interrupts
628 * on the card before the buffers are being released.
629 * Otherwise one might experience some `interesting'
632 * Then release the RX buffers - jumbo buffers were
633 * already released in ace_close().
635 ace_sync_irq(dev->irq);
637 for (i = 0; i < RX_STD_RING_ENTRIES; i++) {
638 struct sk_buff *skb = ap->skb->rx_std_skbuff[i].skb;
641 struct ring_info *ringp;
644 ringp = &ap->skb->rx_std_skbuff[i];
645 mapping = dma_unmap_addr(ringp, mapping);
646 dma_unmap_page(&ap->pdev->dev, mapping,
647 ACE_STD_BUFSIZE, DMA_FROM_DEVICE);
649 ap->rx_std_ring[i].size = 0;
650 ap->skb->rx_std_skbuff[i].skb = NULL;
655 if (ap->version >= 2) {
656 for (i = 0; i < RX_MINI_RING_ENTRIES; i++) {
657 struct sk_buff *skb = ap->skb->rx_mini_skbuff[i].skb;
660 struct ring_info *ringp;
663 ringp = &ap->skb->rx_mini_skbuff[i];
664 mapping = dma_unmap_addr(ringp,mapping);
665 dma_unmap_page(&ap->pdev->dev, mapping,
669 ap->rx_mini_ring[i].size = 0;
670 ap->skb->rx_mini_skbuff[i].skb = NULL;
676 for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
677 struct sk_buff *skb = ap->skb->rx_jumbo_skbuff[i].skb;
679 struct ring_info *ringp;
682 ringp = &ap->skb->rx_jumbo_skbuff[i];
683 mapping = dma_unmap_addr(ringp, mapping);
684 dma_unmap_page(&ap->pdev->dev, mapping,
685 ACE_JUMBO_BUFSIZE, DMA_FROM_DEVICE);
687 ap->rx_jumbo_ring[i].size = 0;
688 ap->skb->rx_jumbo_skbuff[i].skb = NULL;
693 ace_init_cleanup(dev);
697 static struct pci_driver acenic_pci_driver = {
699 .id_table = acenic_pci_tbl,
700 .probe = acenic_probe_one,
701 .remove = acenic_remove_one,
704 static void ace_free_descriptors(struct net_device *dev)
706 struct ace_private *ap = netdev_priv(dev);
709 if (ap->rx_std_ring != NULL) {
710 size = (sizeof(struct rx_desc) *
711 (RX_STD_RING_ENTRIES +
712 RX_JUMBO_RING_ENTRIES +
713 RX_MINI_RING_ENTRIES +
714 RX_RETURN_RING_ENTRIES));
715 dma_free_coherent(&ap->pdev->dev, size, ap->rx_std_ring,
716 ap->rx_ring_base_dma);
717 ap->rx_std_ring = NULL;
718 ap->rx_jumbo_ring = NULL;
719 ap->rx_mini_ring = NULL;
720 ap->rx_return_ring = NULL;
722 if (ap->evt_ring != NULL) {
723 size = (sizeof(struct event) * EVT_RING_ENTRIES);
724 dma_free_coherent(&ap->pdev->dev, size, ap->evt_ring,
728 if (ap->tx_ring != NULL && !ACE_IS_TIGON_I(ap)) {
729 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
730 dma_free_coherent(&ap->pdev->dev, size, ap->tx_ring,
735 if (ap->evt_prd != NULL) {
736 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
737 (void *)ap->evt_prd, ap->evt_prd_dma);
740 if (ap->rx_ret_prd != NULL) {
741 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
742 (void *)ap->rx_ret_prd, ap->rx_ret_prd_dma);
743 ap->rx_ret_prd = NULL;
745 if (ap->tx_csm != NULL) {
746 dma_free_coherent(&ap->pdev->dev, sizeof(u32),
747 (void *)ap->tx_csm, ap->tx_csm_dma);
753 static int ace_allocate_descriptors(struct net_device *dev)
755 struct ace_private *ap = netdev_priv(dev);
758 size = (sizeof(struct rx_desc) *
759 (RX_STD_RING_ENTRIES +
760 RX_JUMBO_RING_ENTRIES +
761 RX_MINI_RING_ENTRIES +
762 RX_RETURN_RING_ENTRIES));
764 ap->rx_std_ring = dma_alloc_coherent(&ap->pdev->dev, size,
765 &ap->rx_ring_base_dma, GFP_KERNEL);
766 if (ap->rx_std_ring == NULL)
769 ap->rx_jumbo_ring = ap->rx_std_ring + RX_STD_RING_ENTRIES;
770 ap->rx_mini_ring = ap->rx_jumbo_ring + RX_JUMBO_RING_ENTRIES;
771 ap->rx_return_ring = ap->rx_mini_ring + RX_MINI_RING_ENTRIES;
773 size = (sizeof(struct event) * EVT_RING_ENTRIES);
775 ap->evt_ring = dma_alloc_coherent(&ap->pdev->dev, size,
776 &ap->evt_ring_dma, GFP_KERNEL);
778 if (ap->evt_ring == NULL)
782 * Only allocate a host TX ring for the Tigon II, the Tigon I
783 * has to use PCI registers for this ;-(
785 if (!ACE_IS_TIGON_I(ap)) {
786 size = (sizeof(struct tx_desc) * MAX_TX_RING_ENTRIES);
788 ap->tx_ring = dma_alloc_coherent(&ap->pdev->dev, size,
789 &ap->tx_ring_dma, GFP_KERNEL);
791 if (ap->tx_ring == NULL)
795 ap->evt_prd = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
796 &ap->evt_prd_dma, GFP_KERNEL);
797 if (ap->evt_prd == NULL)
800 ap->rx_ret_prd = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
801 &ap->rx_ret_prd_dma, GFP_KERNEL);
802 if (ap->rx_ret_prd == NULL)
805 ap->tx_csm = dma_alloc_coherent(&ap->pdev->dev, sizeof(u32),
806 &ap->tx_csm_dma, GFP_KERNEL);
807 if (ap->tx_csm == NULL)
814 ace_init_cleanup(dev);
820 * Generic cleanup handling data allocated during init. Used when the
821 * module is unloaded or if an error occurs during initialization
823 static void ace_init_cleanup(struct net_device *dev)
825 struct ace_private *ap;
827 ap = netdev_priv(dev);
829 ace_free_descriptors(dev);
832 dma_free_coherent(&ap->pdev->dev, sizeof(struct ace_info),
833 ap->info, ap->info_dma);
835 kfree(ap->trace_buf);
838 free_irq(dev->irq, dev);
845 * Commands are considered to be slow.
847 static inline void ace_issue_cmd(struct ace_regs __iomem *regs, struct cmd *cmd)
851 idx = readl(®s->CmdPrd);
853 writel(*(u32 *)(cmd), ®s->CmdRng[idx]);
854 idx = (idx + 1) % CMD_RING_ENTRIES;
856 writel(idx, ®s->CmdPrd);
860 static int ace_init(struct net_device *dev)
862 struct ace_private *ap;
863 struct ace_regs __iomem *regs;
864 struct ace_info *info = NULL;
865 struct pci_dev *pdev;
868 u32 tig_ver, mac1, mac2, tmp, pci_state;
869 int board_idx, ecode = 0;
871 unsigned char cache_size;
873 ap = netdev_priv(dev);
876 board_idx = ap->board_idx;
879 * aman@sgi.com - its useful to do a NIC reset here to
880 * address the `Firmware not running' problem subsequent
881 * to any crashes involving the NIC
883 writel(HW_RESET | (HW_RESET << 24), ®s->HostCtrl);
884 readl(®s->HostCtrl); /* PCI write posting */
888 * Don't access any other registers before this point!
892 * This will most likely need BYTE_SWAP once we switch
893 * to using __raw_writel()
895 writel((WORD_SWAP | CLR_INT | ((WORD_SWAP | CLR_INT) << 24)),
898 writel((CLR_INT | WORD_SWAP | ((CLR_INT | WORD_SWAP) << 24)),
901 readl(®s->HostCtrl); /* PCI write posting */
904 * Stop the NIC CPU and clear pending interrupts
906 writel(readl(®s->CpuCtrl) | CPU_HALT, ®s->CpuCtrl);
907 readl(®s->CpuCtrl); /* PCI write posting */
908 writel(0, ®s->Mb0Lo);
910 tig_ver = readl(®s->HostCtrl) >> 28;
913 #ifndef CONFIG_ACENIC_OMIT_TIGON_I
916 printk(KERN_INFO " Tigon I (Rev. %i), Firmware: %i.%i.%i, ",
917 tig_ver, ap->firmware_major, ap->firmware_minor,
919 writel(0, ®s->LocalCtrl);
921 ap->tx_ring_entries = TIGON_I_TX_RING_ENTRIES;
925 printk(KERN_INFO " Tigon II (Rev. %i), Firmware: %i.%i.%i, ",
926 tig_ver, ap->firmware_major, ap->firmware_minor,
928 writel(readl(®s->CpuBCtrl) | CPU_HALT, ®s->CpuBCtrl);
929 readl(®s->CpuBCtrl); /* PCI write posting */
931 * The SRAM bank size does _not_ indicate the amount
932 * of memory on the card, it controls the _bank_ size!
933 * Ie. a 1MB AceNIC will have two banks of 512KB.
935 writel(SRAM_BANK_512K, ®s->LocalCtrl);
936 writel(SYNC_SRAM_TIMING, ®s->MiscCfg);
938 ap->tx_ring_entries = MAX_TX_RING_ENTRIES;
941 printk(KERN_WARNING " Unsupported Tigon version detected "
948 * ModeStat _must_ be set after the SRAM settings as this change
949 * seems to corrupt the ModeStat and possible other registers.
950 * The SRAM settings survive resets and setting it to the same
951 * value a second time works as well. This is what caused the
952 * `Firmware not running' problem on the Tigon II.
955 writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL | ACE_BYTE_SWAP_BD |
956 ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, ®s->ModeStat);
958 writel(ACE_BYTE_SWAP_DMA | ACE_WARN | ACE_FATAL |
959 ACE_WORD_SWAP_BD | ACE_NO_JUMBO_FRAG, ®s->ModeStat);
961 readl(®s->ModeStat); /* PCI write posting */
964 for(i = 0; i < 4; i++) {
968 t = read_eeprom_byte(dev, 0x8c+i);
976 for(i = 4; i < 8; i++) {
980 t = read_eeprom_byte(dev, 0x8c+i);
988 writel(mac1, ®s->MacAddrHi);
989 writel(mac2, ®s->MacAddrLo);
991 dev->dev_addr[0] = (mac1 >> 8) & 0xff;
992 dev->dev_addr[1] = mac1 & 0xff;
993 dev->dev_addr[2] = (mac2 >> 24) & 0xff;
994 dev->dev_addr[3] = (mac2 >> 16) & 0xff;
995 dev->dev_addr[4] = (mac2 >> 8) & 0xff;
996 dev->dev_addr[5] = mac2 & 0xff;
998 printk("MAC: %pM\n", dev->dev_addr);
1001 * Looks like this is necessary to deal with on all architectures,
1002 * even this %$#%$# N440BX Intel based thing doesn't get it right.
1003 * Ie. having two NICs in the machine, one will have the cache
1004 * line set at boot time, the other will not.
1007 pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_size);
1009 if (cache_size != SMP_CACHE_BYTES) {
1010 printk(KERN_INFO " PCI cache line size set incorrectly "
1011 "(%i bytes) by BIOS/FW, ", cache_size);
1012 if (cache_size > SMP_CACHE_BYTES)
1013 printk("expecting %i\n", SMP_CACHE_BYTES);
1015 printk("correcting to %i\n", SMP_CACHE_BYTES);
1016 pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
1017 SMP_CACHE_BYTES >> 2);
1021 pci_state = readl(®s->PciState);
1022 printk(KERN_INFO " PCI bus width: %i bits, speed: %iMHz, "
1023 "latency: %i clks\n",
1024 (pci_state & PCI_32BIT) ? 32 : 64,
1025 (pci_state & PCI_66MHZ) ? 66 : 33,
1029 * Set the max DMA transfer size. Seems that for most systems
1030 * the performance is better when no MAX parameter is
1031 * set. However for systems enabling PCI write and invalidate,
1032 * DMA writes must be set to the L1 cache line size to get
1033 * optimal performance.
1035 * The default is now to turn the PCI write and invalidate off
1036 * - that is what Alteon does for NT.
1038 tmp = READ_CMD_MEM | WRITE_CMD_MEM;
1039 if (ap->version >= 2) {
1040 tmp |= (MEM_READ_MULTIPLE | (pci_state & PCI_66MHZ));
1042 * Tuning parameters only supported for 8 cards
1044 if (board_idx == BOARD_IDX_OVERFLOW ||
1045 dis_pci_mem_inval[board_idx]) {
1046 if (ap->pci_command & PCI_COMMAND_INVALIDATE) {
1047 ap->pci_command &= ~PCI_COMMAND_INVALIDATE;
1048 pci_write_config_word(pdev, PCI_COMMAND,
1050 printk(KERN_INFO " Disabling PCI memory "
1051 "write and invalidate\n");
1053 } else if (ap->pci_command & PCI_COMMAND_INVALIDATE) {
1054 printk(KERN_INFO " PCI memory write & invalidate "
1055 "enabled by BIOS, enabling counter measures\n");
1057 switch(SMP_CACHE_BYTES) {
1059 tmp |= DMA_WRITE_MAX_16;
1062 tmp |= DMA_WRITE_MAX_32;
1065 tmp |= DMA_WRITE_MAX_64;
1068 tmp |= DMA_WRITE_MAX_128;
1071 printk(KERN_INFO " Cache line size %i not "
1072 "supported, PCI write and invalidate "
1073 "disabled\n", SMP_CACHE_BYTES);
1074 ap->pci_command &= ~PCI_COMMAND_INVALIDATE;
1075 pci_write_config_word(pdev, PCI_COMMAND,
1083 * On this platform, we know what the best dma settings
1084 * are. We use 64-byte maximum bursts, because if we
1085 * burst larger than the cache line size (or even cross
1086 * a 64byte boundary in a single burst) the UltraSparc
1087 * PCI controller will disconnect at 64-byte multiples.
1089 * Read-multiple will be properly enabled above, and when
1090 * set will give the PCI controller proper hints about
1093 tmp &= ~DMA_READ_WRITE_MASK;
1094 tmp |= DMA_READ_MAX_64;
1095 tmp |= DMA_WRITE_MAX_64;
1098 tmp &= ~DMA_READ_WRITE_MASK;
1099 tmp |= DMA_READ_MAX_128;
1101 * All the docs say MUST NOT. Well, I did.
1102 * Nothing terrible happens, if we load wrong size.
1103 * Bit w&i still works better!
1105 tmp |= DMA_WRITE_MAX_128;
1107 writel(tmp, ®s->PciState);
1111 * The Host PCI bus controller driver has to set FBB.
1112 * If all devices on that PCI bus support FBB, then the controller
1113 * can enable FBB support in the Host PCI Bus controller (or on
1114 * the PCI-PCI bridge if that applies).
1118 * I have received reports from people having problems when this
1121 if (!(ap->pci_command & PCI_COMMAND_FAST_BACK)) {
1122 printk(KERN_INFO " Enabling PCI Fast Back to Back\n");
1123 ap->pci_command |= PCI_COMMAND_FAST_BACK;
1124 pci_write_config_word(pdev, PCI_COMMAND, ap->pci_command);
1129 * Configure DMA attributes.
1131 if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
1132 ap->pci_using_dac = 1;
1133 } else if (!dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) {
1134 ap->pci_using_dac = 0;
1141 * Initialize the generic info block and the command+event rings
1142 * and the control blocks for the transmit and receive rings
1143 * as they need to be setup once and for all.
1145 if (!(info = dma_alloc_coherent(&ap->pdev->dev, sizeof(struct ace_info),
1146 &ap->info_dma, GFP_KERNEL))) {
1153 * Get the memory for the skb rings.
1155 if (!(ap->skb = kzalloc(sizeof(struct ace_skb), GFP_KERNEL))) {
1160 ecode = request_irq(pdev->irq, ace_interrupt, IRQF_SHARED,
1163 printk(KERN_WARNING "%s: Requested IRQ %d is busy\n",
1164 DRV_NAME, pdev->irq);
1167 dev->irq = pdev->irq;
1170 spin_lock_init(&ap->debug_lock);
1171 ap->last_tx = ACE_TX_RING_ENTRIES(ap) - 1;
1172 ap->last_std_rx = 0;
1173 ap->last_mini_rx = 0;
1176 ecode = ace_load_firmware(dev);
1182 tmp_ptr = ap->info_dma;
1183 writel(tmp_ptr >> 32, ®s->InfoPtrHi);
1184 writel(tmp_ptr & 0xffffffff, ®s->InfoPtrLo);
1186 memset(ap->evt_ring, 0, EVT_RING_ENTRIES * sizeof(struct event));
1188 set_aceaddr(&info->evt_ctrl.rngptr, ap->evt_ring_dma);
1189 info->evt_ctrl.flags = 0;
1193 set_aceaddr(&info->evt_prd_ptr, ap->evt_prd_dma);
1194 writel(0, ®s->EvtCsm);
1196 set_aceaddr(&info->cmd_ctrl.rngptr, 0x100);
1197 info->cmd_ctrl.flags = 0;
1198 info->cmd_ctrl.max_len = 0;
1200 for (i = 0; i < CMD_RING_ENTRIES; i++)
1201 writel(0, ®s->CmdRng[i]);
1203 writel(0, ®s->CmdPrd);
1204 writel(0, ®s->CmdCsm);
1206 tmp_ptr = ap->info_dma;
1207 tmp_ptr += (unsigned long) &(((struct ace_info *)0)->s.stats);
1208 set_aceaddr(&info->stats2_ptr, (dma_addr_t) tmp_ptr);
1210 set_aceaddr(&info->rx_std_ctrl.rngptr, ap->rx_ring_base_dma);
1211 info->rx_std_ctrl.max_len = ACE_STD_BUFSIZE;
1212 info->rx_std_ctrl.flags =
1213 RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1215 memset(ap->rx_std_ring, 0,
1216 RX_STD_RING_ENTRIES * sizeof(struct rx_desc));
1218 for (i = 0; i < RX_STD_RING_ENTRIES; i++)
1219 ap->rx_std_ring[i].flags = BD_FLG_TCP_UDP_SUM;
1221 ap->rx_std_skbprd = 0;
1222 atomic_set(&ap->cur_rx_bufs, 0);
1224 set_aceaddr(&info->rx_jumbo_ctrl.rngptr,
1225 (ap->rx_ring_base_dma +
1226 (sizeof(struct rx_desc) * RX_STD_RING_ENTRIES)));
1227 info->rx_jumbo_ctrl.max_len = 0;
1228 info->rx_jumbo_ctrl.flags =
1229 RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1231 memset(ap->rx_jumbo_ring, 0,
1232 RX_JUMBO_RING_ENTRIES * sizeof(struct rx_desc));
1234 for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++)
1235 ap->rx_jumbo_ring[i].flags = BD_FLG_TCP_UDP_SUM | BD_FLG_JUMBO;
1237 ap->rx_jumbo_skbprd = 0;
1238 atomic_set(&ap->cur_jumbo_bufs, 0);
1240 memset(ap->rx_mini_ring, 0,
1241 RX_MINI_RING_ENTRIES * sizeof(struct rx_desc));
1243 if (ap->version >= 2) {
1244 set_aceaddr(&info->rx_mini_ctrl.rngptr,
1245 (ap->rx_ring_base_dma +
1246 (sizeof(struct rx_desc) *
1247 (RX_STD_RING_ENTRIES +
1248 RX_JUMBO_RING_ENTRIES))));
1249 info->rx_mini_ctrl.max_len = ACE_MINI_SIZE;
1250 info->rx_mini_ctrl.flags =
1251 RCB_FLG_TCP_UDP_SUM|RCB_FLG_NO_PSEUDO_HDR|RCB_FLG_VLAN_ASSIST;
1253 for (i = 0; i < RX_MINI_RING_ENTRIES; i++)
1254 ap->rx_mini_ring[i].flags =
1255 BD_FLG_TCP_UDP_SUM | BD_FLG_MINI;
1257 set_aceaddr(&info->rx_mini_ctrl.rngptr, 0);
1258 info->rx_mini_ctrl.flags = RCB_FLG_RNG_DISABLE;
1259 info->rx_mini_ctrl.max_len = 0;
1262 ap->rx_mini_skbprd = 0;
1263 atomic_set(&ap->cur_mini_bufs, 0);
1265 set_aceaddr(&info->rx_return_ctrl.rngptr,
1266 (ap->rx_ring_base_dma +
1267 (sizeof(struct rx_desc) *
1268 (RX_STD_RING_ENTRIES +
1269 RX_JUMBO_RING_ENTRIES +
1270 RX_MINI_RING_ENTRIES))));
1271 info->rx_return_ctrl.flags = 0;
1272 info->rx_return_ctrl.max_len = RX_RETURN_RING_ENTRIES;
1274 memset(ap->rx_return_ring, 0,
1275 RX_RETURN_RING_ENTRIES * sizeof(struct rx_desc));
1277 set_aceaddr(&info->rx_ret_prd_ptr, ap->rx_ret_prd_dma);
1278 *(ap->rx_ret_prd) = 0;
1280 writel(TX_RING_BASE, ®s->WinBase);
1282 if (ACE_IS_TIGON_I(ap)) {
1283 ap->tx_ring = (__force struct tx_desc *) regs->Window;
1284 for (i = 0; i < (TIGON_I_TX_RING_ENTRIES
1285 * sizeof(struct tx_desc)) / sizeof(u32); i++)
1286 writel(0, (__force void __iomem *)ap->tx_ring + i * 4);
1288 set_aceaddr(&info->tx_ctrl.rngptr, TX_RING_BASE);
1290 memset(ap->tx_ring, 0,
1291 MAX_TX_RING_ENTRIES * sizeof(struct tx_desc));
1293 set_aceaddr(&info->tx_ctrl.rngptr, ap->tx_ring_dma);
1296 info->tx_ctrl.max_len = ACE_TX_RING_ENTRIES(ap);
1297 tmp = RCB_FLG_TCP_UDP_SUM | RCB_FLG_NO_PSEUDO_HDR | RCB_FLG_VLAN_ASSIST;
1300 * The Tigon I does not like having the TX ring in host memory ;-(
1302 if (!ACE_IS_TIGON_I(ap))
1303 tmp |= RCB_FLG_TX_HOST_RING;
1304 #if TX_COAL_INTS_ONLY
1305 tmp |= RCB_FLG_COAL_INT_ONLY;
1307 info->tx_ctrl.flags = tmp;
1309 set_aceaddr(&info->tx_csm_ptr, ap->tx_csm_dma);
1312 * Potential item for tuning parameter
1315 writel(DMA_THRESH_16W, ®s->DmaReadCfg);
1316 writel(DMA_THRESH_16W, ®s->DmaWriteCfg);
1318 writel(DMA_THRESH_8W, ®s->DmaReadCfg);
1319 writel(DMA_THRESH_8W, ®s->DmaWriteCfg);
1322 writel(0, ®s->MaskInt);
1323 writel(1, ®s->IfIdx);
1326 * McKinley boxes do not like us fiddling with AssistState
1329 writel(1, ®s->AssistState);
1332 writel(DEF_STAT, ®s->TuneStatTicks);
1333 writel(DEF_TRACE, ®s->TuneTrace);
1335 ace_set_rxtx_parms(dev, 0);
1337 if (board_idx == BOARD_IDX_OVERFLOW) {
1338 printk(KERN_WARNING "%s: more than %i NICs detected, "
1339 "ignoring module parameters!\n",
1340 ap->name, ACE_MAX_MOD_PARMS);
1341 } else if (board_idx >= 0) {
1342 if (tx_coal_tick[board_idx])
1343 writel(tx_coal_tick[board_idx],
1344 ®s->TuneTxCoalTicks);
1345 if (max_tx_desc[board_idx])
1346 writel(max_tx_desc[board_idx], ®s->TuneMaxTxDesc);
1348 if (rx_coal_tick[board_idx])
1349 writel(rx_coal_tick[board_idx],
1350 ®s->TuneRxCoalTicks);
1351 if (max_rx_desc[board_idx])
1352 writel(max_rx_desc[board_idx], ®s->TuneMaxRxDesc);
1354 if (trace[board_idx])
1355 writel(trace[board_idx], ®s->TuneTrace);
1357 if ((tx_ratio[board_idx] > 0) && (tx_ratio[board_idx] < 64))
1358 writel(tx_ratio[board_idx], ®s->TxBufRat);
1362 * Default link parameters
1364 tmp = LNK_ENABLE | LNK_FULL_DUPLEX | LNK_1000MB | LNK_100MB |
1365 LNK_10MB | LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL | LNK_NEGOTIATE;
1366 if(ap->version >= 2)
1367 tmp |= LNK_TX_FLOW_CTL_Y;
1370 * Override link default parameters
1372 if ((board_idx >= 0) && link_state[board_idx]) {
1373 int option = link_state[board_idx];
1377 if (option & 0x01) {
1378 printk(KERN_INFO "%s: Setting half duplex link\n",
1380 tmp &= ~LNK_FULL_DUPLEX;
1383 tmp &= ~LNK_NEGOTIATE;
1390 if ((option & 0x70) == 0) {
1391 printk(KERN_WARNING "%s: No media speed specified, "
1392 "forcing auto negotiation\n", ap->name);
1393 tmp |= LNK_NEGOTIATE | LNK_1000MB |
1394 LNK_100MB | LNK_10MB;
1396 if ((option & 0x100) == 0)
1397 tmp |= LNK_NEG_FCTL;
1399 printk(KERN_INFO "%s: Disabling flow control "
1400 "negotiation\n", ap->name);
1402 tmp |= LNK_RX_FLOW_CTL_Y;
1403 if ((option & 0x400) && (ap->version >= 2)) {
1404 printk(KERN_INFO "%s: Enabling TX flow control\n",
1406 tmp |= LNK_TX_FLOW_CTL_Y;
1411 writel(tmp, ®s->TuneLink);
1412 if (ap->version >= 2)
1413 writel(tmp, ®s->TuneFastLink);
1415 writel(ap->firmware_start, ®s->Pc);
1417 writel(0, ®s->Mb0Lo);
1420 * Set tx_csm before we start receiving interrupts, otherwise
1421 * the interrupt handler might think it is supposed to process
1422 * tx ints before we are up and running, which may cause a null
1423 * pointer access in the int handler.
1426 ap->tx_prd = *(ap->tx_csm) = ap->tx_ret_csm = 0;
1429 ace_set_txprd(regs, ap, 0);
1430 writel(0, ®s->RxRetCsm);
1433 * Enable DMA engine now.
1434 * If we do this sooner, Mckinley box pukes.
1435 * I assume it's because Tigon II DMA engine wants to check
1436 * *something* even before the CPU is started.
1438 writel(1, ®s->AssistState); /* enable DMA */
1443 writel(readl(®s->CpuCtrl) & ~(CPU_HALT|CPU_TRACE), ®s->CpuCtrl);
1444 readl(®s->CpuCtrl);
1447 * Wait for the firmware to spin up - max 3 seconds.
1449 myjif = jiffies + 3 * HZ;
1450 while (time_before(jiffies, myjif) && !ap->fw_running)
1453 if (!ap->fw_running) {
1454 printk(KERN_ERR "%s: Firmware NOT running!\n", ap->name);
1457 writel(readl(®s->CpuCtrl) | CPU_HALT, ®s->CpuCtrl);
1458 readl(®s->CpuCtrl);
1460 /* aman@sgi.com - account for badly behaving firmware/NIC:
1461 * - have observed that the NIC may continue to generate
1462 * interrupts for some reason; attempt to stop it - halt
1463 * second CPU for Tigon II cards, and also clear Mb0
1464 * - if we're a module, we'll fail to load if this was
1465 * the only GbE card in the system => if the kernel does
1466 * see an interrupt from the NIC, code to handle it is
1467 * gone and OOps! - so free_irq also
1469 if (ap->version >= 2)
1470 writel(readl(®s->CpuBCtrl) | CPU_HALT,
1472 writel(0, ®s->Mb0Lo);
1473 readl(®s->Mb0Lo);
1480 * We load the ring here as there seem to be no way to tell the
1481 * firmware to wipe the ring without re-initializing it.
1483 if (!test_and_set_bit(0, &ap->std_refill_busy))
1484 ace_load_std_rx_ring(dev, RX_RING_SIZE);
1486 printk(KERN_ERR "%s: Someone is busy refilling the RX ring\n",
1488 if (ap->version >= 2) {
1489 if (!test_and_set_bit(0, &ap->mini_refill_busy))
1490 ace_load_mini_rx_ring(dev, RX_MINI_SIZE);
1492 printk(KERN_ERR "%s: Someone is busy refilling "
1493 "the RX mini ring\n", ap->name);
1498 ace_init_cleanup(dev);
1503 static void ace_set_rxtx_parms(struct net_device *dev, int jumbo)
1505 struct ace_private *ap = netdev_priv(dev);
1506 struct ace_regs __iomem *regs = ap->regs;
1507 int board_idx = ap->board_idx;
1509 if (board_idx >= 0) {
1511 if (!tx_coal_tick[board_idx])
1512 writel(DEF_TX_COAL, ®s->TuneTxCoalTicks);
1513 if (!max_tx_desc[board_idx])
1514 writel(DEF_TX_MAX_DESC, ®s->TuneMaxTxDesc);
1515 if (!rx_coal_tick[board_idx])
1516 writel(DEF_RX_COAL, ®s->TuneRxCoalTicks);
1517 if (!max_rx_desc[board_idx])
1518 writel(DEF_RX_MAX_DESC, ®s->TuneMaxRxDesc);
1519 if (!tx_ratio[board_idx])
1520 writel(DEF_TX_RATIO, ®s->TxBufRat);
1522 if (!tx_coal_tick[board_idx])
1523 writel(DEF_JUMBO_TX_COAL,
1524 ®s->TuneTxCoalTicks);
1525 if (!max_tx_desc[board_idx])
1526 writel(DEF_JUMBO_TX_MAX_DESC,
1527 ®s->TuneMaxTxDesc);
1528 if (!rx_coal_tick[board_idx])
1529 writel(DEF_JUMBO_RX_COAL,
1530 ®s->TuneRxCoalTicks);
1531 if (!max_rx_desc[board_idx])
1532 writel(DEF_JUMBO_RX_MAX_DESC,
1533 ®s->TuneMaxRxDesc);
1534 if (!tx_ratio[board_idx])
1535 writel(DEF_JUMBO_TX_RATIO, ®s->TxBufRat);
1541 static void ace_watchdog(struct net_device *data, unsigned int txqueue)
1543 struct net_device *dev = data;
1544 struct ace_private *ap = netdev_priv(dev);
1545 struct ace_regs __iomem *regs = ap->regs;
1548 * We haven't received a stats update event for more than 2.5
1549 * seconds and there is data in the transmit queue, thus we
1550 * assume the card is stuck.
1552 if (*ap->tx_csm != ap->tx_ret_csm) {
1553 printk(KERN_WARNING "%s: Transmitter is stuck, %08x\n",
1554 dev->name, (unsigned int)readl(®s->HostCtrl));
1555 /* This can happen due to ieee flow control. */
1557 printk(KERN_DEBUG "%s: BUG... transmitter died. Kicking it.\n",
1560 netif_wake_queue(dev);
1566 static void ace_tasklet(struct tasklet_struct *t)
1568 struct ace_private *ap = from_tasklet(ap, t, ace_tasklet);
1569 struct net_device *dev = ap->ndev;
1572 cur_size = atomic_read(&ap->cur_rx_bufs);
1573 if ((cur_size < RX_LOW_STD_THRES) &&
1574 !test_and_set_bit(0, &ap->std_refill_busy)) {
1576 printk("refilling buffers (current %i)\n", cur_size);
1578 ace_load_std_rx_ring(dev, RX_RING_SIZE - cur_size);
1581 if (ap->version >= 2) {
1582 cur_size = atomic_read(&ap->cur_mini_bufs);
1583 if ((cur_size < RX_LOW_MINI_THRES) &&
1584 !test_and_set_bit(0, &ap->mini_refill_busy)) {
1586 printk("refilling mini buffers (current %i)\n",
1589 ace_load_mini_rx_ring(dev, RX_MINI_SIZE - cur_size);
1593 cur_size = atomic_read(&ap->cur_jumbo_bufs);
1594 if (ap->jumbo && (cur_size < RX_LOW_JUMBO_THRES) &&
1595 !test_and_set_bit(0, &ap->jumbo_refill_busy)) {
1597 printk("refilling jumbo buffers (current %i)\n", cur_size);
1599 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE - cur_size);
1601 ap->tasklet_pending = 0;
1606 * Copy the contents of the NIC's trace buffer to kernel memory.
1608 static void ace_dump_trace(struct ace_private *ap)
1612 if (!(ap->trace_buf = kmalloc(ACE_TRACE_SIZE, GFP_KERNEL)))
1619 * Load the standard rx ring.
1621 * Loading rings is safe without holding the spin lock since this is
1622 * done only before the device is enabled, thus no interrupts are
1623 * generated and by the interrupt handler/tasklet handler.
1625 static void ace_load_std_rx_ring(struct net_device *dev, int nr_bufs)
1627 struct ace_private *ap = netdev_priv(dev);
1628 struct ace_regs __iomem *regs = ap->regs;
1632 prefetchw(&ap->cur_rx_bufs);
1634 idx = ap->rx_std_skbprd;
1636 for (i = 0; i < nr_bufs; i++) {
1637 struct sk_buff *skb;
1641 skb = netdev_alloc_skb_ip_align(dev, ACE_STD_BUFSIZE);
1645 mapping = dma_map_page(&ap->pdev->dev,
1646 virt_to_page(skb->data),
1647 offset_in_page(skb->data),
1648 ACE_STD_BUFSIZE, DMA_FROM_DEVICE);
1649 ap->skb->rx_std_skbuff[idx].skb = skb;
1650 dma_unmap_addr_set(&ap->skb->rx_std_skbuff[idx],
1653 rd = &ap->rx_std_ring[idx];
1654 set_aceaddr(&rd->addr, mapping);
1655 rd->size = ACE_STD_BUFSIZE;
1657 idx = (idx + 1) % RX_STD_RING_ENTRIES;
1663 atomic_add(i, &ap->cur_rx_bufs);
1664 ap->rx_std_skbprd = idx;
1666 if (ACE_IS_TIGON_I(ap)) {
1668 cmd.evt = C_SET_RX_PRD_IDX;
1670 cmd.idx = ap->rx_std_skbprd;
1671 ace_issue_cmd(regs, &cmd);
1673 writel(idx, ®s->RxStdPrd);
1678 clear_bit(0, &ap->std_refill_busy);
1682 printk(KERN_INFO "Out of memory when allocating "
1683 "standard receive buffers\n");
1688 static void ace_load_mini_rx_ring(struct net_device *dev, int nr_bufs)
1690 struct ace_private *ap = netdev_priv(dev);
1691 struct ace_regs __iomem *regs = ap->regs;
1694 prefetchw(&ap->cur_mini_bufs);
1696 idx = ap->rx_mini_skbprd;
1697 for (i = 0; i < nr_bufs; i++) {
1698 struct sk_buff *skb;
1702 skb = netdev_alloc_skb_ip_align(dev, ACE_MINI_BUFSIZE);
1706 mapping = dma_map_page(&ap->pdev->dev,
1707 virt_to_page(skb->data),
1708 offset_in_page(skb->data),
1709 ACE_MINI_BUFSIZE, DMA_FROM_DEVICE);
1710 ap->skb->rx_mini_skbuff[idx].skb = skb;
1711 dma_unmap_addr_set(&ap->skb->rx_mini_skbuff[idx],
1714 rd = &ap->rx_mini_ring[idx];
1715 set_aceaddr(&rd->addr, mapping);
1716 rd->size = ACE_MINI_BUFSIZE;
1718 idx = (idx + 1) % RX_MINI_RING_ENTRIES;
1724 atomic_add(i, &ap->cur_mini_bufs);
1726 ap->rx_mini_skbprd = idx;
1728 writel(idx, ®s->RxMiniPrd);
1732 clear_bit(0, &ap->mini_refill_busy);
1735 printk(KERN_INFO "Out of memory when allocating "
1736 "mini receive buffers\n");
1742 * Load the jumbo rx ring, this may happen at any time if the MTU
1743 * is changed to a value > 1500.
1745 static void ace_load_jumbo_rx_ring(struct net_device *dev, int nr_bufs)
1747 struct ace_private *ap = netdev_priv(dev);
1748 struct ace_regs __iomem *regs = ap->regs;
1751 idx = ap->rx_jumbo_skbprd;
1753 for (i = 0; i < nr_bufs; i++) {
1754 struct sk_buff *skb;
1758 skb = netdev_alloc_skb_ip_align(dev, ACE_JUMBO_BUFSIZE);
1762 mapping = dma_map_page(&ap->pdev->dev,
1763 virt_to_page(skb->data),
1764 offset_in_page(skb->data),
1765 ACE_JUMBO_BUFSIZE, DMA_FROM_DEVICE);
1766 ap->skb->rx_jumbo_skbuff[idx].skb = skb;
1767 dma_unmap_addr_set(&ap->skb->rx_jumbo_skbuff[idx],
1770 rd = &ap->rx_jumbo_ring[idx];
1771 set_aceaddr(&rd->addr, mapping);
1772 rd->size = ACE_JUMBO_BUFSIZE;
1774 idx = (idx + 1) % RX_JUMBO_RING_ENTRIES;
1780 atomic_add(i, &ap->cur_jumbo_bufs);
1781 ap->rx_jumbo_skbprd = idx;
1783 if (ACE_IS_TIGON_I(ap)) {
1785 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1787 cmd.idx = ap->rx_jumbo_skbprd;
1788 ace_issue_cmd(regs, &cmd);
1790 writel(idx, ®s->RxJumboPrd);
1795 clear_bit(0, &ap->jumbo_refill_busy);
1798 if (net_ratelimit())
1799 printk(KERN_INFO "Out of memory when allocating "
1800 "jumbo receive buffers\n");
1806 * All events are considered to be slow (RX/TX ints do not generate
1807 * events) and are handled here, outside the main interrupt handler,
1808 * to reduce the size of the handler.
1810 static u32 ace_handle_event(struct net_device *dev, u32 evtcsm, u32 evtprd)
1812 struct ace_private *ap;
1814 ap = netdev_priv(dev);
1816 while (evtcsm != evtprd) {
1817 switch (ap->evt_ring[evtcsm].evt) {
1819 printk(KERN_INFO "%s: Firmware up and running\n",
1824 case E_STATS_UPDATED:
1828 u16 code = ap->evt_ring[evtcsm].code;
1832 u32 state = readl(&ap->regs->GigLnkState);
1833 printk(KERN_WARNING "%s: Optical link UP "
1834 "(%s Duplex, Flow Control: %s%s)\n",
1836 state & LNK_FULL_DUPLEX ? "Full":"Half",
1837 state & LNK_TX_FLOW_CTL_Y ? "TX " : "",
1838 state & LNK_RX_FLOW_CTL_Y ? "RX" : "");
1842 printk(KERN_WARNING "%s: Optical link DOWN\n",
1845 case E_C_LINK_10_100:
1846 printk(KERN_WARNING "%s: 10/100BaseT link "
1850 printk(KERN_ERR "%s: Unknown optical link "
1851 "state %02x\n", ap->name, code);
1856 switch(ap->evt_ring[evtcsm].code) {
1857 case E_C_ERR_INVAL_CMD:
1858 printk(KERN_ERR "%s: invalid command error\n",
1861 case E_C_ERR_UNIMP_CMD:
1862 printk(KERN_ERR "%s: unimplemented command "
1863 "error\n", ap->name);
1865 case E_C_ERR_BAD_CFG:
1866 printk(KERN_ERR "%s: bad config error\n",
1870 printk(KERN_ERR "%s: unknown error %02x\n",
1871 ap->name, ap->evt_ring[evtcsm].code);
1874 case E_RESET_JUMBO_RNG:
1877 for (i = 0; i < RX_JUMBO_RING_ENTRIES; i++) {
1878 if (ap->skb->rx_jumbo_skbuff[i].skb) {
1879 ap->rx_jumbo_ring[i].size = 0;
1880 set_aceaddr(&ap->rx_jumbo_ring[i].addr, 0);
1881 dev_kfree_skb(ap->skb->rx_jumbo_skbuff[i].skb);
1882 ap->skb->rx_jumbo_skbuff[i].skb = NULL;
1886 if (ACE_IS_TIGON_I(ap)) {
1888 cmd.evt = C_SET_RX_JUMBO_PRD_IDX;
1891 ace_issue_cmd(ap->regs, &cmd);
1893 writel(0, &((ap->regs)->RxJumboPrd));
1898 ap->rx_jumbo_skbprd = 0;
1899 printk(KERN_INFO "%s: Jumbo ring flushed\n",
1901 clear_bit(0, &ap->jumbo_refill_busy);
1905 printk(KERN_ERR "%s: Unhandled event 0x%02x\n",
1906 ap->name, ap->evt_ring[evtcsm].evt);
1908 evtcsm = (evtcsm + 1) % EVT_RING_ENTRIES;
1915 static void ace_rx_int(struct net_device *dev, u32 rxretprd, u32 rxretcsm)
1917 struct ace_private *ap = netdev_priv(dev);
1919 int mini_count = 0, std_count = 0;
1923 prefetchw(&ap->cur_rx_bufs);
1924 prefetchw(&ap->cur_mini_bufs);
1926 while (idx != rxretprd) {
1927 struct ring_info *rip;
1928 struct sk_buff *skb;
1929 struct rx_desc *retdesc;
1931 int bd_flags, desc_type, mapsize;
1935 /* make sure the rx descriptor isn't read before rxretprd */
1936 if (idx == rxretcsm)
1939 retdesc = &ap->rx_return_ring[idx];
1940 skbidx = retdesc->idx;
1941 bd_flags = retdesc->flags;
1942 desc_type = bd_flags & (BD_FLG_JUMBO | BD_FLG_MINI);
1946 * Normal frames do not have any flags set
1948 * Mini and normal frames arrive frequently,
1949 * so use a local counter to avoid doing
1950 * atomic operations for each packet arriving.
1953 rip = &ap->skb->rx_std_skbuff[skbidx];
1954 mapsize = ACE_STD_BUFSIZE;
1958 rip = &ap->skb->rx_jumbo_skbuff[skbidx];
1959 mapsize = ACE_JUMBO_BUFSIZE;
1960 atomic_dec(&ap->cur_jumbo_bufs);
1963 rip = &ap->skb->rx_mini_skbuff[skbidx];
1964 mapsize = ACE_MINI_BUFSIZE;
1968 printk(KERN_INFO "%s: unknown frame type (0x%02x) "
1969 "returned by NIC\n", dev->name,
1976 dma_unmap_page(&ap->pdev->dev, dma_unmap_addr(rip, mapping),
1977 mapsize, DMA_FROM_DEVICE);
1978 skb_put(skb, retdesc->size);
1983 csum = retdesc->tcp_udp_csum;
1985 skb->protocol = eth_type_trans(skb, dev);
1988 * Instead of forcing the poor tigon mips cpu to calculate
1989 * pseudo hdr checksum, we do this ourselves.
1991 if (bd_flags & BD_FLG_TCP_UDP_SUM) {
1992 skb->csum = htons(csum);
1993 skb->ip_summed = CHECKSUM_COMPLETE;
1995 skb_checksum_none_assert(skb);
1999 if ((bd_flags & BD_FLG_VLAN_TAG))
2000 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), retdesc->vlan);
2003 dev->stats.rx_packets++;
2004 dev->stats.rx_bytes += retdesc->size;
2006 idx = (idx + 1) % RX_RETURN_RING_ENTRIES;
2009 atomic_sub(std_count, &ap->cur_rx_bufs);
2010 if (!ACE_IS_TIGON_I(ap))
2011 atomic_sub(mini_count, &ap->cur_mini_bufs);
2015 * According to the documentation RxRetCsm is obsolete with
2016 * the 12.3.x Firmware - my Tigon I NICs seem to disagree!
2018 if (ACE_IS_TIGON_I(ap)) {
2019 writel(idx, &ap->regs->RxRetCsm);
2030 static inline void ace_tx_int(struct net_device *dev,
2033 struct ace_private *ap = netdev_priv(dev);
2036 struct sk_buff *skb;
2037 struct tx_ring_info *info;
2039 info = ap->skb->tx_skbuff + idx;
2042 if (dma_unmap_len(info, maplen)) {
2043 dma_unmap_page(&ap->pdev->dev,
2044 dma_unmap_addr(info, mapping),
2045 dma_unmap_len(info, maplen),
2047 dma_unmap_len_set(info, maplen, 0);
2051 dev->stats.tx_packets++;
2052 dev->stats.tx_bytes += skb->len;
2053 dev_consume_skb_irq(skb);
2057 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2058 } while (idx != txcsm);
2060 if (netif_queue_stopped(dev))
2061 netif_wake_queue(dev);
2064 ap->tx_ret_csm = txcsm;
2066 /* So... tx_ret_csm is advanced _after_ check for device wakeup.
2068 * We could try to make it before. In this case we would get
2069 * the following race condition: hard_start_xmit on other cpu
2070 * enters after we advanced tx_ret_csm and fills space,
2071 * which we have just freed, so that we make illegal device wakeup.
2072 * There is no good way to workaround this (at entry
2073 * to ace_start_xmit detects this condition and prevents
2074 * ring corruption, but it is not a good workaround.)
2076 * When tx_ret_csm is advanced after, we wake up device _only_
2077 * if we really have some space in ring (though the core doing
2078 * hard_start_xmit can see full ring for some period and has to
2079 * synchronize.) Superb.
2080 * BUT! We get another subtle race condition. hard_start_xmit
2081 * may think that ring is full between wakeup and advancing
2082 * tx_ret_csm and will stop device instantly! It is not so bad.
2083 * We are guaranteed that there is something in ring, so that
2084 * the next irq will resume transmission. To speedup this we could
2085 * mark descriptor, which closes ring with BD_FLG_COAL_NOW
2086 * (see ace_start_xmit).
2088 * Well, this dilemma exists in all lock-free devices.
2089 * We, following scheme used in drivers by Donald Becker,
2090 * select the least dangerous.
2096 static irqreturn_t ace_interrupt(int irq, void *dev_id)
2098 struct net_device *dev = (struct net_device *)dev_id;
2099 struct ace_private *ap = netdev_priv(dev);
2100 struct ace_regs __iomem *regs = ap->regs;
2102 u32 txcsm, rxretcsm, rxretprd;
2106 * In case of PCI shared interrupts or spurious interrupts,
2107 * we want to make sure it is actually our interrupt before
2108 * spending any time in here.
2110 if (!(readl(®s->HostCtrl) & IN_INT))
2114 * ACK intr now. Otherwise we will lose updates to rx_ret_prd,
2115 * which happened _after_ rxretprd = *ap->rx_ret_prd; but before
2116 * writel(0, ®s->Mb0Lo).
2118 * "IRQ avoidance" recommended in docs applies to IRQs served
2119 * threads and it is wrong even for that case.
2121 writel(0, ®s->Mb0Lo);
2122 readl(®s->Mb0Lo);
2125 * There is no conflict between transmit handling in
2126 * start_xmit and receive processing, thus there is no reason
2127 * to take a spin lock for RX handling. Wait until we start
2128 * working on the other stuff - hey we don't need a spin lock
2131 rxretprd = *ap->rx_ret_prd;
2132 rxretcsm = ap->cur_rx;
2134 if (rxretprd != rxretcsm)
2135 ace_rx_int(dev, rxretprd, rxretcsm);
2137 txcsm = *ap->tx_csm;
2138 idx = ap->tx_ret_csm;
2142 * If each skb takes only one descriptor this check degenerates
2143 * to identity, because new space has just been opened.
2144 * But if skbs are fragmented we must check that this index
2145 * update releases enough of space, otherwise we just
2146 * wait for device to make more work.
2148 if (!tx_ring_full(ap, txcsm, ap->tx_prd))
2149 ace_tx_int(dev, txcsm, idx);
2152 evtcsm = readl(®s->EvtCsm);
2153 evtprd = *ap->evt_prd;
2155 if (evtcsm != evtprd) {
2156 evtcsm = ace_handle_event(dev, evtcsm, evtprd);
2157 writel(evtcsm, ®s->EvtCsm);
2161 * This has to go last in the interrupt handler and run with
2162 * the spin lock released ... what lock?
2164 if (netif_running(dev)) {
2166 int run_tasklet = 0;
2168 cur_size = atomic_read(&ap->cur_rx_bufs);
2169 if (cur_size < RX_LOW_STD_THRES) {
2170 if ((cur_size < RX_PANIC_STD_THRES) &&
2171 !test_and_set_bit(0, &ap->std_refill_busy)) {
2173 printk("low on std buffers %i\n", cur_size);
2175 ace_load_std_rx_ring(dev,
2176 RX_RING_SIZE - cur_size);
2181 if (!ACE_IS_TIGON_I(ap)) {
2182 cur_size = atomic_read(&ap->cur_mini_bufs);
2183 if (cur_size < RX_LOW_MINI_THRES) {
2184 if ((cur_size < RX_PANIC_MINI_THRES) &&
2185 !test_and_set_bit(0,
2186 &ap->mini_refill_busy)) {
2188 printk("low on mini buffers %i\n",
2191 ace_load_mini_rx_ring(dev,
2192 RX_MINI_SIZE - cur_size);
2199 cur_size = atomic_read(&ap->cur_jumbo_bufs);
2200 if (cur_size < RX_LOW_JUMBO_THRES) {
2201 if ((cur_size < RX_PANIC_JUMBO_THRES) &&
2202 !test_and_set_bit(0,
2203 &ap->jumbo_refill_busy)){
2205 printk("low on jumbo buffers %i\n",
2208 ace_load_jumbo_rx_ring(dev,
2209 RX_JUMBO_SIZE - cur_size);
2214 if (run_tasklet && !ap->tasklet_pending) {
2215 ap->tasklet_pending = 1;
2216 tasklet_schedule(&ap->ace_tasklet);
2223 static int ace_open(struct net_device *dev)
2225 struct ace_private *ap = netdev_priv(dev);
2226 struct ace_regs __iomem *regs = ap->regs;
2229 if (!(ap->fw_running)) {
2230 printk(KERN_WARNING "%s: Firmware not running!\n", dev->name);
2234 writel(dev->mtu + ETH_HLEN + 4, ®s->IfMtu);
2236 cmd.evt = C_CLEAR_STATS;
2239 ace_issue_cmd(regs, &cmd);
2241 cmd.evt = C_HOST_STATE;
2242 cmd.code = C_C_STACK_UP;
2244 ace_issue_cmd(regs, &cmd);
2247 !test_and_set_bit(0, &ap->jumbo_refill_busy))
2248 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2250 if (dev->flags & IFF_PROMISC) {
2251 cmd.evt = C_SET_PROMISC_MODE;
2252 cmd.code = C_C_PROMISC_ENABLE;
2254 ace_issue_cmd(regs, &cmd);
2262 cmd.evt = C_LNK_NEGOTIATION;
2265 ace_issue_cmd(regs, &cmd);
2268 netif_start_queue(dev);
2271 * Setup the bottom half rx ring refill handler
2273 tasklet_setup(&ap->ace_tasklet, ace_tasklet);
2278 static int ace_close(struct net_device *dev)
2280 struct ace_private *ap = netdev_priv(dev);
2281 struct ace_regs __iomem *regs = ap->regs;
2283 unsigned long flags;
2287 * Without (or before) releasing irq and stopping hardware, this
2288 * is an absolute non-sense, by the way. It will be reset instantly
2291 netif_stop_queue(dev);
2295 cmd.evt = C_SET_PROMISC_MODE;
2296 cmd.code = C_C_PROMISC_DISABLE;
2298 ace_issue_cmd(regs, &cmd);
2302 cmd.evt = C_HOST_STATE;
2303 cmd.code = C_C_STACK_DOWN;
2305 ace_issue_cmd(regs, &cmd);
2307 tasklet_kill(&ap->ace_tasklet);
2310 * Make sure one CPU is not processing packets while
2311 * buffers are being released by another.
2314 local_irq_save(flags);
2317 for (i = 0; i < ACE_TX_RING_ENTRIES(ap); i++) {
2318 struct sk_buff *skb;
2319 struct tx_ring_info *info;
2321 info = ap->skb->tx_skbuff + i;
2324 if (dma_unmap_len(info, maplen)) {
2325 if (ACE_IS_TIGON_I(ap)) {
2326 /* NB: TIGON_1 is special, tx_ring is in io space */
2327 struct tx_desc __iomem *tx;
2328 tx = (__force struct tx_desc __iomem *) &ap->tx_ring[i];
2329 writel(0, &tx->addr.addrhi);
2330 writel(0, &tx->addr.addrlo);
2331 writel(0, &tx->flagsize);
2333 memset(ap->tx_ring + i, 0,
2334 sizeof(struct tx_desc));
2335 dma_unmap_page(&ap->pdev->dev,
2336 dma_unmap_addr(info, mapping),
2337 dma_unmap_len(info, maplen),
2339 dma_unmap_len_set(info, maplen, 0);
2348 cmd.evt = C_RESET_JUMBO_RNG;
2351 ace_issue_cmd(regs, &cmd);
2354 ace_unmask_irq(dev);
2355 local_irq_restore(flags);
2361 static inline dma_addr_t
2362 ace_map_tx_skb(struct ace_private *ap, struct sk_buff *skb,
2363 struct sk_buff *tail, u32 idx)
2366 struct tx_ring_info *info;
2368 mapping = dma_map_page(&ap->pdev->dev, virt_to_page(skb->data),
2369 offset_in_page(skb->data), skb->len,
2372 info = ap->skb->tx_skbuff + idx;
2374 dma_unmap_addr_set(info, mapping, mapping);
2375 dma_unmap_len_set(info, maplen, skb->len);
2381 ace_load_tx_bd(struct ace_private *ap, struct tx_desc *desc, u64 addr,
2382 u32 flagsize, u32 vlan_tag)
2384 #if !USE_TX_COAL_NOW
2385 flagsize &= ~BD_FLG_COAL_NOW;
2388 if (ACE_IS_TIGON_I(ap)) {
2389 struct tx_desc __iomem *io = (__force struct tx_desc __iomem *) desc;
2390 writel(addr >> 32, &io->addr.addrhi);
2391 writel(addr & 0xffffffff, &io->addr.addrlo);
2392 writel(flagsize, &io->flagsize);
2393 writel(vlan_tag, &io->vlanres);
2395 desc->addr.addrhi = addr >> 32;
2396 desc->addr.addrlo = addr;
2397 desc->flagsize = flagsize;
2398 desc->vlanres = vlan_tag;
2403 static netdev_tx_t ace_start_xmit(struct sk_buff *skb,
2404 struct net_device *dev)
2406 struct ace_private *ap = netdev_priv(dev);
2407 struct ace_regs __iomem *regs = ap->regs;
2408 struct tx_desc *desc;
2410 unsigned long maxjiff = jiffies + 3*HZ;
2415 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2418 if (!skb_shinfo(skb)->nr_frags) {
2422 mapping = ace_map_tx_skb(ap, skb, skb, idx);
2423 flagsize = (skb->len << 16) | (BD_FLG_END);
2424 if (skb->ip_summed == CHECKSUM_PARTIAL)
2425 flagsize |= BD_FLG_TCP_UDP_SUM;
2426 if (skb_vlan_tag_present(skb)) {
2427 flagsize |= BD_FLG_VLAN_TAG;
2428 vlan_tag = skb_vlan_tag_get(skb);
2430 desc = ap->tx_ring + idx;
2431 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2433 /* Look at ace_tx_int for explanations. */
2434 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2435 flagsize |= BD_FLG_COAL_NOW;
2437 ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2443 mapping = ace_map_tx_skb(ap, skb, NULL, idx);
2444 flagsize = (skb_headlen(skb) << 16);
2445 if (skb->ip_summed == CHECKSUM_PARTIAL)
2446 flagsize |= BD_FLG_TCP_UDP_SUM;
2447 if (skb_vlan_tag_present(skb)) {
2448 flagsize |= BD_FLG_VLAN_TAG;
2449 vlan_tag = skb_vlan_tag_get(skb);
2452 ace_load_tx_bd(ap, ap->tx_ring + idx, mapping, flagsize, vlan_tag);
2454 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2456 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2457 const skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2458 struct tx_ring_info *info;
2460 len += skb_frag_size(frag);
2461 info = ap->skb->tx_skbuff + idx;
2462 desc = ap->tx_ring + idx;
2464 mapping = skb_frag_dma_map(&ap->pdev->dev, frag, 0,
2465 skb_frag_size(frag),
2468 flagsize = skb_frag_size(frag) << 16;
2469 if (skb->ip_summed == CHECKSUM_PARTIAL)
2470 flagsize |= BD_FLG_TCP_UDP_SUM;
2471 idx = (idx + 1) % ACE_TX_RING_ENTRIES(ap);
2473 if (i == skb_shinfo(skb)->nr_frags - 1) {
2474 flagsize |= BD_FLG_END;
2475 if (tx_ring_full(ap, ap->tx_ret_csm, idx))
2476 flagsize |= BD_FLG_COAL_NOW;
2479 * Only the last fragment frees
2486 dma_unmap_addr_set(info, mapping, mapping);
2487 dma_unmap_len_set(info, maplen, skb_frag_size(frag));
2488 ace_load_tx_bd(ap, desc, mapping, flagsize, vlan_tag);
2494 ace_set_txprd(regs, ap, idx);
2496 if (flagsize & BD_FLG_COAL_NOW) {
2497 netif_stop_queue(dev);
2500 * A TX-descriptor producer (an IRQ) might have gotten
2501 * between, making the ring free again. Since xmit is
2502 * serialized, this is the only situation we have to
2505 if (!tx_ring_full(ap, ap->tx_ret_csm, idx))
2506 netif_wake_queue(dev);
2509 return NETDEV_TX_OK;
2513 * This race condition is unavoidable with lock-free drivers.
2514 * We wake up the queue _before_ tx_prd is advanced, so that we can
2515 * enter hard_start_xmit too early, while tx ring still looks closed.
2516 * This happens ~1-4 times per 100000 packets, so that we can allow
2517 * to loop syncing to other CPU. Probably, we need an additional
2518 * wmb() in ace_tx_intr as well.
2520 * Note that this race is relieved by reserving one more entry
2521 * in tx ring than it is necessary (see original non-SG driver).
2522 * However, with SG we need to reserve 2*MAX_SKB_FRAGS+1, which
2523 * is already overkill.
2525 * Alternative is to return with 1 not throttling queue. In this
2526 * case loop becomes longer, no more useful effects.
2528 if (time_before(jiffies, maxjiff)) {
2534 /* The ring is stuck full. */
2535 printk(KERN_WARNING "%s: Transmit ring stuck full\n", dev->name);
2536 return NETDEV_TX_BUSY;
2540 static int ace_change_mtu(struct net_device *dev, int new_mtu)
2542 struct ace_private *ap = netdev_priv(dev);
2543 struct ace_regs __iomem *regs = ap->regs;
2545 writel(new_mtu + ETH_HLEN + 4, ®s->IfMtu);
2548 if (new_mtu > ACE_STD_MTU) {
2550 printk(KERN_INFO "%s: Enabling Jumbo frame "
2551 "support\n", dev->name);
2553 if (!test_and_set_bit(0, &ap->jumbo_refill_busy))
2554 ace_load_jumbo_rx_ring(dev, RX_JUMBO_SIZE);
2555 ace_set_rxtx_parms(dev, 1);
2558 while (test_and_set_bit(0, &ap->jumbo_refill_busy));
2559 ace_sync_irq(dev->irq);
2560 ace_set_rxtx_parms(dev, 0);
2564 cmd.evt = C_RESET_JUMBO_RNG;
2567 ace_issue_cmd(regs, &cmd);
2574 static int ace_get_link_ksettings(struct net_device *dev,
2575 struct ethtool_link_ksettings *cmd)
2577 struct ace_private *ap = netdev_priv(dev);
2578 struct ace_regs __iomem *regs = ap->regs;
2582 memset(cmd, 0, sizeof(struct ethtool_link_ksettings));
2584 supported = (SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full |
2585 SUPPORTED_100baseT_Half | SUPPORTED_100baseT_Full |
2586 SUPPORTED_1000baseT_Half | SUPPORTED_1000baseT_Full |
2587 SUPPORTED_Autoneg | SUPPORTED_FIBRE);
2589 cmd->base.port = PORT_FIBRE;
2591 link = readl(®s->GigLnkState);
2592 if (link & LNK_1000MB) {
2593 cmd->base.speed = SPEED_1000;
2595 link = readl(®s->FastLnkState);
2596 if (link & LNK_100MB)
2597 cmd->base.speed = SPEED_100;
2598 else if (link & LNK_10MB)
2599 cmd->base.speed = SPEED_10;
2601 cmd->base.speed = 0;
2603 if (link & LNK_FULL_DUPLEX)
2604 cmd->base.duplex = DUPLEX_FULL;
2606 cmd->base.duplex = DUPLEX_HALF;
2608 if (link & LNK_NEGOTIATE)
2609 cmd->base.autoneg = AUTONEG_ENABLE;
2611 cmd->base.autoneg = AUTONEG_DISABLE;
2615 * Current struct ethtool_cmd is insufficient
2617 ecmd->trace = readl(®s->TuneTrace);
2619 ecmd->txcoal = readl(®s->TuneTxCoalTicks);
2620 ecmd->rxcoal = readl(®s->TuneRxCoalTicks);
2623 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
2629 static int ace_set_link_ksettings(struct net_device *dev,
2630 const struct ethtool_link_ksettings *cmd)
2632 struct ace_private *ap = netdev_priv(dev);
2633 struct ace_regs __iomem *regs = ap->regs;
2636 link = readl(®s->GigLnkState);
2637 if (link & LNK_1000MB)
2640 link = readl(®s->FastLnkState);
2641 if (link & LNK_100MB)
2643 else if (link & LNK_10MB)
2649 link = LNK_ENABLE | LNK_1000MB | LNK_100MB | LNK_10MB |
2650 LNK_RX_FLOW_CTL_Y | LNK_NEG_FCTL;
2651 if (!ACE_IS_TIGON_I(ap))
2652 link |= LNK_TX_FLOW_CTL_Y;
2653 if (cmd->base.autoneg == AUTONEG_ENABLE)
2654 link |= LNK_NEGOTIATE;
2655 if (cmd->base.speed != speed) {
2656 link &= ~(LNK_1000MB | LNK_100MB | LNK_10MB);
2657 switch (cmd->base.speed) {
2670 if (cmd->base.duplex == DUPLEX_FULL)
2671 link |= LNK_FULL_DUPLEX;
2673 if (link != ap->link) {
2675 printk(KERN_INFO "%s: Renegotiating link state\n",
2679 writel(link, ®s->TuneLink);
2680 if (!ACE_IS_TIGON_I(ap))
2681 writel(link, ®s->TuneFastLink);
2684 cmd.evt = C_LNK_NEGOTIATION;
2687 ace_issue_cmd(regs, &cmd);
2692 static void ace_get_drvinfo(struct net_device *dev,
2693 struct ethtool_drvinfo *info)
2695 struct ace_private *ap = netdev_priv(dev);
2697 strlcpy(info->driver, "acenic", sizeof(info->driver));
2698 snprintf(info->fw_version, sizeof(info->version), "%i.%i.%i",
2699 ap->firmware_major, ap->firmware_minor, ap->firmware_fix);
2702 strlcpy(info->bus_info, pci_name(ap->pdev),
2703 sizeof(info->bus_info));
2708 * Set the hardware MAC address.
2710 static int ace_set_mac_addr(struct net_device *dev, void *p)
2712 struct ace_private *ap = netdev_priv(dev);
2713 struct ace_regs __iomem *regs = ap->regs;
2714 struct sockaddr *addr=p;
2718 if(netif_running(dev))
2721 memcpy(dev->dev_addr, addr->sa_data,dev->addr_len);
2723 da = (u8 *)dev->dev_addr;
2725 writel(da[0] << 8 | da[1], ®s->MacAddrHi);
2726 writel((da[2] << 24) | (da[3] << 16) | (da[4] << 8) | da[5],
2729 cmd.evt = C_SET_MAC_ADDR;
2732 ace_issue_cmd(regs, &cmd);
2738 static void ace_set_multicast_list(struct net_device *dev)
2740 struct ace_private *ap = netdev_priv(dev);
2741 struct ace_regs __iomem *regs = ap->regs;
2744 if ((dev->flags & IFF_ALLMULTI) && !(ap->mcast_all)) {
2745 cmd.evt = C_SET_MULTICAST_MODE;
2746 cmd.code = C_C_MCAST_ENABLE;
2748 ace_issue_cmd(regs, &cmd);
2750 } else if (ap->mcast_all) {
2751 cmd.evt = C_SET_MULTICAST_MODE;
2752 cmd.code = C_C_MCAST_DISABLE;
2754 ace_issue_cmd(regs, &cmd);
2758 if ((dev->flags & IFF_PROMISC) && !(ap->promisc)) {
2759 cmd.evt = C_SET_PROMISC_MODE;
2760 cmd.code = C_C_PROMISC_ENABLE;
2762 ace_issue_cmd(regs, &cmd);
2764 }else if (!(dev->flags & IFF_PROMISC) && (ap->promisc)) {
2765 cmd.evt = C_SET_PROMISC_MODE;
2766 cmd.code = C_C_PROMISC_DISABLE;
2768 ace_issue_cmd(regs, &cmd);
2773 * For the time being multicast relies on the upper layers
2774 * filtering it properly. The Firmware does not allow one to
2775 * set the entire multicast list at a time and keeping track of
2776 * it here is going to be messy.
2778 if (!netdev_mc_empty(dev) && !ap->mcast_all) {
2779 cmd.evt = C_SET_MULTICAST_MODE;
2780 cmd.code = C_C_MCAST_ENABLE;
2782 ace_issue_cmd(regs, &cmd);
2783 }else if (!ap->mcast_all) {
2784 cmd.evt = C_SET_MULTICAST_MODE;
2785 cmd.code = C_C_MCAST_DISABLE;
2787 ace_issue_cmd(regs, &cmd);
2792 static struct net_device_stats *ace_get_stats(struct net_device *dev)
2794 struct ace_private *ap = netdev_priv(dev);
2795 struct ace_mac_stats __iomem *mac_stats =
2796 (struct ace_mac_stats __iomem *)ap->regs->Stats;
2798 dev->stats.rx_missed_errors = readl(&mac_stats->drop_space);
2799 dev->stats.multicast = readl(&mac_stats->kept_mc);
2800 dev->stats.collisions = readl(&mac_stats->coll);
2806 static void ace_copy(struct ace_regs __iomem *regs, const __be32 *src,
2809 void __iomem *tdest;
2816 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2817 min_t(u32, size, ACE_WINDOW_SIZE));
2818 tdest = (void __iomem *) ®s->Window +
2819 (dest & (ACE_WINDOW_SIZE - 1));
2820 writel(dest & ~(ACE_WINDOW_SIZE - 1), ®s->WinBase);
2821 for (i = 0; i < (tsize / 4); i++) {
2822 /* Firmware is big-endian */
2823 writel(be32_to_cpup(src), tdest);
2833 static void ace_clear(struct ace_regs __iomem *regs, u32 dest, int size)
2835 void __iomem *tdest;
2842 tsize = min_t(u32, ((~dest & (ACE_WINDOW_SIZE - 1)) + 1),
2843 min_t(u32, size, ACE_WINDOW_SIZE));
2844 tdest = (void __iomem *) ®s->Window +
2845 (dest & (ACE_WINDOW_SIZE - 1));
2846 writel(dest & ~(ACE_WINDOW_SIZE - 1), ®s->WinBase);
2848 for (i = 0; i < (tsize / 4); i++) {
2849 writel(0, tdest + i*4);
2859 * Download the firmware into the SRAM on the NIC
2861 * This operation requires the NIC to be halted and is performed with
2862 * interrupts disabled and with the spinlock hold.
2864 static int ace_load_firmware(struct net_device *dev)
2866 const struct firmware *fw;
2867 const char *fw_name = "/*(DEBLOBBED)*/";
2868 struct ace_private *ap = netdev_priv(dev);
2869 struct ace_regs __iomem *regs = ap->regs;
2870 const __be32 *fw_data;
2874 if (!(readl(®s->CpuCtrl) & CPU_HALTED)) {
2875 printk(KERN_ERR "%s: trying to download firmware while the "
2876 "CPU is running!\n", ap->name);
2880 if (ACE_IS_TIGON_I(ap))
2881 fw_name = "/*(DEBLOBBED)*/";
2883 ret = reject_firmware(&fw, fw_name, &ap->pdev->dev);
2885 printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
2890 fw_data = (void *)fw->data;
2892 /* Firmware blob starts with version numbers, followed by
2893 load and start address. Remainder is the blob to be loaded
2894 contiguously from load address. We don't bother to represent
2895 the BSS/SBSS sections any more, since we were clearing the
2896 whole thing anyway. */
2897 ap->firmware_major = fw->data[0];
2898 ap->firmware_minor = fw->data[1];
2899 ap->firmware_fix = fw->data[2];
2901 ap->firmware_start = be32_to_cpu(fw_data[1]);
2902 if (ap->firmware_start < 0x4000 || ap->firmware_start >= 0x80000) {
2903 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2904 ap->name, ap->firmware_start, fw_name);
2909 load_addr = be32_to_cpu(fw_data[2]);
2910 if (load_addr < 0x4000 || load_addr >= 0x80000) {
2911 printk(KERN_ERR "%s: bogus load address %08x in \"%s\"\n",
2912 ap->name, load_addr, fw_name);
2918 * Do not try to clear more than 512KiB or we end up seeing
2919 * funny things on NICs with only 512KiB SRAM
2921 ace_clear(regs, 0x2000, 0x80000-0x2000);
2922 ace_copy(regs, &fw_data[3], load_addr, fw->size-12);
2924 release_firmware(fw);
2930 * The eeprom on the AceNIC is an Atmel i2c EEPROM.
2932 * Accessing the EEPROM is `interesting' to say the least - don't read
2933 * this code right after dinner.
2935 * This is all about black magic and bit-banging the device .... I
2936 * wonder in what hospital they have put the guy who designed the i2c
2939 * Oh yes, this is only the beginning!
2941 * Thanks to Stevarino Webinski for helping tracking down the bugs in the
2942 * code i2c readout code by beta testing all my hacks.
2944 static void eeprom_start(struct ace_regs __iomem *regs)
2948 readl(®s->LocalCtrl);
2949 udelay(ACE_SHORT_DELAY);
2950 local = readl(®s->LocalCtrl);
2951 local |= EEPROM_DATA_OUT | EEPROM_WRITE_ENABLE;
2952 writel(local, ®s->LocalCtrl);
2953 readl(®s->LocalCtrl);
2955 udelay(ACE_SHORT_DELAY);
2956 local |= EEPROM_CLK_OUT;
2957 writel(local, ®s->LocalCtrl);
2958 readl(®s->LocalCtrl);
2960 udelay(ACE_SHORT_DELAY);
2961 local &= ~EEPROM_DATA_OUT;
2962 writel(local, ®s->LocalCtrl);
2963 readl(®s->LocalCtrl);
2965 udelay(ACE_SHORT_DELAY);
2966 local &= ~EEPROM_CLK_OUT;
2967 writel(local, ®s->LocalCtrl);
2968 readl(®s->LocalCtrl);
2973 static void eeprom_prep(struct ace_regs __iomem *regs, u8 magic)
2978 udelay(ACE_SHORT_DELAY);
2979 local = readl(®s->LocalCtrl);
2980 local &= ~EEPROM_DATA_OUT;
2981 local |= EEPROM_WRITE_ENABLE;
2982 writel(local, ®s->LocalCtrl);
2983 readl(®s->LocalCtrl);
2986 for (i = 0; i < 8; i++, magic <<= 1) {
2987 udelay(ACE_SHORT_DELAY);
2989 local |= EEPROM_DATA_OUT;
2991 local &= ~EEPROM_DATA_OUT;
2992 writel(local, ®s->LocalCtrl);
2993 readl(®s->LocalCtrl);
2996 udelay(ACE_SHORT_DELAY);
2997 local |= EEPROM_CLK_OUT;
2998 writel(local, ®s->LocalCtrl);
2999 readl(®s->LocalCtrl);
3001 udelay(ACE_SHORT_DELAY);
3002 local &= ~(EEPROM_CLK_OUT | EEPROM_DATA_OUT);
3003 writel(local, ®s->LocalCtrl);
3004 readl(®s->LocalCtrl);
3010 static int eeprom_check_ack(struct ace_regs __iomem *regs)
3015 local = readl(®s->LocalCtrl);
3016 local &= ~EEPROM_WRITE_ENABLE;
3017 writel(local, ®s->LocalCtrl);
3018 readl(®s->LocalCtrl);
3020 udelay(ACE_LONG_DELAY);
3021 local |= EEPROM_CLK_OUT;
3022 writel(local, ®s->LocalCtrl);
3023 readl(®s->LocalCtrl);
3025 udelay(ACE_SHORT_DELAY);
3026 /* sample data in middle of high clk */
3027 state = (readl(®s->LocalCtrl) & EEPROM_DATA_IN) != 0;
3028 udelay(ACE_SHORT_DELAY);
3030 writel(readl(®s->LocalCtrl) & ~EEPROM_CLK_OUT, ®s->LocalCtrl);
3031 readl(®s->LocalCtrl);
3038 static void eeprom_stop(struct ace_regs __iomem *regs)
3042 udelay(ACE_SHORT_DELAY);
3043 local = readl(®s->LocalCtrl);
3044 local |= EEPROM_WRITE_ENABLE;
3045 writel(local, ®s->LocalCtrl);
3046 readl(®s->LocalCtrl);
3048 udelay(ACE_SHORT_DELAY);
3049 local &= ~EEPROM_DATA_OUT;
3050 writel(local, ®s->LocalCtrl);
3051 readl(®s->LocalCtrl);
3053 udelay(ACE_SHORT_DELAY);
3054 local |= EEPROM_CLK_OUT;
3055 writel(local, ®s->LocalCtrl);
3056 readl(®s->LocalCtrl);
3058 udelay(ACE_SHORT_DELAY);
3059 local |= EEPROM_DATA_OUT;
3060 writel(local, ®s->LocalCtrl);
3061 readl(®s->LocalCtrl);
3063 udelay(ACE_LONG_DELAY);
3064 local &= ~EEPROM_CLK_OUT;
3065 writel(local, ®s->LocalCtrl);
3071 * Read a whole byte from the EEPROM.
3073 static int read_eeprom_byte(struct net_device *dev, unsigned long offset)
3075 struct ace_private *ap = netdev_priv(dev);
3076 struct ace_regs __iomem *regs = ap->regs;
3077 unsigned long flags;
3083 * Don't take interrupts on this CPU will bit banging
3084 * the %#%#@$ I2C device
3086 local_irq_save(flags);
3090 eeprom_prep(regs, EEPROM_WRITE_SELECT);
3091 if (eeprom_check_ack(regs)) {
3092 local_irq_restore(flags);
3093 printk(KERN_ERR "%s: Unable to sync eeprom\n", ap->name);
3095 goto eeprom_read_error;
3098 eeprom_prep(regs, (offset >> 8) & 0xff);
3099 if (eeprom_check_ack(regs)) {
3100 local_irq_restore(flags);
3101 printk(KERN_ERR "%s: Unable to set address byte 0\n",
3104 goto eeprom_read_error;
3107 eeprom_prep(regs, offset & 0xff);
3108 if (eeprom_check_ack(regs)) {
3109 local_irq_restore(flags);
3110 printk(KERN_ERR "%s: Unable to set address byte 1\n",
3113 goto eeprom_read_error;
3117 eeprom_prep(regs, EEPROM_READ_SELECT);
3118 if (eeprom_check_ack(regs)) {
3119 local_irq_restore(flags);
3120 printk(KERN_ERR "%s: Unable to set READ_SELECT\n",
3123 goto eeprom_read_error;
3126 for (i = 0; i < 8; i++) {
3127 local = readl(®s->LocalCtrl);
3128 local &= ~EEPROM_WRITE_ENABLE;
3129 writel(local, ®s->LocalCtrl);
3130 readl(®s->LocalCtrl);
3131 udelay(ACE_LONG_DELAY);
3133 local |= EEPROM_CLK_OUT;
3134 writel(local, ®s->LocalCtrl);
3135 readl(®s->LocalCtrl);
3137 udelay(ACE_SHORT_DELAY);
3138 /* sample data mid high clk */
3139 result = (result << 1) |
3140 ((readl(®s->LocalCtrl) & EEPROM_DATA_IN) != 0);
3141 udelay(ACE_SHORT_DELAY);
3143 local = readl(®s->LocalCtrl);
3144 local &= ~EEPROM_CLK_OUT;
3145 writel(local, ®s->LocalCtrl);
3146 readl(®s->LocalCtrl);
3147 udelay(ACE_SHORT_DELAY);
3150 local |= EEPROM_WRITE_ENABLE;
3151 writel(local, ®s->LocalCtrl);
3152 readl(®s->LocalCtrl);
3154 udelay(ACE_SHORT_DELAY);
3158 local |= EEPROM_DATA_OUT;
3159 writel(local, ®s->LocalCtrl);
3160 readl(®s->LocalCtrl);
3162 udelay(ACE_SHORT_DELAY);
3163 writel(readl(®s->LocalCtrl) | EEPROM_CLK_OUT, ®s->LocalCtrl);
3164 readl(®s->LocalCtrl);
3165 udelay(ACE_LONG_DELAY);
3166 writel(readl(®s->LocalCtrl) & ~EEPROM_CLK_OUT, ®s->LocalCtrl);
3167 readl(®s->LocalCtrl);
3169 udelay(ACE_SHORT_DELAY);
3172 local_irq_restore(flags);
3177 printk(KERN_ERR "%s: Unable to read eeprom byte 0x%02lx\n",
3182 module_pci_driver(acenic_pci_driver);