blob: 443f1da9fc9e26948a7f48ac7e504a9bfa29086b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* epic100.c: A SMC 83c170 EPIC/100 Fast Ethernet driver for Linux. */
2/*
3 Written/copyright 1997-2001 by Donald Becker.
4
5 This software may be used and distributed according to the terms of
6 the GNU General Public License (GPL), incorporated herein by reference.
7 Drivers based on or derived from this code fall under the GPL and must
8 retain the authorship, copyright and license notice. This file is not
9 a complete program and may only be used when the entire operating
10 system is licensed under the GPL.
11
12 This driver is for the SMC83c170/175 "EPIC" series, as used on the
13 SMC EtherPower II 9432 PCI adapter, and several CardBus cards.
14
15 The author may be reached as becker@scyld.com, or C/O
16 Scyld Computing Corporation
17 410 Severn Ave., Suite 210
18 Annapolis MD 21403
19
20 Information and updates available at
21 http://www.scyld.com/network/epic100.html
Jeff Garzik36e1e842006-06-27 07:38:33 -040022 [this link no longer provides anything useful -jgarzik]
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24 ---------------------------------------------------------------------
Jeff Garzikf3b197a2006-05-26 21:39:03 -040025
Linus Torvalds1da177e2005-04-16 15:20:36 -070026*/
27
28#define DRV_NAME "epic100"
Andy Gospodarekd5b20692006-09-11 17:39:18 -040029#define DRV_VERSION "2.1"
30#define DRV_RELDATE "Sept 11, 2006"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32/* The user-configurable values.
33 These may be modified when a driver module is loaded.*/
34
35static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
36
37/* Used to pass the full-duplex flag, etc. */
38#define MAX_UNITS 8 /* More are supported, limit only on options */
39static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
40static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
41
42/* Set the copy breakpoint for the copy-only-tiny-frames scheme.
43 Setting to > 1518 effectively disables this feature. */
44static int rx_copybreak;
45
46/* Operational parameters that are set at compile time. */
47
48/* Keep the ring sizes a power of two for operational efficiency.
49 The compiler will convert <unsigned>'%'<2^N> into a bit mask.
50 Making the Tx ring too large decreases the effectiveness of channel
51 bonding and packet priority.
52 There are no ill effects from too-large receive rings. */
53#define TX_RING_SIZE 256
54#define TX_QUEUE_LEN 240 /* Limit ring entries actually used. */
55#define RX_RING_SIZE 256
56#define TX_TOTAL_SIZE TX_RING_SIZE*sizeof(struct epic_tx_desc)
57#define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct epic_rx_desc)
58
59/* Operational parameters that usually are not changed. */
60/* Time in jiffies before concluding the transmitter is hung. */
61#define TX_TIMEOUT (2*HZ)
62
63#define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
64
65/* Bytes transferred to chip before transmission starts. */
66/* Initial threshold, increased on underflow, rounded down to 4 byte units. */
67#define TX_FIFO_THRESH 256
68#define RX_FIFO_THRESH 1 /* 0-3, 0==32, 64,96, or 3==128 bytes */
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#include <linux/module.h>
71#include <linux/kernel.h>
72#include <linux/string.h>
73#include <linux/timer.h>
74#include <linux/errno.h>
75#include <linux/ioport.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070076#include <linux/interrupt.h>
77#include <linux/pci.h>
78#include <linux/delay.h>
79#include <linux/netdevice.h>
80#include <linux/etherdevice.h>
81#include <linux/skbuff.h>
82#include <linux/init.h>
83#include <linux/spinlock.h>
84#include <linux/ethtool.h>
85#include <linux/mii.h>
86#include <linux/crc32.h>
87#include <linux/bitops.h>
88#include <asm/io.h>
89#include <asm/uaccess.h>
Roland Dreier9e2d11b2010-06-02 10:36:53 +000090#include <asm/byteorder.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92/* These identify the driver base version and may not be removed. */
Bill Pembertonb0171cd2012-12-03 09:23:42 -050093static char version[] =
Ben Boeckel3ee307d2013-11-01 08:53:30 -040094DRV_NAME ".c:v1.11 1/7/2001 Written by Donald Becker <becker@scyld.com>";
Bill Pembertonb0171cd2012-12-03 09:23:42 -050095static char version2[] =
Ben Boeckel3ee307d2013-11-01 08:53:30 -040096" (unofficial 2.4.x kernel port, version " DRV_VERSION ", " DRV_RELDATE ")";
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
99MODULE_DESCRIPTION("SMC 83c170 EPIC series Ethernet driver");
100MODULE_LICENSE("GPL");
101
102module_param(debug, int, 0);
103module_param(rx_copybreak, int, 0);
104module_param_array(options, int, NULL, 0);
105module_param_array(full_duplex, int, NULL, 0);
106MODULE_PARM_DESC(debug, "EPIC/100 debug level (0-5)");
107MODULE_PARM_DESC(options, "EPIC/100: Bits 0-3: media type, bit 4: full duplex");
108MODULE_PARM_DESC(rx_copybreak, "EPIC/100 copy breakpoint for copy-only-tiny-frames");
109MODULE_PARM_DESC(full_duplex, "EPIC/100 full duplex setting(s) (1)");
110
111/*
112 Theory of Operation
113
114I. Board Compatibility
115
116This device driver is designed for the SMC "EPIC/100", the SMC
117single-chip Ethernet controllers for PCI. This chip is used on
118the SMC EtherPower II boards.
119
120II. Board-specific settings
121
122PCI bus devices are configured by the system at boot time, so no jumpers
123need to be set on the board. The system BIOS will assign the
124PCI INTA signal to a (preferably otherwise unused) system IRQ line.
125Note: Kernel versions earlier than 1.3.73 do not support shared PCI
126interrupt lines.
127
128III. Driver operation
129
130IIIa. Ring buffers
131
132IVb. References
133
Justin P. Mattock631dd1a2010-10-18 11:03:14 +0200134http://www.smsc.com/media/Downloads_Public/discontinued/83c171.pdf
135http://www.smsc.com/media/Downloads_Public/discontinued/83c175.pdf
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136http://scyld.com/expert/NWay.html
137http://www.national.com/pf/DP/DP83840A.html
138
139IVc. Errata
140
141*/
142
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144enum chip_capability_flags { MII_PWRDWN=1, TYPE2_INTR=2, NO_MII=4 };
145
146#define EPIC_TOTAL_SIZE 0x100
147#define USE_IO_OPS 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Francois Romieuaae9bc32012-03-13 12:04:26 +0100149#ifdef USE_IO_OPS
150#define EPIC_BAR 0
151#else
152#define EPIC_BAR 1
153#endif
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155typedef enum {
156 SMSC_83C170_0,
157 SMSC_83C170,
158 SMSC_83C175,
159} chip_t;
160
161
162struct epic_chip_info {
163 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 int drv_flags; /* Driver use, intended as capability flags. */
165};
166
167
168/* indexed by chip_t */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500169static const struct epic_chip_info pci_id_tbl[] = {
Jeff Garzik36e1e842006-06-27 07:38:33 -0400170 { "SMSC EPIC/100 83c170", TYPE2_INTR | NO_MII | MII_PWRDWN },
171 { "SMSC EPIC/100 83c170", TYPE2_INTR },
172 { "SMSC EPIC/C 83c175", TYPE2_INTR | MII_PWRDWN },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173};
174
175
Benoit Taine9baa3c32014-08-08 15:56:03 +0200176static const struct pci_device_id epic_pci_tbl[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 { 0x10B8, 0x0005, 0x1092, 0x0AB4, 0, 0, SMSC_83C170_0 },
178 { 0x10B8, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMSC_83C170 },
179 { 0x10B8, 0x0006, PCI_ANY_ID, PCI_ANY_ID,
180 PCI_CLASS_NETWORK_ETHERNET << 8, 0xffff00, SMSC_83C175 },
181 { 0,}
182};
183MODULE_DEVICE_TABLE (pci, epic_pci_tbl);
184
Francois Romieuaae9bc32012-03-13 12:04:26 +0100185#define ew16(reg, val) iowrite16(val, ioaddr + (reg))
186#define ew32(reg, val) iowrite32(val, ioaddr + (reg))
187#define er8(reg) ioread8(ioaddr + (reg))
188#define er16(reg) ioread16(ioaddr + (reg))
189#define er32(reg) ioread32(ioaddr + (reg))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191/* Offsets to registers, using the (ugh) SMC names. */
192enum epic_registers {
193 COMMAND=0, INTSTAT=4, INTMASK=8, GENCTL=0x0C, NVCTL=0x10, EECTL=0x14,
194 PCIBurstCnt=0x18,
195 TEST1=0x1C, CRCCNT=0x20, ALICNT=0x24, MPCNT=0x28, /* Rx error counters. */
196 MIICtrl=0x30, MIIData=0x34, MIICfg=0x38,
197 LAN0=64, /* MAC address. */
198 MC0=80, /* Multicast filter table. */
199 RxCtrl=96, TxCtrl=112, TxSTAT=0x74,
200 PRxCDAR=0x84, RxSTAT=0xA4, EarlyRx=0xB0, PTxCDAR=0xC4, TxThresh=0xDC,
201};
202
203/* Interrupt register bits, using my own meaningful names. */
204enum IntrStatus {
205 TxIdle=0x40000, RxIdle=0x20000, IntrSummary=0x010000,
206 PCIBusErr170=0x7000, PCIBusErr175=0x1000, PhyEvent175=0x8000,
207 RxStarted=0x0800, RxEarlyWarn=0x0400, CntFull=0x0200, TxUnderrun=0x0100,
208 TxEmpty=0x0080, TxDone=0x0020, RxError=0x0010,
209 RxOverflow=0x0008, RxFull=0x0004, RxHeader=0x0002, RxDone=0x0001,
210};
211enum CommandBits {
212 StopRx=1, StartRx=2, TxQueued=4, RxQueued=8,
213 StopTxDMA=0x20, StopRxDMA=0x40, RestartTx=0x80,
214};
215
216#define EpicRemoved 0xffffffff /* Chip failed or removed (CardBus) */
217
218#define EpicNapiEvent (TxEmpty | TxDone | \
219 RxDone | RxStarted | RxEarlyWarn | RxOverflow | RxFull)
220#define EpicNormalEvent (0x0000ffff & ~EpicNapiEvent)
221
Arjan van de Venf71e1302006-03-03 21:33:57 -0500222static const u16 media2miictl[16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 0, 0x0C00, 0x0C00, 0x2000, 0x0100, 0x2100, 0, 0,
224 0, 0, 0, 0, 0, 0, 0, 0 };
225
Al Viro9ebfd492008-03-16 22:22:04 +0000226/*
227 * The EPIC100 Rx and Tx buffer descriptors. Note that these
228 * really ARE host-endian; it's not a misannotation. We tell
229 * the card to byteswap them internally on big-endian hosts -
Roland Dreier9e2d11b2010-06-02 10:36:53 +0000230 * look for #ifdef __BIG_ENDIAN in epic_open().
Al Viro9ebfd492008-03-16 22:22:04 +0000231 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233struct epic_tx_desc {
234 u32 txstatus;
235 u32 bufaddr;
236 u32 buflength;
237 u32 next;
238};
239
240struct epic_rx_desc {
241 u32 rxstatus;
242 u32 bufaddr;
243 u32 buflength;
244 u32 next;
245};
246
247enum desc_status_bits {
248 DescOwn=0x8000,
249};
250
251#define PRIV_ALIGN 15 /* Required alignment mask */
252struct epic_private {
253 struct epic_rx_desc *rx_ring;
254 struct epic_tx_desc *tx_ring;
255 /* The saved address of a sent-in-place packet/buffer, for skfree(). */
256 struct sk_buff* tx_skbuff[TX_RING_SIZE];
257 /* The addresses of receive-in-place skbuffs. */
258 struct sk_buff* rx_skbuff[RX_RING_SIZE];
259
260 dma_addr_t tx_ring_dma;
261 dma_addr_t rx_ring_dma;
262
263 /* Ring pointers. */
264 spinlock_t lock; /* Group with Tx control cache line. */
265 spinlock_t napi_lock;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700266 struct napi_struct napi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 unsigned int reschedule_in_poll;
268 unsigned int cur_tx, dirty_tx;
269
270 unsigned int cur_rx, dirty_rx;
271 u32 irq_mask;
272 unsigned int rx_buf_sz; /* Based on MTU+slack. */
273
Francois Romieuaae9bc32012-03-13 12:04:26 +0100274 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 struct pci_dev *pci_dev; /* PCI bus location. */
276 int chip_id, chip_flags;
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 struct timer_list timer; /* Media selection timer. */
279 int tx_threshold;
280 unsigned char mc_filter[8];
281 signed char phys[4]; /* MII device addresses. */
282 u16 advertising; /* NWay media advertisement */
283 int mii_phy_cnt;
284 struct mii_if_info mii;
285 unsigned int tx_full:1; /* The Tx queue is full. */
286 unsigned int default_port:4; /* Last dev->if_port value. */
287};
288
289static int epic_open(struct net_device *dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100290static int read_eeprom(struct epic_private *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291static int mdio_read(struct net_device *dev, int phy_id, int location);
292static void mdio_write(struct net_device *dev, int phy_id, int loc, int val);
293static void epic_restart(struct net_device *dev);
294static void epic_timer(unsigned long data);
295static void epic_tx_timeout(struct net_device *dev);
296static void epic_init_ring(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000297static netdev_tx_t epic_start_xmit(struct sk_buff *skb,
298 struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299static int epic_rx(struct net_device *dev, int budget);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700300static int epic_poll(struct napi_struct *napi, int budget);
David Howells7d12e782006-10-05 14:55:46 +0100301static irqreturn_t epic_interrupt(int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Jeff Garzik7282d492006-09-13 14:30:00 -0400303static const struct ethtool_ops netdev_ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304static int epic_close(struct net_device *dev);
305static struct net_device_stats *epic_get_stats(struct net_device *dev);
306static void set_rx_mode(struct net_device *dev);
307
Stephen Hemminger805524c2009-01-07 17:27:39 -0800308static const struct net_device_ops epic_netdev_ops = {
309 .ndo_open = epic_open,
310 .ndo_stop = epic_close,
311 .ndo_start_xmit = epic_start_xmit,
312 .ndo_tx_timeout = epic_tx_timeout,
313 .ndo_get_stats = epic_get_stats,
Jiri Pirkoafc4b132011-08-16 06:29:01 +0000314 .ndo_set_rx_mode = set_rx_mode,
Stephen Hemminger805524c2009-01-07 17:27:39 -0800315 .ndo_do_ioctl = netdev_ioctl,
316 .ndo_change_mtu = eth_change_mtu,
317 .ndo_set_mac_address = eth_mac_addr,
318 .ndo_validate_addr = eth_validate_addr,
319};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320
Greg Kroah-Hartman1dd06ae2012-12-06 14:30:56 +0000321static int epic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
323 static int card_idx = -1;
Francois Romieuaae9bc32012-03-13 12:04:26 +0100324 void __iomem *ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 int chip_idx = (int) ent->driver_data;
326 int irq;
327 struct net_device *dev;
328 struct epic_private *ep;
329 int i, ret, option = 0, duplex = 0;
330 void *ring_space;
331 dma_addr_t ring_dma;
332
333/* when built into the kernel, we only print version if device is found */
334#ifndef MODULE
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400335 pr_info_once("%s%s\n", version, version2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336#endif
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 card_idx++;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 ret = pci_enable_device(pdev);
341 if (ret)
342 goto out;
343 irq = pdev->irq;
344
Jeff Garzik36e1e842006-06-27 07:38:33 -0400345 if (pci_resource_len(pdev, 0) < EPIC_TOTAL_SIZE) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400346 dev_err(&pdev->dev, "no PCI region space\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 ret = -ENODEV;
348 goto err_out_disable;
349 }
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 pci_set_master(pdev);
352
353 ret = pci_request_regions(pdev, DRV_NAME);
354 if (ret < 0)
355 goto err_out_disable;
356
357 ret = -ENOMEM;
358
359 dev = alloc_etherdev(sizeof (*ep));
Joe Perches41de8d42012-01-29 13:47:52 +0000360 if (!dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 goto err_out_free_res;
Joe Perches41de8d42012-01-29 13:47:52 +0000362
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 SET_NETDEV_DEV(dev, &pdev->dev);
364
Francois Romieuaae9bc32012-03-13 12:04:26 +0100365 ioaddr = pci_iomap(pdev, EPIC_BAR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 if (!ioaddr) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400367 dev_err(&pdev->dev, "ioremap failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 goto err_out_free_netdev;
369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371 pci_set_drvdata(pdev, dev);
Wang Chen4cf16532008-11-12 23:38:14 -0800372 ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100373 ep->ioaddr = ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 ep->mii.dev = dev;
375 ep->mii.mdio_read = mdio_read;
376 ep->mii.mdio_write = mdio_write;
377 ep->mii.phy_id_mask = 0x1f;
378 ep->mii.reg_num_mask = 0x1f;
379
380 ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
381 if (!ring_space)
382 goto err_out_iounmap;
Joe Perches43d620c2011-06-16 19:08:06 +0000383 ep->tx_ring = ring_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 ep->tx_ring_dma = ring_dma;
385
386 ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
387 if (!ring_space)
388 goto err_out_unmap_tx;
Joe Perches43d620c2011-06-16 19:08:06 +0000389 ep->rx_ring = ring_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 ep->rx_ring_dma = ring_dma;
391
392 if (dev->mem_start) {
393 option = dev->mem_start;
394 duplex = (dev->mem_start & 16) ? 1 : 0;
395 } else if (card_idx >= 0 && card_idx < MAX_UNITS) {
396 if (options[card_idx] >= 0)
397 option = options[card_idx];
398 if (full_duplex[card_idx] >= 0)
399 duplex = full_duplex[card_idx];
400 }
401
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 spin_lock_init(&ep->lock);
403 spin_lock_init(&ep->napi_lock);
404 ep->reschedule_in_poll = 0;
405
406 /* Bring the chip out of low-power mode. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100407 ew32(GENCTL, 0x4200);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 /* Magic?! If we don't set this bit the MII interface won't work. */
409 /* This magic is documented in SMSC app note 7.15 */
410 for (i = 16; i > 0; i--)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100411 ew32(TEST1, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 /* Turn on the MII transceiver. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100414 ew32(MIICfg, 0x12);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (chip_idx == 1)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100416 ew32(NVCTL, (er32(NVCTL) & ~0x003c) | 0x4800);
417 ew32(GENCTL, 0x0200);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 /* Note: the '175 does not have a serial EEPROM. */
420 for (i = 0; i < 3; i++)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100421 ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(er16(LAN0 + i*4));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
423 if (debug > 2) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400424 dev_dbg(&pdev->dev, "EEPROM contents:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 for (i = 0; i < 64; i++)
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400426 pr_cont(" %4.4x%s", read_eeprom(ep, i),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 i % 16 == 15 ? "\n" : "");
428 }
429
430 ep->pci_dev = pdev;
431 ep->chip_id = chip_idx;
432 ep->chip_flags = pci_id_tbl[chip_idx].drv_flags;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400433 ep->irq_mask =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 (ep->chip_flags & TYPE2_INTR ? PCIBusErr175 : PCIBusErr170)
435 | CntFull | TxUnderrun | EpicNapiEvent;
436
437 /* Find the connected MII xcvrs.
438 Doing this in open() would allow detecting external xcvrs later, but
439 takes much time and no cards have external MII. */
440 {
441 int phy, phy_idx = 0;
442 for (phy = 1; phy < 32 && phy_idx < sizeof(ep->phys); phy++) {
443 int mii_status = mdio_read(dev, phy, MII_BMSR);
444 if (mii_status != 0xffff && mii_status != 0x0000) {
445 ep->phys[phy_idx++] = phy;
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400446 dev_info(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400447 "MII transceiver #%d control "
448 "%4.4x status %4.4x.\n",
449 phy, mdio_read(dev, phy, 0), mii_status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 }
451 }
452 ep->mii_phy_cnt = phy_idx;
453 if (phy_idx != 0) {
454 phy = ep->phys[0];
455 ep->mii.advertising = mdio_read(dev, phy, MII_ADVERTISE);
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400456 dev_info(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400457 "Autonegotiation advertising %4.4x link "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 "partner %4.4x.\n",
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400459 ep->mii.advertising, mdio_read(dev, phy, 5));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 } else if ( ! (ep->chip_flags & NO_MII)) {
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400461 dev_warn(&pdev->dev,
Jeff Garzik2e8a5382006-06-27 10:47:51 -0400462 "***WARNING***: No MII transceiver found!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 /* Use the known PHY address of the EPII. */
464 ep->phys[0] = 3;
465 }
466 ep->mii.phy_id = ep->phys[0];
467 }
468
469 /* Turn off the MII xcvr (175 only!), leave the chip in low-power mode. */
470 if (ep->chip_flags & MII_PWRDWN)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100471 ew32(NVCTL, er32(NVCTL) & ~0x483c);
472 ew32(GENCTL, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474 /* The lower four bits are the media type. */
475 if (duplex) {
476 ep->mii.force_media = ep->mii.full_duplex = 1;
Jeff Garzik9b91cf92006-06-27 11:39:50 -0400477 dev_info(&pdev->dev, "Forced full duplex requested.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 }
479 dev->if_port = ep->default_port = option;
480
481 /* The Epic-specific entries in the device structure. */
Stephen Hemminger805524c2009-01-07 17:27:39 -0800482 dev->netdev_ops = &epic_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 dev->ethtool_ops = &netdev_ethtool_ops;
484 dev->watchdog_timeo = TX_TIMEOUT;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700485 netif_napi_add(dev, &ep->napi, epic_poll, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 ret = register_netdev(dev);
488 if (ret < 0)
489 goto err_out_unmap_rx;
490
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400491 netdev_info(dev, "%s at %lx, IRQ %d, %pM\n",
492 pci_id_tbl[chip_idx].name,
493 (long)pci_resource_start(pdev, EPIC_BAR), pdev->irq,
494 dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496out:
497 return ret;
498
499err_out_unmap_rx:
500 pci_free_consistent(pdev, RX_TOTAL_SIZE, ep->rx_ring, ep->rx_ring_dma);
501err_out_unmap_tx:
502 pci_free_consistent(pdev, TX_TOTAL_SIZE, ep->tx_ring, ep->tx_ring_dma);
503err_out_iounmap:
Francois Romieuaae9bc32012-03-13 12:04:26 +0100504 pci_iounmap(pdev, ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505err_out_free_netdev:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 free_netdev(dev);
507err_out_free_res:
508 pci_release_regions(pdev);
509err_out_disable:
510 pci_disable_device(pdev);
511 goto out;
512}
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514/* Serial EEPROM section. */
515
516/* EEPROM_Ctrl bits. */
517#define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
518#define EE_CS 0x02 /* EEPROM chip select. */
519#define EE_DATA_WRITE 0x08 /* EEPROM chip data in. */
520#define EE_WRITE_0 0x01
521#define EE_WRITE_1 0x09
522#define EE_DATA_READ 0x10 /* EEPROM chip data out. */
523#define EE_ENB (0x0001 | EE_CS)
524
525/* Delay between EEPROM clock transitions.
526 This serves to flush the operation to the PCI bus.
527 */
528
Francois Romieuaae9bc32012-03-13 12:04:26 +0100529#define eeprom_delay() er32(EECTL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531/* The EEPROM commands include the alway-set leading bit. */
532#define EE_WRITE_CMD (5 << 6)
533#define EE_READ64_CMD (6 << 6)
534#define EE_READ256_CMD (6 << 8)
535#define EE_ERASE_CMD (7 << 6)
536
537static void epic_disable_int(struct net_device *dev, struct epic_private *ep)
538{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100539 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540
Francois Romieuaae9bc32012-03-13 12:04:26 +0100541 ew32(INTMASK, 0x00000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
Francois Romieuaae9bc32012-03-13 12:04:26 +0100544static inline void __epic_pci_commit(void __iomem *ioaddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546#ifndef USE_IO_OPS
Francois Romieuaae9bc32012-03-13 12:04:26 +0100547 er32(INTMASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548#endif
549}
550
551static inline void epic_napi_irq_off(struct net_device *dev,
552 struct epic_private *ep)
553{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100554 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Francois Romieuaae9bc32012-03-13 12:04:26 +0100556 ew32(INTMASK, ep->irq_mask & ~EpicNapiEvent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 __epic_pci_commit(ioaddr);
558}
559
560static inline void epic_napi_irq_on(struct net_device *dev,
561 struct epic_private *ep)
562{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100563 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 /* No need to commit possible posted write */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100566 ew32(INTMASK, ep->irq_mask | EpicNapiEvent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Bill Pembertonb0171cd2012-12-03 09:23:42 -0500569static int read_eeprom(struct epic_private *ep, int location)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100571 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 int i;
573 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 int read_cmd = location |
Francois Romieuaae9bc32012-03-13 12:04:26 +0100575 (er32(EECTL) & 0x40 ? EE_READ64_CMD : EE_READ256_CMD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
Francois Romieuaae9bc32012-03-13 12:04:26 +0100577 ew32(EECTL, EE_ENB & ~EE_CS);
578 ew32(EECTL, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 /* Shift the read command bits out. */
581 for (i = 12; i >= 0; i--) {
582 short dataval = (read_cmd & (1 << i)) ? EE_WRITE_1 : EE_WRITE_0;
Francois Romieuaae9bc32012-03-13 12:04:26 +0100583 ew32(EECTL, EE_ENB | dataval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 eeprom_delay();
Francois Romieuaae9bc32012-03-13 12:04:26 +0100585 ew32(EECTL, EE_ENB | dataval | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 eeprom_delay();
587 }
Francois Romieuaae9bc32012-03-13 12:04:26 +0100588 ew32(EECTL, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 for (i = 16; i > 0; i--) {
Francois Romieuaae9bc32012-03-13 12:04:26 +0100591 ew32(EECTL, EE_ENB | EE_SHIFT_CLK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 eeprom_delay();
Francois Romieuaae9bc32012-03-13 12:04:26 +0100593 retval = (retval << 1) | ((er32(EECTL) & EE_DATA_READ) ? 1 : 0);
594 ew32(EECTL, EE_ENB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 eeprom_delay();
596 }
597
598 /* Terminate the EEPROM access. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100599 ew32(EECTL, EE_ENB & ~EE_CS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 return retval;
601}
602
603#define MII_READOP 1
604#define MII_WRITEOP 2
605static int mdio_read(struct net_device *dev, int phy_id, int location)
606{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100607 struct epic_private *ep = netdev_priv(dev);
608 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 int read_cmd = (phy_id << 9) | (location << 4) | MII_READOP;
610 int i;
611
Francois Romieuaae9bc32012-03-13 12:04:26 +0100612 ew32(MIICtrl, read_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 /* Typical operation takes 25 loops. */
614 for (i = 400; i > 0; i--) {
615 barrier();
Francois Romieuaae9bc32012-03-13 12:04:26 +0100616 if ((er32(MIICtrl) & MII_READOP) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /* Work around read failure bug. */
Joe Perches8e95a202009-12-03 07:58:21 +0000618 if (phy_id == 1 && location < 6 &&
Francois Romieuaae9bc32012-03-13 12:04:26 +0100619 er16(MIIData) == 0xffff) {
620 ew32(MIICtrl, read_cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 continue;
622 }
Francois Romieuaae9bc32012-03-13 12:04:26 +0100623 return er16(MIIData);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 }
625 }
626 return 0xffff;
627}
628
629static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
630{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100631 struct epic_private *ep = netdev_priv(dev);
632 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 int i;
634
Francois Romieuaae9bc32012-03-13 12:04:26 +0100635 ew16(MIIData, value);
636 ew32(MIICtrl, (phy_id << 9) | (loc << 4) | MII_WRITEOP);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400637 for (i = 10000; i > 0; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 barrier();
Francois Romieuaae9bc32012-03-13 12:04:26 +0100639 if ((er32(MIICtrl) & MII_WRITEOP) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 break;
641 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642}
643
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645static int epic_open(struct net_device *dev)
646{
Wang Chen4cf16532008-11-12 23:38:14 -0800647 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100648 void __iomem *ioaddr = ep->ioaddr;
649 const int irq = ep->pci_dev->irq;
650 int rc, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 /* Soft reset the chip. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100653 ew32(GENCTL, 0x4001);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700655 napi_enable(&ep->napi);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100656 rc = request_irq(irq, epic_interrupt, IRQF_SHARED, dev->name, dev);
657 if (rc) {
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700658 napi_disable(&ep->napi);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100659 return rc;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 epic_init_ring(dev);
663
Francois Romieuaae9bc32012-03-13 12:04:26 +0100664 ew32(GENCTL, 0x4000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 /* This magic is documented in SMSC app note 7.15 */
666 for (i = 16; i > 0; i--)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100667 ew32(TEST1, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669 /* Pull the chip out of low-power mode, enable interrupts, and set for
670 PCI read multiple. The MIIcfg setting and strange write order are
671 required by the details of which bits are reset and the transceiver
672 wiring on the Ositech CardBus card.
673 */
674#if 0
Francois Romieuaae9bc32012-03-13 12:04:26 +0100675 ew32(MIICfg, dev->if_port == 1 ? 0x13 : 0x12);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676#endif
677 if (ep->chip_flags & MII_PWRDWN)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100678 ew32(NVCTL, (er32(NVCTL) & ~0x003c) | 0x4800);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Al Viro9ebfd492008-03-16 22:22:04 +0000680 /* Tell the chip to byteswap descriptors on big-endian hosts */
Roland Dreier9e2d11b2010-06-02 10:36:53 +0000681#ifdef __BIG_ENDIAN
Francois Romieuaae9bc32012-03-13 12:04:26 +0100682 ew32(GENCTL, 0x4432 | (RX_FIFO_THRESH << 8));
683 er32(GENCTL);
684 ew32(GENCTL, 0x0432 | (RX_FIFO_THRESH << 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685#else
Francois Romieuaae9bc32012-03-13 12:04:26 +0100686 ew32(GENCTL, 0x4412 | (RX_FIFO_THRESH << 8));
687 er32(GENCTL);
688 ew32(GENCTL, 0x0412 | (RX_FIFO_THRESH << 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689#endif
690
691 udelay(20); /* Looks like EPII needs that if you want reliable RX init. FIXME: pci posting bug? */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400692
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 for (i = 0; i < 3; i++)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100694 ew32(LAN0 + i*4, le16_to_cpu(((__le16*)dev->dev_addr)[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 ep->tx_threshold = TX_FIFO_THRESH;
Francois Romieuaae9bc32012-03-13 12:04:26 +0100697 ew32(TxThresh, ep->tx_threshold);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
699 if (media2miictl[dev->if_port & 15]) {
700 if (ep->mii_phy_cnt)
701 mdio_write(dev, ep->phys[0], MII_BMCR, media2miictl[dev->if_port&15]);
702 if (dev->if_port == 1) {
703 if (debug > 1)
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400704 netdev_info(dev, "Using the 10base2 transceiver, MII status %4.4x.\n",
705 mdio_read(dev, ep->phys[0], MII_BMSR));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
707 } else {
708 int mii_lpa = mdio_read(dev, ep->phys[0], MII_LPA);
709 if (mii_lpa != 0xffff) {
710 if ((mii_lpa & LPA_100FULL) || (mii_lpa & 0x01C0) == LPA_10FULL)
711 ep->mii.full_duplex = 1;
712 else if (! (mii_lpa & LPA_LPACK))
713 mdio_write(dev, ep->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
714 if (debug > 1)
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400715 netdev_info(dev, "Setting %s-duplex based on MII xcvr %d register read of %4.4x.\n",
716 ep->mii.full_duplex ? "full"
717 : "half",
718 ep->phys[0], mii_lpa);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 }
720 }
721
Francois Romieuaae9bc32012-03-13 12:04:26 +0100722 ew32(TxCtrl, ep->mii.full_duplex ? 0x7f : 0x79);
723 ew32(PRxCDAR, ep->rx_ring_dma);
724 ew32(PTxCDAR, ep->tx_ring_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 /* Start the chip's Rx process. */
727 set_rx_mode(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100728 ew32(COMMAND, StartRx | RxQueued);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 netif_start_queue(dev);
731
732 /* Enable interrupts by setting the interrupt mask. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100733 ew32(INTMASK, RxError | RxHeader | EpicNapiEvent | CntFull |
734 ((ep->chip_flags & TYPE2_INTR) ? PCIBusErr175 : PCIBusErr170) |
735 TxUnderrun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Francois Romieuaae9bc32012-03-13 12:04:26 +0100737 if (debug > 1) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400738 netdev_dbg(dev, "epic_open() ioaddr %p IRQ %d status %4.4x %s-duplex.\n",
739 ioaddr, irq, er32(GENCTL),
740 ep->mii.full_duplex ? "full" : "half");
Francois Romieuaae9bc32012-03-13 12:04:26 +0100741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 /* Set the timer to switch to check for link beat and perhaps switch
744 to an alternate media type. */
745 init_timer(&ep->timer);
746 ep->timer.expires = jiffies + 3*HZ;
747 ep->timer.data = (unsigned long)dev;
Joe Perchesc061b182010-08-23 18:20:03 +0000748 ep->timer.function = epic_timer; /* timer handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 add_timer(&ep->timer);
750
Francois Romieuaae9bc32012-03-13 12:04:26 +0100751 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752}
753
754/* Reset the chip to recover from a PCI transaction error.
755 This may occur at interrupt time. */
756static void epic_pause(struct net_device *dev)
757{
Francois Romieuaae9bc32012-03-13 12:04:26 +0100758 struct net_device_stats *stats = &dev->stats;
759 struct epic_private *ep = netdev_priv(dev);
760 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
762 netif_stop_queue (dev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400763
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 /* Disable interrupts by clearing the interrupt mask. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100765 ew32(INTMASK, 0x00000000);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 /* Stop the chip's Tx and Rx DMA processes. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100767 ew16(COMMAND, StopRx | StopTxDMA | StopRxDMA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
769 /* Update the error counts. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100770 if (er16(COMMAND) != 0xffff) {
771 stats->rx_missed_errors += er8(MPCNT);
772 stats->rx_frame_errors += er8(ALICNT);
773 stats->rx_crc_errors += er8(CRCCNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775
776 /* Remove the packets on the Rx queue. */
777 epic_rx(dev, RX_RING_SIZE);
778}
779
780static void epic_restart(struct net_device *dev)
781{
Wang Chen4cf16532008-11-12 23:38:14 -0800782 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100783 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 int i;
785
786 /* Soft reset the chip. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100787 ew32(GENCTL, 0x4001);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400789 netdev_dbg(dev, "Restarting the EPIC chip, Rx %d/%d Tx %d/%d.\n",
790 ep->cur_rx, ep->dirty_rx, ep->dirty_tx, ep->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 udelay(1);
792
793 /* This magic is documented in SMSC app note 7.15 */
794 for (i = 16; i > 0; i--)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100795 ew32(TEST1, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Roland Dreier9e2d11b2010-06-02 10:36:53 +0000797#ifdef __BIG_ENDIAN
Francois Romieuaae9bc32012-03-13 12:04:26 +0100798 ew32(GENCTL, 0x0432 | (RX_FIFO_THRESH << 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799#else
Francois Romieuaae9bc32012-03-13 12:04:26 +0100800 ew32(GENCTL, 0x0412 | (RX_FIFO_THRESH << 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801#endif
Francois Romieuaae9bc32012-03-13 12:04:26 +0100802 ew32(MIICfg, dev->if_port == 1 ? 0x13 : 0x12);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 if (ep->chip_flags & MII_PWRDWN)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100804 ew32(NVCTL, (er32(NVCTL) & ~0x003c) | 0x4800);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
806 for (i = 0; i < 3; i++)
Francois Romieuaae9bc32012-03-13 12:04:26 +0100807 ew32(LAN0 + i*4, le16_to_cpu(((__le16*)dev->dev_addr)[i]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
809 ep->tx_threshold = TX_FIFO_THRESH;
Francois Romieuaae9bc32012-03-13 12:04:26 +0100810 ew32(TxThresh, ep->tx_threshold);
811 ew32(TxCtrl, ep->mii.full_duplex ? 0x7f : 0x79);
812 ew32(PRxCDAR, ep->rx_ring_dma +
813 (ep->cur_rx % RX_RING_SIZE) * sizeof(struct epic_rx_desc));
814 ew32(PTxCDAR, ep->tx_ring_dma +
815 (ep->dirty_tx % TX_RING_SIZE) * sizeof(struct epic_tx_desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 /* Start the chip's Rx process. */
818 set_rx_mode(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100819 ew32(COMMAND, StartRx | RxQueued);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
821 /* Enable interrupts by setting the interrupt mask. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100822 ew32(INTMASK, RxError | RxHeader | EpicNapiEvent | CntFull |
823 ((ep->chip_flags & TYPE2_INTR) ? PCIBusErr175 : PCIBusErr170) |
824 TxUnderrun);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400826 netdev_dbg(dev, "epic_restart() done, cmd status %4.4x, ctl %4.4x interrupt %4.4x.\n",
827 er32(COMMAND), er32(GENCTL), er32(INTSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828}
829
830static void check_media(struct net_device *dev)
831{
Wang Chen4cf16532008-11-12 23:38:14 -0800832 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100833 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 int mii_lpa = ep->mii_phy_cnt ? mdio_read(dev, ep->phys[0], MII_LPA) : 0;
835 int negotiated = mii_lpa & ep->mii.advertising;
836 int duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
837
838 if (ep->mii.force_media)
839 return;
840 if (mii_lpa == 0xffff) /* Bogus read */
841 return;
842 if (ep->mii.full_duplex != duplex) {
843 ep->mii.full_duplex = duplex;
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400844 netdev_info(dev, "Setting %s-duplex based on MII #%d link partner capability of %4.4x.\n",
845 ep->mii.full_duplex ? "full" : "half",
846 ep->phys[0], mii_lpa);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100847 ew32(TxCtrl, ep->mii.full_duplex ? 0x7F : 0x79);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
849}
850
851static void epic_timer(unsigned long data)
852{
853 struct net_device *dev = (struct net_device *)data;
Wang Chen4cf16532008-11-12 23:38:14 -0800854 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100855 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 int next_tick = 5*HZ;
857
858 if (debug > 3) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400859 netdev_dbg(dev, "Media monitor tick, Tx status %8.8x.\n",
860 er32(TxSTAT));
861 netdev_dbg(dev, "Other registers are IntMask %4.4x IntStatus %4.4x RxStatus %4.4x.\n",
862 er32(INTMASK), er32(INTSTAT), er32(RxSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
864
865 check_media(dev);
866
867 ep->timer.expires = jiffies + next_tick;
868 add_timer(&ep->timer);
869}
870
871static void epic_tx_timeout(struct net_device *dev)
872{
Wang Chen4cf16532008-11-12 23:38:14 -0800873 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100874 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
876 if (debug > 0) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400877 netdev_warn(dev, "Transmit timeout using MII device, Tx status %4.4x.\n",
878 er16(TxSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (debug > 1) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400880 netdev_dbg(dev, "Tx indices: dirty_tx %d, cur_tx %d.\n",
881 ep->dirty_tx, ep->cur_tx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 }
883 }
Francois Romieuaae9bc32012-03-13 12:04:26 +0100884 if (er16(TxSTAT) & 0x10) { /* Tx FIFO underflow. */
Kulikov Vasiliy275defc2010-07-05 02:13:20 +0000885 dev->stats.tx_fifo_errors++;
Francois Romieuaae9bc32012-03-13 12:04:26 +0100886 ew32(COMMAND, RestartTx);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 } else {
888 epic_restart(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100889 ew32(COMMAND, TxQueued);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 }
891
Eric Dumazet1ae5dc32010-05-10 05:01:31 -0700892 dev->trans_start = jiffies; /* prevent tx timeout */
Kulikov Vasiliy275defc2010-07-05 02:13:20 +0000893 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 if (!ep->tx_full)
895 netif_wake_queue(dev);
896}
897
898/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
899static void epic_init_ring(struct net_device *dev)
900{
Wang Chen4cf16532008-11-12 23:38:14 -0800901 struct epic_private *ep = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 int i;
903
904 ep->tx_full = 0;
905 ep->dirty_tx = ep->cur_tx = 0;
906 ep->cur_rx = ep->dirty_rx = 0;
907 ep->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
908
909 /* Initialize all Rx descriptors. */
910 for (i = 0; i < RX_RING_SIZE; i++) {
911 ep->rx_ring[i].rxstatus = 0;
Al Viro9ebfd492008-03-16 22:22:04 +0000912 ep->rx_ring[i].buflength = ep->rx_buf_sz;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400913 ep->rx_ring[i].next = ep->rx_ring_dma +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 (i+1)*sizeof(struct epic_rx_desc);
915 ep->rx_skbuff[i] = NULL;
916 }
917 /* Mark the last entry as wrapping the ring. */
918 ep->rx_ring[i-1].next = ep->rx_ring_dma;
919
920 /* Fill in the Rx buffers. Handle allocation failure gracefully. */
921 for (i = 0; i < RX_RING_SIZE; i++) {
Pradeep A. Dalvidae2e9f2012-02-06 11:16:13 +0000922 struct sk_buff *skb = netdev_alloc_skb(dev, ep->rx_buf_sz + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 ep->rx_skbuff[i] = skb;
924 if (skb == NULL)
925 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 skb_reserve(skb, 2); /* 16 byte align the IP header. */
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400927 ep->rx_ring[i].bufaddr = pci_map_single(ep->pci_dev,
David S. Miller689be432005-06-28 15:25:31 -0700928 skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
Al Viro9ebfd492008-03-16 22:22:04 +0000929 ep->rx_ring[i].rxstatus = DescOwn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 }
931 ep->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
932
933 /* The Tx buffer descriptor is filled in as needed, but we
934 do need to clear the ownership bit. */
935 for (i = 0; i < TX_RING_SIZE; i++) {
936 ep->tx_skbuff[i] = NULL;
937 ep->tx_ring[i].txstatus = 0x0000;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400938 ep->tx_ring[i].next = ep->tx_ring_dma +
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 (i+1)*sizeof(struct epic_tx_desc);
940 }
941 ep->tx_ring[i-1].next = ep->tx_ring_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
943
Stephen Hemminger613573252009-08-31 19:50:58 +0000944static netdev_tx_t epic_start_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
Wang Chen4cf16532008-11-12 23:38:14 -0800946 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +0100947 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 int entry, free_count;
949 u32 ctrl_word;
950 unsigned long flags;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400951
Herbert Xu5b057c62006-06-23 02:06:41 -0700952 if (skb_padto(skb, ETH_ZLEN))
Patrick McHardy6ed10652009-06-23 06:03:08 +0000953 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
955 /* Caution: the write order is important here, set the field with the
956 "ownership" bit last. */
957
958 /* Calculate the next Tx descriptor entry. */
959 spin_lock_irqsave(&ep->lock, flags);
960 free_count = ep->cur_tx - ep->dirty_tx;
961 entry = ep->cur_tx % TX_RING_SIZE;
962
963 ep->tx_skbuff[entry] = skb;
Jeff Garzikf3b197a2006-05-26 21:39:03 -0400964 ep->tx_ring[entry].bufaddr = pci_map_single(ep->pci_dev, skb->data,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 skb->len, PCI_DMA_TODEVICE);
966 if (free_count < TX_QUEUE_LEN/2) {/* Typical path */
Al Viro9ebfd492008-03-16 22:22:04 +0000967 ctrl_word = 0x100000; /* No interrupt */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 } else if (free_count == TX_QUEUE_LEN/2) {
Al Viro9ebfd492008-03-16 22:22:04 +0000969 ctrl_word = 0x140000; /* Tx-done intr. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 } else if (free_count < TX_QUEUE_LEN - 1) {
Al Viro9ebfd492008-03-16 22:22:04 +0000971 ctrl_word = 0x100000; /* No Tx-done intr. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 } else {
973 /* Leave room for an additional entry. */
Al Viro9ebfd492008-03-16 22:22:04 +0000974 ctrl_word = 0x140000; /* Tx-done intr. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 ep->tx_full = 1;
976 }
Al Viro9ebfd492008-03-16 22:22:04 +0000977 ep->tx_ring[entry].buflength = ctrl_word | skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 ep->tx_ring[entry].txstatus =
979 ((skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN) << 16)
Al Viro9ebfd492008-03-16 22:22:04 +0000980 | DescOwn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
982 ep->cur_tx++;
983 if (ep->tx_full)
984 netif_stop_queue(dev);
985
986 spin_unlock_irqrestore(&ep->lock, flags);
987 /* Trigger an immediate transmit demand. */
Francois Romieuaae9bc32012-03-13 12:04:26 +0100988 ew32(COMMAND, TxQueued);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 if (debug > 4)
Ben Boeckel3ee307d2013-11-01 08:53:30 -0400991 netdev_dbg(dev, "Queued Tx packet size %d to slot %d, flag %2.2x Tx status %8.8x.\n",
992 skb->len, entry, ctrl_word, er32(TxSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
Patrick McHardy6ed10652009-06-23 06:03:08 +0000994 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
996
997static void epic_tx_error(struct net_device *dev, struct epic_private *ep,
998 int status)
999{
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001000 struct net_device_stats *stats = &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
1002#ifndef final_version
1003 /* There was an major error, log it. */
1004 if (debug > 1)
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001005 netdev_dbg(dev, "Transmit error, Tx status %8.8x.\n",
1006 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007#endif
1008 stats->tx_errors++;
1009 if (status & 0x1050)
1010 stats->tx_aborted_errors++;
1011 if (status & 0x0008)
1012 stats->tx_carrier_errors++;
1013 if (status & 0x0040)
1014 stats->tx_window_errors++;
1015 if (status & 0x0010)
1016 stats->tx_fifo_errors++;
1017}
1018
1019static void epic_tx(struct net_device *dev, struct epic_private *ep)
1020{
1021 unsigned int dirty_tx, cur_tx;
1022
1023 /*
1024 * Note: if this lock becomes a problem we can narrow the locked
1025 * region at the cost of occasionally grabbing the lock more times.
1026 */
1027 cur_tx = ep->cur_tx;
1028 for (dirty_tx = ep->dirty_tx; cur_tx - dirty_tx > 0; dirty_tx++) {
1029 struct sk_buff *skb;
1030 int entry = dirty_tx % TX_RING_SIZE;
Al Viro9ebfd492008-03-16 22:22:04 +00001031 int txstatus = ep->tx_ring[entry].txstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
1033 if (txstatus & DescOwn)
1034 break; /* It still hasn't been Txed */
1035
1036 if (likely(txstatus & 0x0001)) {
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001037 dev->stats.collisions += (txstatus >> 8) & 15;
1038 dev->stats.tx_packets++;
1039 dev->stats.tx_bytes += ep->tx_skbuff[entry]->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 } else
1041 epic_tx_error(dev, ep, txstatus);
1042
1043 /* Free the original skb. */
1044 skb = ep->tx_skbuff[entry];
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001045 pci_unmap_single(ep->pci_dev, ep->tx_ring[entry].bufaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 skb->len, PCI_DMA_TODEVICE);
1047 dev_kfree_skb_irq(skb);
1048 ep->tx_skbuff[entry] = NULL;
1049 }
1050
1051#ifndef final_version
1052 if (cur_tx - dirty_tx > TX_RING_SIZE) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001053 netdev_warn(dev, "Out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
1054 dirty_tx, cur_tx, ep->tx_full);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 dirty_tx += TX_RING_SIZE;
1056 }
1057#endif
1058 ep->dirty_tx = dirty_tx;
1059 if (ep->tx_full && cur_tx - dirty_tx < TX_QUEUE_LEN - 4) {
1060 /* The ring is no longer full, allow new TX entries. */
1061 ep->tx_full = 0;
1062 netif_wake_queue(dev);
1063 }
1064}
1065
1066/* The interrupt handler does all of the Rx thread work and cleans up
1067 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01001068static irqreturn_t epic_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
1070 struct net_device *dev = dev_instance;
Wang Chen4cf16532008-11-12 23:38:14 -08001071 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001072 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 unsigned int handled = 0;
1074 int status;
1075
Francois Romieuaae9bc32012-03-13 12:04:26 +01001076 status = er32(INTSTAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 /* Acknowledge all of the current interrupt sources ASAP. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001078 ew32(INTSTAT, status & EpicNormalEvent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 if (debug > 4) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001081 netdev_dbg(dev, "Interrupt, status=%#8.8x new intstat=%#8.8x.\n",
1082 status, er32(INTSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 }
1084
1085 if ((status & IntrSummary) == 0)
1086 goto out;
1087
1088 handled = 1;
1089
1090 if ((status & EpicNapiEvent) && !ep->reschedule_in_poll) {
1091 spin_lock(&ep->napi_lock);
Ben Hutchings288379f2009-01-19 16:43:59 -08001092 if (napi_schedule_prep(&ep->napi)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 epic_napi_irq_off(dev, ep);
Ben Hutchings288379f2009-01-19 16:43:59 -08001094 __napi_schedule(&ep->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 } else
1096 ep->reschedule_in_poll++;
1097 spin_unlock(&ep->napi_lock);
1098 }
1099 status &= ~EpicNapiEvent;
1100
1101 /* Check uncommon events all at once. */
1102 if (status & (CntFull | TxUnderrun | PCIBusErr170 | PCIBusErr175)) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001103 struct net_device_stats *stats = &dev->stats;
1104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 if (status == EpicRemoved)
1106 goto out;
1107
1108 /* Always update the error counts to avoid overhead later. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001109 stats->rx_missed_errors += er8(MPCNT);
1110 stats->rx_frame_errors += er8(ALICNT);
1111 stats->rx_crc_errors += er8(CRCCNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113 if (status & TxUnderrun) { /* Tx FIFO underflow. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001114 stats->tx_fifo_errors++;
1115 ew32(TxThresh, ep->tx_threshold += 128);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 /* Restart the transmit process. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001117 ew32(COMMAND, RestartTx);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 }
1119 if (status & PCIBusErr170) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001120 netdev_err(dev, "PCI Bus Error! status %4.4x.\n",
1121 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 epic_pause(dev);
1123 epic_restart(dev);
1124 }
1125 /* Clear all error sources. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001126 ew32(INTSTAT, status & 0x7f18);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 }
1128
1129out:
1130 if (debug > 3) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001131 netdev_dbg(dev, "exit interrupt, intr_status=%#4.4x.\n",
1132 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
1134
1135 return IRQ_RETVAL(handled);
1136}
1137
1138static int epic_rx(struct net_device *dev, int budget)
1139{
Wang Chen4cf16532008-11-12 23:38:14 -08001140 struct epic_private *ep = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 int entry = ep->cur_rx % RX_RING_SIZE;
1142 int rx_work_limit = ep->dirty_rx + RX_RING_SIZE - ep->cur_rx;
1143 int work_done = 0;
1144
1145 if (debug > 4)
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001146 netdev_dbg(dev, " In epic_rx(), entry %d %8.8x.\n", entry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 ep->rx_ring[entry].rxstatus);
1148
1149 if (rx_work_limit > budget)
1150 rx_work_limit = budget;
1151
1152 /* If we own the next entry, it's a new packet. Send it up. */
Al Viro9ebfd492008-03-16 22:22:04 +00001153 while ((ep->rx_ring[entry].rxstatus & DescOwn) == 0) {
1154 int status = ep->rx_ring[entry].rxstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 if (debug > 4)
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001157 netdev_dbg(dev, " epic_rx() status was %8.8x.\n",
1158 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 if (--rx_work_limit < 0)
1160 break;
1161 if (status & 0x2006) {
1162 if (debug > 2)
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001163 netdev_dbg(dev, "epic_rx() error status was %8.8x.\n",
1164 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 if (status & 0x2000) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001166 netdev_warn(dev, "Oversized Ethernet frame spanned multiple buffers, status %4.4x!\n",
1167 status);
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001168 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 } else if (status & 0x0006)
1170 /* Rx Frame errors are counted in hardware. */
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001171 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 } else {
1173 /* Malloc up new buffer, compatible with net-2e. */
1174 /* Omit the four octet CRC from the length. */
1175 short pkt_len = (status >> 16) - 4;
1176 struct sk_buff *skb;
1177
1178 if (pkt_len > PKT_BUF_SZ - 4) {
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001179 netdev_err(dev, "Oversized Ethernet frame, status %x %d bytes.\n",
1180 status, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 pkt_len = 1514;
1182 }
1183 /* Check if the packet is long enough to accept without copying
1184 to a minimally-sized skbuff. */
Joe Perches8e95a202009-12-03 07:58:21 +00001185 if (pkt_len < rx_copybreak &&
Pradeep A. Dalvidae2e9f2012-02-06 11:16:13 +00001186 (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 skb_reserve(skb, 2); /* 16 byte align the IP header */
1188 pci_dma_sync_single_for_cpu(ep->pci_dev,
1189 ep->rx_ring[entry].bufaddr,
1190 ep->rx_buf_sz,
1191 PCI_DMA_FROMDEVICE);
David S. Miller8c7b7fa2007-07-10 22:08:12 -07001192 skb_copy_to_linear_data(skb, ep->rx_skbuff[entry]->data, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 skb_put(skb, pkt_len);
1194 pci_dma_sync_single_for_device(ep->pci_dev,
1195 ep->rx_ring[entry].bufaddr,
1196 ep->rx_buf_sz,
1197 PCI_DMA_FROMDEVICE);
1198 } else {
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001199 pci_unmap_single(ep->pci_dev,
1200 ep->rx_ring[entry].bufaddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
1202 skb_put(skb = ep->rx_skbuff[entry], pkt_len);
1203 ep->rx_skbuff[entry] = NULL;
1204 }
1205 skb->protocol = eth_type_trans(skb, dev);
1206 netif_receive_skb(skb);
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001207 dev->stats.rx_packets++;
1208 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 }
1210 work_done++;
1211 entry = (++ep->cur_rx) % RX_RING_SIZE;
1212 }
1213
1214 /* Refill the Rx ring buffers. */
1215 for (; ep->cur_rx - ep->dirty_rx > 0; ep->dirty_rx++) {
1216 entry = ep->dirty_rx % RX_RING_SIZE;
1217 if (ep->rx_skbuff[entry] == NULL) {
1218 struct sk_buff *skb;
Pradeep A. Dalvidae2e9f2012-02-06 11:16:13 +00001219 skb = ep->rx_skbuff[entry] = netdev_alloc_skb(dev, ep->rx_buf_sz + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 if (skb == NULL)
1221 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001223 ep->rx_ring[entry].bufaddr = pci_map_single(ep->pci_dev,
David S. Miller689be432005-06-28 15:25:31 -07001224 skb->data, ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 work_done++;
1226 }
Al Viro9ebfd492008-03-16 22:22:04 +00001227 /* AV: shouldn't we add a barrier here? */
1228 ep->rx_ring[entry].rxstatus = DescOwn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230 return work_done;
1231}
1232
1233static void epic_rx_err(struct net_device *dev, struct epic_private *ep)
1234{
Francois Romieuaae9bc32012-03-13 12:04:26 +01001235 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 int status;
1237
Francois Romieuaae9bc32012-03-13 12:04:26 +01001238 status = er32(INTSTAT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
1240 if (status == EpicRemoved)
1241 return;
1242 if (status & RxOverflow) /* Missed a Rx frame. */
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001243 dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 if (status & (RxOverflow | RxFull))
Francois Romieuaae9bc32012-03-13 12:04:26 +01001245 ew16(COMMAND, RxQueued);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246}
1247
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001248static int epic_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001250 struct epic_private *ep = container_of(napi, struct epic_private, napi);
1251 struct net_device *dev = ep->mii.dev;
1252 int work_done = 0;
Francois Romieuaae9bc32012-03-13 12:04:26 +01001253 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255rx_action:
1256
1257 epic_tx(dev, ep);
1258
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001259 work_done += epic_rx(dev, budget);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 epic_rx_err(dev, ep);
1262
David S. Miller4ec24112008-01-07 20:48:21 -08001263 if (work_done < budget) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 unsigned long flags;
1265 int more;
1266
1267 /* A bit baroque but it avoids a (space hungry) spin_unlock */
1268
1269 spin_lock_irqsave(&ep->napi_lock, flags);
1270
1271 more = ep->reschedule_in_poll;
1272 if (!more) {
Ben Hutchings288379f2009-01-19 16:43:59 -08001273 __napi_complete(napi);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001274 ew32(INTSTAT, EpicNapiEvent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 epic_napi_irq_on(dev, ep);
1276 } else
1277 ep->reschedule_in_poll--;
1278
1279 spin_unlock_irqrestore(&ep->napi_lock, flags);
1280
1281 if (more)
1282 goto rx_action;
1283 }
1284
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001285 return work_done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286}
1287
1288static int epic_close(struct net_device *dev)
1289{
Wang Chen4cf16532008-11-12 23:38:14 -08001290 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001291 struct pci_dev *pdev = ep->pci_dev;
1292 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 struct sk_buff *skb;
1294 int i;
1295
1296 netif_stop_queue(dev);
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001297 napi_disable(&ep->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
1299 if (debug > 1)
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001300 netdev_dbg(dev, "Shutting down ethercard, status was %2.2x.\n",
1301 er32(INTSTAT));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 del_timer_sync(&ep->timer);
1304
1305 epic_disable_int(dev, ep);
1306
Francois Romieuaae9bc32012-03-13 12:04:26 +01001307 free_irq(pdev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 epic_pause(dev);
1310
1311 /* Free all the skbuffs in the Rx queue. */
1312 for (i = 0; i < RX_RING_SIZE; i++) {
1313 skb = ep->rx_skbuff[i];
1314 ep->rx_skbuff[i] = NULL;
1315 ep->rx_ring[i].rxstatus = 0; /* Not owned by Epic chip. */
1316 ep->rx_ring[i].buflength = 0;
1317 if (skb) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001318 pci_unmap_single(pdev, ep->rx_ring[i].bufaddr,
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001319 ep->rx_buf_sz, PCI_DMA_FROMDEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 dev_kfree_skb(skb);
1321 }
1322 ep->rx_ring[i].bufaddr = 0xBADF00D0; /* An invalid address. */
1323 }
1324 for (i = 0; i < TX_RING_SIZE; i++) {
1325 skb = ep->tx_skbuff[i];
1326 ep->tx_skbuff[i] = NULL;
1327 if (!skb)
1328 continue;
Francois Romieuaae9bc32012-03-13 12:04:26 +01001329 pci_unmap_single(pdev, ep->tx_ring[i].bufaddr, skb->len,
1330 PCI_DMA_TODEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 dev_kfree_skb(skb);
1332 }
1333
1334 /* Green! Leave the chip in low-power mode. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001335 ew32(GENCTL, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
1337 return 0;
1338}
1339
1340static struct net_device_stats *epic_get_stats(struct net_device *dev)
1341{
Francois Romieuaae9bc32012-03-13 12:04:26 +01001342 struct epic_private *ep = netdev_priv(dev);
1343 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
1345 if (netif_running(dev)) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001346 struct net_device_stats *stats = &dev->stats;
1347
1348 stats->rx_missed_errors += er8(MPCNT);
1349 stats->rx_frame_errors += er8(ALICNT);
1350 stats->rx_crc_errors += er8(CRCCNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 }
1352
Kulikov Vasiliy275defc2010-07-05 02:13:20 +00001353 return &dev->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354}
1355
1356/* Set or clear the multicast filter for this adaptor.
1357 Note that we only use exclusion around actually queueing the
1358 new frame, not around filling ep->setup_frame. This is non-deterministic
1359 when re-entered but still correct. */
1360
1361static void set_rx_mode(struct net_device *dev)
1362{
Wang Chen4cf16532008-11-12 23:38:14 -08001363 struct epic_private *ep = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001364 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 unsigned char mc_filter[8]; /* Multicast hash filter */
1366 int i;
1367
1368 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001369 ew32(RxCtrl, 0x002c);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 /* Unconditionally log net taps. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 memset(mc_filter, 0xff, sizeof(mc_filter));
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001372 } else if ((!netdev_mc_empty(dev)) || (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 /* There is apparently a chip bug, so the multicast filter
1374 is never enabled. */
1375 /* Too many to filter perfectly -- accept all multicasts. */
1376 memset(mc_filter, 0xff, sizeof(mc_filter));
Francois Romieuaae9bc32012-03-13 12:04:26 +01001377 ew32(RxCtrl, 0x000c);
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001378 } else if (netdev_mc_empty(dev)) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001379 ew32(RxCtrl, 0x0004);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 return;
1381 } else { /* Never executed, for now. */
Jiri Pirko22bedad32010-04-01 21:22:57 +00001382 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383
1384 memset(mc_filter, 0, sizeof(mc_filter));
Jiri Pirko22bedad32010-04-01 21:22:57 +00001385 netdev_for_each_mc_addr(ha, dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 unsigned int bit_nr =
Jiri Pirko22bedad32010-04-01 21:22:57 +00001387 ether_crc_le(ETH_ALEN, ha->addr) & 0x3f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 mc_filter[bit_nr >> 3] |= (1 << bit_nr);
1389 }
1390 }
1391 /* ToDo: perhaps we need to stop the Tx and Rx process here? */
1392 if (memcmp(mc_filter, ep->mc_filter, sizeof(mc_filter))) {
1393 for (i = 0; i < 4; i++)
Francois Romieuaae9bc32012-03-13 12:04:26 +01001394 ew16(MC0 + i*4, ((u16 *)mc_filter)[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395 memcpy(ep->mc_filter, mc_filter, sizeof(mc_filter));
1396 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
1398
1399static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
1400{
Wang Chen4cf16532008-11-12 23:38:14 -08001401 struct epic_private *np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
Rick Jones68aad782011-11-07 13:29:27 +00001403 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1404 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1405 strlcpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406}
1407
1408static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1409{
Wang Chen4cf16532008-11-12 23:38:14 -08001410 struct epic_private *np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 int rc;
1412
1413 spin_lock_irq(&np->lock);
1414 rc = mii_ethtool_gset(&np->mii, cmd);
1415 spin_unlock_irq(&np->lock);
1416
1417 return rc;
1418}
1419
1420static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1421{
Wang Chen4cf16532008-11-12 23:38:14 -08001422 struct epic_private *np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 int rc;
1424
1425 spin_lock_irq(&np->lock);
1426 rc = mii_ethtool_sset(&np->mii, cmd);
1427 spin_unlock_irq(&np->lock);
1428
1429 return rc;
1430}
1431
1432static int netdev_nway_reset(struct net_device *dev)
1433{
Wang Chen4cf16532008-11-12 23:38:14 -08001434 struct epic_private *np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 return mii_nway_restart(&np->mii);
1436}
1437
1438static u32 netdev_get_link(struct net_device *dev)
1439{
Wang Chen4cf16532008-11-12 23:38:14 -08001440 struct epic_private *np = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 return mii_link_ok(&np->mii);
1442}
1443
1444static u32 netdev_get_msglevel(struct net_device *dev)
1445{
1446 return debug;
1447}
1448
1449static void netdev_set_msglevel(struct net_device *dev, u32 value)
1450{
1451 debug = value;
1452}
1453
1454static int ethtool_begin(struct net_device *dev)
1455{
Francois Romieuaae9bc32012-03-13 12:04:26 +01001456 struct epic_private *ep = netdev_priv(dev);
1457 void __iomem *ioaddr = ep->ioaddr;
1458
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 /* power-up, if interface is down */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001460 if (!netif_running(dev)) {
1461 ew32(GENCTL, 0x0200);
1462 ew32(NVCTL, (er32(NVCTL) & ~0x003c) | 0x4800);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 }
1464 return 0;
1465}
1466
1467static void ethtool_complete(struct net_device *dev)
1468{
Francois Romieuaae9bc32012-03-13 12:04:26 +01001469 struct epic_private *ep = netdev_priv(dev);
1470 void __iomem *ioaddr = ep->ioaddr;
1471
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 /* power-down, if interface is down */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001473 if (!netif_running(dev)) {
1474 ew32(GENCTL, 0x0008);
1475 ew32(NVCTL, (er32(NVCTL) & ~0x483c) | 0x0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 }
1477}
1478
Jeff Garzik7282d492006-09-13 14:30:00 -04001479static const struct ethtool_ops netdev_ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 .get_drvinfo = netdev_get_drvinfo,
1481 .get_settings = netdev_get_settings,
1482 .set_settings = netdev_set_settings,
1483 .nway_reset = netdev_nway_reset,
1484 .get_link = netdev_get_link,
1485 .get_msglevel = netdev_get_msglevel,
1486 .set_msglevel = netdev_set_msglevel,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 .begin = ethtool_begin,
1488 .complete = ethtool_complete
1489};
1490
1491static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1492{
Wang Chen4cf16532008-11-12 23:38:14 -08001493 struct epic_private *np = netdev_priv(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001494 void __iomem *ioaddr = np->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 struct mii_ioctl_data *data = if_mii(rq);
1496 int rc;
1497
1498 /* power-up, if interface is down */
1499 if (! netif_running(dev)) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001500 ew32(GENCTL, 0x0200);
1501 ew32(NVCTL, (er32(NVCTL) & ~0x003c) | 0x4800);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 }
1503
1504 /* all non-ethtool ioctls (the SIOC[GS]MIIxxx ioctls) */
1505 spin_lock_irq(&np->lock);
1506 rc = generic_mii_ioctl(&np->mii, data, cmd, NULL);
1507 spin_unlock_irq(&np->lock);
1508
1509 /* power-down, if interface is down */
1510 if (! netif_running(dev)) {
Francois Romieuaae9bc32012-03-13 12:04:26 +01001511 ew32(GENCTL, 0x0008);
1512 ew32(NVCTL, (er32(NVCTL) & ~0x483c) | 0x0000);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 }
1514 return rc;
1515}
1516
1517
Bill Pembertonb0171cd2012-12-03 09:23:42 -05001518static void epic_remove_one(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519{
1520 struct net_device *dev = pci_get_drvdata(pdev);
Wang Chen4cf16532008-11-12 23:38:14 -08001521 struct epic_private *ep = netdev_priv(dev);
Jeff Garzikf3b197a2006-05-26 21:39:03 -04001522
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 pci_free_consistent(pdev, TX_TOTAL_SIZE, ep->tx_ring, ep->tx_ring_dma);
1524 pci_free_consistent(pdev, RX_TOTAL_SIZE, ep->rx_ring, ep->rx_ring_dma);
1525 unregister_netdev(dev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001526 pci_iounmap(pdev, ep->ioaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 pci_release_regions(pdev);
1528 free_netdev(dev);
1529 pci_disable_device(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 /* pci_power_off(pdev, -1); */
1531}
1532
1533
1534#ifdef CONFIG_PM
1535
1536static int epic_suspend (struct pci_dev *pdev, pm_message_t state)
1537{
1538 struct net_device *dev = pci_get_drvdata(pdev);
Francois Romieuaae9bc32012-03-13 12:04:26 +01001539 struct epic_private *ep = netdev_priv(dev);
1540 void __iomem *ioaddr = ep->ioaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
1542 if (!netif_running(dev))
1543 return 0;
1544 epic_pause(dev);
1545 /* Put the chip into low-power mode. */
Francois Romieuaae9bc32012-03-13 12:04:26 +01001546 ew32(GENCTL, 0x0008);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 /* pci_power_off(pdev, -1); */
1548 return 0;
1549}
1550
1551
1552static int epic_resume (struct pci_dev *pdev)
1553{
1554 struct net_device *dev = pci_get_drvdata(pdev);
1555
1556 if (!netif_running(dev))
1557 return 0;
1558 epic_restart(dev);
1559 /* pci_power_on(pdev); */
1560 return 0;
1561}
1562
1563#endif /* CONFIG_PM */
1564
1565
1566static struct pci_driver epic_driver = {
1567 .name = DRV_NAME,
1568 .id_table = epic_pci_tbl,
1569 .probe = epic_init_one,
Bill Pembertonb0171cd2012-12-03 09:23:42 -05001570 .remove = epic_remove_one,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571#ifdef CONFIG_PM
1572 .suspend = epic_suspend,
1573 .resume = epic_resume,
1574#endif /* CONFIG_PM */
1575};
1576
1577
1578static int __init epic_init (void)
1579{
1580/* when a module, this is printed whether or not devices are found in probe */
1581#ifdef MODULE
Ben Boeckel3ee307d2013-11-01 08:53:30 -04001582 pr_info("%s%s\n", version, version2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583#endif
1584
Jeff Garzik29917622006-08-19 17:48:59 -04001585 return pci_register_driver(&epic_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586}
1587
1588
1589static void __exit epic_cleanup (void)
1590{
1591 pci_unregister_driver (&epic_driver);
1592}
1593
1594
1595module_init(epic_init);
1596module_exit(epic_cleanup);