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