Loading...
1// SPDX-License-Identifier: GPL-1.0+
2/* A Linux device driver for PCI NE2000 clones.
3 *
4 * Authors and other copyright holders:
5 * 1992-2000 by Donald Becker, NE2000 core and various modifications.
6 * 1995-1998 by Paul Gortmaker, core modifications and PCI support.
7 * Copyright 1993 assigned to the United States Government as represented
8 * by the Director, National Security Agency.
9 *
10 * This software may be used and distributed according to the terms of
11 * the GNU General Public License (GPL), incorporated herein by reference.
12 * Drivers based on or derived from this code fall under the GPL and must
13 * retain the authorship, copyright and license notice. This file is not
14 * a complete program and may only be used when the entire operating
15 * system is licensed under the GPL.
16 *
17 * The author may be reached as becker@scyld.com, or C/O
18 * Scyld Computing Corporation
19 * 410 Severn Ave., Suite 210
20 * Annapolis MD 21403
21 *
22 * Issues remaining:
23 * People are making PCI NE2000 clones! Oh the horror, the horror...
24 * Limited full-duplex support.
25 */
26
27#define DRV_NAME "ne2k-pci"
28#define DRV_DESCRIPTION "PCI NE2000 clone driver"
29#define DRV_AUTHOR "Donald Becker / Paul Gortmaker"
30#define DRV_VERSION "1.03"
31#define DRV_RELDATE "9/22/2003"
32
33#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34
35/* The user-configurable values.
36 * These may be modified when a driver module is loaded.
37 */
38
39/* More are supported, limit only on options */
40#define MAX_UNITS 8
41
42/* Used to pass the full-duplex flag, etc. */
43static int full_duplex[MAX_UNITS];
44static int options[MAX_UNITS];
45
46/* Force a non std. amount of memory. Units are 256 byte pages. */
47/* #define PACKETBUF_MEMSIZE 0x40 */
48
49
50#include <linux/module.h>
51#include <linux/kernel.h>
52#include <linux/errno.h>
53#include <linux/pci.h>
54#include <linux/init.h>
55#include <linux/interrupt.h>
56#include <linux/ethtool.h>
57#include <linux/netdevice.h>
58#include <linux/etherdevice.h>
59
60#include <linux/io.h>
61#include <asm/irq.h>
62#include <linux/uaccess.h>
63
64#include "8390.h"
65
66static int ne2k_msg_enable;
67
68static const int default_msg_level = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
69 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR);
70
71#if defined(__powerpc__)
72#define inl_le(addr) le32_to_cpu(inl(addr))
73#define inw_le(addr) le16_to_cpu(inw(addr))
74#endif
75
76MODULE_AUTHOR(DRV_AUTHOR);
77MODULE_DESCRIPTION(DRV_DESCRIPTION);
78MODULE_VERSION(DRV_VERSION);
79MODULE_LICENSE("GPL");
80
81module_param_named(msg_enable, ne2k_msg_enable, int, 0444);
82module_param_array(options, int, NULL, 0);
83module_param_array(full_duplex, int, NULL, 0);
84MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
85MODULE_PARM_DESC(options, "Bit 5: full duplex");
86MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
87
88/* Some defines that people can play with if so inclined.
89 */
90
91/* Use 32 bit data-movement operations instead of 16 bit. */
92#define USE_LONGIO
93
94/* Do we implement the read before write bugfix ? */
95/* #define NE_RW_BUGFIX */
96
97/* Flags. We rename an existing ei_status field to store flags!
98 * Thus only the low 8 bits are usable for non-init-time flags.
99 */
100#define ne2k_flags reg0
101
102enum {
103 /* Chip can do only 16/32-bit xfers. */
104 ONLY_16BIT_IO = 8, ONLY_32BIT_IO = 4,
105 /* User override. */
106 FORCE_FDX = 0x20,
107 REALTEK_FDX = 0x40, HOLTEK_FDX = 0x80,
108 STOP_PG_0x60 = 0x100,
109};
110
111enum ne2k_pci_chipsets {
112 CH_RealTek_RTL_8029 = 0,
113 CH_Winbond_89C940,
114 CH_Compex_RL2000,
115 CH_KTI_ET32P2,
116 CH_NetVin_NV5000SC,
117 CH_Via_86C926,
118 CH_SureCom_NE34,
119 CH_Winbond_W89C940F,
120 CH_Holtek_HT80232,
121 CH_Holtek_HT80229,
122 CH_Winbond_89C940_8c4a,
123};
124
125
126static struct {
127 char *name;
128 int flags;
129} pci_clone_list[] = {
130 {"RealTek RTL-8029(AS)", REALTEK_FDX},
131 {"Winbond 89C940", 0},
132 {"Compex RL2000", 0},
133 {"KTI ET32P2", 0},
134 {"NetVin NV5000SC", 0},
135 {"Via 86C926", ONLY_16BIT_IO},
136 {"SureCom NE34", 0},
137 {"Winbond W89C940F", 0},
138 {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
139 {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
140 {"Winbond W89C940(misprogrammed)", 0},
141 {NULL,}
142};
143
144
145static const struct pci_device_id ne2k_pci_tbl[] = {
146 { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
147 { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
148 { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
149 { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
150 { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
151 { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
152 { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
153 { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
154 { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
155 { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
156 { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
157 { 0, }
158};
159
160MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
161
162
163/* ---- No user-serviceable parts below ---- */
164
165#define NE_BASE (dev->base_addr)
166#define NE_CMD 0x00
167#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
168#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
169#define NE_IO_EXTENT 0x20
170
171#define NESM_START_PG 0x40 /* First page of TX buffer */
172#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
173
174
175static int ne2k_pci_open(struct net_device *dev);
176static int ne2k_pci_close(struct net_device *dev);
177
178static void ne2k_pci_reset_8390(struct net_device *dev);
179static void ne2k_pci_get_8390_hdr(struct net_device *dev,
180 struct e8390_pkt_hdr *hdr, int ring_page);
181static void ne2k_pci_block_input(struct net_device *dev, int count,
182 struct sk_buff *skb, int ring_offset);
183static void ne2k_pci_block_output(struct net_device *dev, const int count,
184 const unsigned char *buf,
185 const int start_page);
186static const struct ethtool_ops ne2k_pci_ethtool_ops;
187
188
189
190/* There is no room in the standard 8390 structure for extra info we need,
191 * so we build a meta/outer-wrapper structure..
192 */
193struct ne2k_pci_card {
194 struct net_device *dev;
195 struct pci_dev *pci_dev;
196};
197
198
199
200/* NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
201 * buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
202 * 0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
203 * detected by their SA prefix.
204 *
205 * Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
206 * mode results in doubled values, which can be detected and compensated for.
207 *
208 * The probe is also responsible for initializing the card and filling
209 * in the 'dev' and 'ei_status' structures.
210 */
211
212static const struct net_device_ops ne2k_netdev_ops = {
213 .ndo_open = ne2k_pci_open,
214 .ndo_stop = ne2k_pci_close,
215 .ndo_start_xmit = ei_start_xmit,
216 .ndo_tx_timeout = ei_tx_timeout,
217 .ndo_get_stats = ei_get_stats,
218 .ndo_set_rx_mode = ei_set_multicast_list,
219 .ndo_validate_addr = eth_validate_addr,
220 .ndo_set_mac_address = eth_mac_addr,
221#ifdef CONFIG_NET_POLL_CONTROLLER
222 .ndo_poll_controller = ei_poll,
223#endif
224};
225
226static int ne2k_pci_init_one(struct pci_dev *pdev,
227 const struct pci_device_id *ent)
228{
229 struct net_device *dev;
230 int i;
231 unsigned char SA_prom[32];
232 int start_page, stop_page;
233 int irq, reg0, chip_idx = ent->driver_data;
234 static unsigned int fnd_cnt;
235 long ioaddr;
236 int flags = pci_clone_list[chip_idx].flags;
237 struct ei_device *ei_local;
238
239 fnd_cnt++;
240
241 i = pci_enable_device(pdev);
242 if (i)
243 return i;
244
245 ioaddr = pci_resource_start(pdev, 0);
246 irq = pdev->irq;
247
248 if (!ioaddr || ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) == 0)) {
249 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
250 goto err_out;
251 }
252
253 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME)) {
254 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
255 NE_IO_EXTENT, ioaddr);
256 goto err_out;
257 }
258
259 reg0 = inb(ioaddr);
260 if (reg0 == 0xFF)
261 goto err_out_free_res;
262
263 /* Do a preliminary verification that we have a 8390. */
264 {
265 int regd;
266
267 outb(E8390_NODMA + E8390_PAGE1 + E8390_STOP, ioaddr + E8390_CMD);
268 regd = inb(ioaddr + 0x0d);
269 outb(0xff, ioaddr + 0x0d);
270 outb(E8390_NODMA + E8390_PAGE0, ioaddr + E8390_CMD);
271 /* Clear the counter by reading. */
272 inb(ioaddr + EN0_COUNTER0);
273 if (inb(ioaddr + EN0_COUNTER0) != 0) {
274 outb(reg0, ioaddr);
275 /* Restore the old values. */
276 outb(regd, ioaddr + 0x0d);
277 goto err_out_free_res;
278 }
279 }
280
281 /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
282 dev = alloc_ei_netdev();
283 if (!dev) {
284 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
285 goto err_out_free_res;
286 }
287 dev->netdev_ops = &ne2k_netdev_ops;
288 ei_local = netdev_priv(dev);
289 ei_local->msg_enable = netif_msg_init(ne2k_msg_enable, default_msg_level);
290
291 SET_NETDEV_DEV(dev, &pdev->dev);
292
293 /* Reset card. Who knows what dain-bramaged state it was left in. */
294 {
295 unsigned long reset_start_time = jiffies;
296
297 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
298
299 /* This looks like a horrible timing loop, but it should never
300 * take more than a few cycles.
301 */
302 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
303 /* Limit wait: '2' avoids jiffy roll-over. */
304 if (jiffies - reset_start_time > 2) {
305 dev_err(&pdev->dev,
306 "Card failure (no reset ack).\n");
307 goto err_out_free_netdev;
308 }
309 /* Ack all intr. */
310 outb(0xff, ioaddr + EN0_ISR);
311 }
312
313 /* Read the 16 bytes of station address PROM.
314 * We must first initialize registers, similar
315 * to NS8390_init(eifdev, 0).
316 * We can't reliably read the SAPROM address without this.
317 * (I learned the hard way!).
318 */
319 {
320 struct {unsigned char value, offset; } program_seq[] = {
321 /* Select page 0 */
322 {E8390_NODMA + E8390_PAGE0 + E8390_STOP, E8390_CMD},
323 /* Set word-wide access */
324 {0x49, EN0_DCFG},
325 /* Clear the count regs. */
326 {0x00, EN0_RCNTLO},
327 /* Mask completion IRQ */
328 {0x00, EN0_RCNTHI},
329 {0x00, EN0_IMR},
330 {0xFF, EN0_ISR},
331 /* 0x20 Set to monitor */
332 {E8390_RXOFF, EN0_RXCR},
333 /* 0x02 and loopback mode */
334 {E8390_TXOFF, EN0_TXCR},
335 {32, EN0_RCNTLO},
336 {0x00, EN0_RCNTHI},
337 /* DMA starting at 0x0000 */
338 {0x00, EN0_RSARLO},
339 {0x00, EN0_RSARHI},
340 {E8390_RREAD+E8390_START, E8390_CMD},
341 };
342 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
343 outb(program_seq[i].value,
344 ioaddr + program_seq[i].offset);
345
346 }
347
348 /* Note: all PCI cards have at least 16 bit access, so we don't have
349 * to check for 8 bit cards. Most cards permit 32 bit access.
350 */
351 if (flags & ONLY_32BIT_IO) {
352 for (i = 0; i < 4 ; i++)
353 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
354 } else
355 for (i = 0; i < 32 /* sizeof(SA_prom )*/; i++)
356 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
357
358 /* We always set the 8390 registers for word mode. */
359 outb(0x49, ioaddr + EN0_DCFG);
360 start_page = NESM_START_PG;
361
362 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
363
364 /* Set up the rest of the parameters. */
365 dev->irq = irq;
366 dev->base_addr = ioaddr;
367 pci_set_drvdata(pdev, dev);
368
369 ei_status.name = pci_clone_list[chip_idx].name;
370 ei_status.tx_start_page = start_page;
371 ei_status.stop_page = stop_page;
372 ei_status.word16 = 1;
373 ei_status.ne2k_flags = flags;
374 if (fnd_cnt < MAX_UNITS) {
375 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
376 ei_status.ne2k_flags |= FORCE_FDX;
377 }
378
379 ei_status.rx_start_page = start_page + TX_PAGES;
380#ifdef PACKETBUF_MEMSIZE
381 /* Allow the packet buffer size to be overridden by know-it-alls. */
382 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
383#endif
384
385 ei_status.reset_8390 = &ne2k_pci_reset_8390;
386 ei_status.block_input = &ne2k_pci_block_input;
387 ei_status.block_output = &ne2k_pci_block_output;
388 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
389 ei_status.priv = (unsigned long) pdev;
390
391 dev->ethtool_ops = &ne2k_pci_ethtool_ops;
392 NS8390_init(dev, 0);
393
394 eth_hw_addr_set(dev, SA_prom);
395
396 i = register_netdev(dev);
397 if (i)
398 goto err_out_free_netdev;
399
400 netdev_info(dev, "%s found at %#lx, IRQ %d, %pM.\n",
401 pci_clone_list[chip_idx].name, ioaddr, dev->irq,
402 dev->dev_addr);
403
404 return 0;
405
406err_out_free_netdev:
407 free_netdev(dev);
408err_out_free_res:
409 release_region(ioaddr, NE_IO_EXTENT);
410err_out:
411 pci_disable_device(pdev);
412 return -ENODEV;
413}
414
415/* Magic incantation sequence for full duplex on the supported cards.
416 */
417static inline int set_realtek_fdx(struct net_device *dev)
418{
419 long ioaddr = dev->base_addr;
420
421 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
422 outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
423 outb(0x40, ioaddr + 0x06); /* Enable full duplex */
424 outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
425 outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
426 return 0;
427}
428
429static inline int set_holtek_fdx(struct net_device *dev)
430{
431 long ioaddr = dev->base_addr;
432
433 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
434 return 0;
435}
436
437static int ne2k_pci_set_fdx(struct net_device *dev)
438{
439 if (ei_status.ne2k_flags & REALTEK_FDX)
440 return set_realtek_fdx(dev);
441 else if (ei_status.ne2k_flags & HOLTEK_FDX)
442 return set_holtek_fdx(dev);
443
444 return -EOPNOTSUPP;
445}
446
447static int ne2k_pci_open(struct net_device *dev)
448{
449 int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED,
450 dev->name, dev);
451
452 if (ret)
453 return ret;
454
455 if (ei_status.ne2k_flags & FORCE_FDX)
456 ne2k_pci_set_fdx(dev);
457
458 ei_open(dev);
459 return 0;
460}
461
462static int ne2k_pci_close(struct net_device *dev)
463{
464 ei_close(dev);
465 free_irq(dev->irq, dev);
466 return 0;
467}
468
469/* Hard reset the card. This used to pause for the same period that a
470 * 8390 reset command required, but that shouldn't be necessary.
471 */
472static void ne2k_pci_reset_8390(struct net_device *dev)
473{
474 unsigned long reset_start_time = jiffies;
475 struct ei_device *ei_local = netdev_priv(dev);
476
477 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n",
478 jiffies);
479
480 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
481
482 ei_status.txing = 0;
483 ei_status.dmaing = 0;
484
485 /* This check _should_not_ be necessary, omit eventually. */
486 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
487 if (jiffies - reset_start_time > 2) {
488 netdev_err(dev, "%s did not complete.\n", __func__);
489 break;
490 }
491 /* Ack intr. */
492 outb(ENISR_RESET, NE_BASE + EN0_ISR);
493}
494
495/* Grab the 8390 specific header. Similar to the block_input routine, but
496 * we don't need to be concerned with ring wrap as the header will be at
497 * the start of a page, so we optimize accordingly.
498 */
499
500static void ne2k_pci_get_8390_hdr(struct net_device *dev,
501 struct e8390_pkt_hdr *hdr, int ring_page)
502{
503
504 long nic_base = dev->base_addr;
505
506 /* This *shouldn't* happen. If it does, it's the last thing you'll see
507 */
508 if (ei_status.dmaing) {
509 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d].\n",
510 __func__, ei_status.dmaing, ei_status.irqlock);
511 return;
512 }
513
514 ei_status.dmaing |= 0x01;
515 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
516 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
517 outb(0, nic_base + EN0_RCNTHI);
518 outb(0, nic_base + EN0_RSARLO); /* On page boundary */
519 outb(ring_page, nic_base + EN0_RSARHI);
520 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
521
522 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
523 insw(NE_BASE + NE_DATAPORT, hdr,
524 sizeof(struct e8390_pkt_hdr) >> 1);
525 } else {
526 *(u32 *)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
527 le16_to_cpus(&hdr->count);
528 }
529 /* Ack intr. */
530 outb(ENISR_RDC, nic_base + EN0_ISR);
531 ei_status.dmaing &= ~0x01;
532}
533
534/* Block input and output, similar to the Crynwr packet driver. If you
535 *are porting to a new ethercard, look at the packet driver source for hints.
536 *The NEx000 doesn't share the on-board packet memory -- you have to put
537 *the packet out through the "remote DMA" dataport using outb.
538 */
539
540static void ne2k_pci_block_input(struct net_device *dev, int count,
541 struct sk_buff *skb, int ring_offset)
542{
543 long nic_base = dev->base_addr;
544 char *buf = skb->data;
545
546 /* This *shouldn't* happen.
547 * If it does, it's the last thing you'll see.
548 */
549 if (ei_status.dmaing) {
550 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
551 __func__, ei_status.dmaing, ei_status.irqlock);
552 return;
553 }
554 ei_status.dmaing |= 0x01;
555 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
556 count = (count + 3) & 0xFFFC;
557 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
558 outb(count & 0xff, nic_base + EN0_RCNTLO);
559 outb(count >> 8, nic_base + EN0_RCNTHI);
560 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
561 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
562 outb(E8390_RREAD + E8390_START, nic_base + NE_CMD);
563
564 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
565 insw(NE_BASE + NE_DATAPORT, buf, count >> 1);
566 if (count & 0x01)
567 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
568 } else {
569 insl(NE_BASE + NE_DATAPORT, buf, count >> 2);
570 if (count & 3) {
571 buf += count & ~3;
572 if (count & 2) {
573 __le16 *b = (__le16 *)buf;
574
575 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
576 buf = (char *)b;
577 }
578 if (count & 1)
579 *buf = inb(NE_BASE + NE_DATAPORT);
580 }
581 }
582 /* Ack intr. */
583 outb(ENISR_RDC, nic_base + EN0_ISR);
584 ei_status.dmaing &= ~0x01;
585}
586
587static void ne2k_pci_block_output(struct net_device *dev, int count,
588 const unsigned char *buf, const int start_page)
589{
590 long nic_base = NE_BASE;
591 unsigned long dma_start;
592
593 /* On little-endian it's always safe to round the count up for
594 * word writes.
595 */
596 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
597 count = (count + 3) & 0xFFFC;
598 else
599 if (count & 0x01)
600 count++;
601
602 /* This *shouldn't* happen.
603 * If it does, it's the last thing you'll see.
604 */
605 if (ei_status.dmaing) {
606 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
607 __func__, ei_status.dmaing, ei_status.irqlock);
608 return;
609 }
610 ei_status.dmaing |= 0x01;
611 /* We should already be in page 0, but to be safe... */
612 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
613
614#ifdef NE_RW_BUGFIX
615 /* Handle the read-before-write bug the same way as the
616 * Crynwr packet driver -- the NatSemi method doesn't work.
617 * Actually this doesn't always work either, but if you have
618 * problems with your NEx000 this is better than nothing!
619 */
620 outb(0x42, nic_base + EN0_RCNTLO);
621 outb(0x00, nic_base + EN0_RCNTHI);
622 outb(0x42, nic_base + EN0_RSARLO);
623 outb(0x00, nic_base + EN0_RSARHI);
624 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
625#endif
626 outb(ENISR_RDC, nic_base + EN0_ISR);
627
628 /* Now the normal output. */
629 outb(count & 0xff, nic_base + EN0_RCNTLO);
630 outb(count >> 8, nic_base + EN0_RCNTHI);
631 outb(0x00, nic_base + EN0_RSARLO);
632 outb(start_page, nic_base + EN0_RSARHI);
633 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
634 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
635 outsw(NE_BASE + NE_DATAPORT, buf, count >> 1);
636 } else {
637 outsl(NE_BASE + NE_DATAPORT, buf, count >> 2);
638 if (count & 3) {
639 buf += count & ~3;
640 if (count & 2) {
641 __le16 *b = (__le16 *)buf;
642
643 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
644 buf = (char *)b;
645 }
646 }
647 }
648
649 dma_start = jiffies;
650
651 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
652 /* Avoid clock roll-over. */
653 if (jiffies - dma_start > 2) {
654 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
655 ne2k_pci_reset_8390(dev);
656 NS8390_init(dev, 1);
657 break;
658 }
659 /* Ack intr. */
660 outb(ENISR_RDC, nic_base + EN0_ISR);
661 ei_status.dmaing &= ~0x01;
662}
663
664static void ne2k_pci_get_drvinfo(struct net_device *dev,
665 struct ethtool_drvinfo *info)
666{
667 struct ei_device *ei = netdev_priv(dev);
668 struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
669
670 strscpy(info->driver, DRV_NAME, sizeof(info->driver));
671 strscpy(info->version, DRV_VERSION, sizeof(info->version));
672 strscpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
673}
674
675static u32 ne2k_pci_get_msglevel(struct net_device *dev)
676{
677 struct ei_device *ei_local = netdev_priv(dev);
678
679 return ei_local->msg_enable;
680}
681
682static void ne2k_pci_set_msglevel(struct net_device *dev, u32 v)
683{
684 struct ei_device *ei_local = netdev_priv(dev);
685
686 ei_local->msg_enable = v;
687}
688
689static const struct ethtool_ops ne2k_pci_ethtool_ops = {
690 .get_drvinfo = ne2k_pci_get_drvinfo,
691 .get_msglevel = ne2k_pci_get_msglevel,
692 .set_msglevel = ne2k_pci_set_msglevel,
693};
694
695static void ne2k_pci_remove_one(struct pci_dev *pdev)
696{
697 struct net_device *dev = pci_get_drvdata(pdev);
698
699 BUG_ON(!dev);
700 unregister_netdev(dev);
701 release_region(dev->base_addr, NE_IO_EXTENT);
702 free_netdev(dev);
703 pci_disable_device(pdev);
704}
705
706static int __maybe_unused ne2k_pci_suspend(struct device *dev_d)
707{
708 struct net_device *dev = dev_get_drvdata(dev_d);
709
710 netif_device_detach(dev);
711
712 return 0;
713}
714
715static int __maybe_unused ne2k_pci_resume(struct device *dev_d)
716{
717 struct net_device *dev = dev_get_drvdata(dev_d);
718
719 NS8390_init(dev, 1);
720 netif_device_attach(dev);
721
722 return 0;
723}
724
725static SIMPLE_DEV_PM_OPS(ne2k_pci_pm_ops, ne2k_pci_suspend, ne2k_pci_resume);
726
727static struct pci_driver ne2k_driver = {
728 .name = DRV_NAME,
729 .probe = ne2k_pci_init_one,
730 .remove = ne2k_pci_remove_one,
731 .id_table = ne2k_pci_tbl,
732 .driver.pm = &ne2k_pci_pm_ops,
733};
734module_pci_driver(ne2k_driver);
1/* A Linux device driver for PCI NE2000 clones.
2 *
3 * Authors and other copyright holders:
4 * 1992-2000 by Donald Becker, NE2000 core and various modifications.
5 * 1995-1998 by Paul Gortmaker, core modifications and PCI support.
6 * Copyright 1993 assigned to the United States Government as represented
7 * by the Director, National Security Agency.
8 *
9 * This software may be used and distributed according to the terms of
10 * the GNU General Public License (GPL), incorporated herein by reference.
11 * Drivers based on or derived from this code fall under the GPL and must
12 * retain the authorship, copyright and license notice. This file is not
13 * a complete program and may only be used when the entire operating
14 * system is licensed under the GPL.
15 *
16 * The author may be reached as becker@scyld.com, or C/O
17 * Scyld Computing Corporation
18 * 410 Severn Ave., Suite 210
19 * Annapolis MD 21403
20 *
21 * Issues remaining:
22 * People are making PCI NE2000 clones! Oh the horror, the horror...
23 * Limited full-duplex support.
24 */
25
26#define DRV_NAME "ne2k-pci"
27#define DRV_DESCRIPTION "PCI NE2000 clone driver"
28#define DRV_AUTHOR "Donald Becker / Paul Gortmaker"
29#define DRV_VERSION "1.03"
30#define DRV_RELDATE "9/22/2003"
31
32#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
33
34/* The user-configurable values.
35 * These may be modified when a driver module is loaded.
36 */
37
38/* More are supported, limit only on options */
39#define MAX_UNITS 8
40
41/* Used to pass the full-duplex flag, etc. */
42static int full_duplex[MAX_UNITS];
43static int options[MAX_UNITS];
44
45/* Force a non std. amount of memory. Units are 256 byte pages. */
46/* #define PACKETBUF_MEMSIZE 0x40 */
47
48
49#include <linux/module.h>
50#include <linux/kernel.h>
51#include <linux/errno.h>
52#include <linux/pci.h>
53#include <linux/init.h>
54#include <linux/interrupt.h>
55#include <linux/ethtool.h>
56#include <linux/netdevice.h>
57#include <linux/etherdevice.h>
58
59#include <linux/io.h>
60#include <asm/irq.h>
61#include <linux/uaccess.h>
62
63#include "8390.h"
64
65static int ne2k_msg_enable;
66
67static const int default_msg_level = (NETIF_MSG_DRV | NETIF_MSG_PROBE |
68 NETIF_MSG_RX_ERR | NETIF_MSG_TX_ERR);
69
70#if defined(__powerpc__)
71#define inl_le(addr) le32_to_cpu(inl(addr))
72#define inw_le(addr) le16_to_cpu(inw(addr))
73#endif
74
75MODULE_AUTHOR(DRV_AUTHOR);
76MODULE_DESCRIPTION(DRV_DESCRIPTION);
77MODULE_VERSION(DRV_VERSION);
78MODULE_LICENSE("GPL");
79
80module_param_named(msg_enable, ne2k_msg_enable, int, 0444);
81module_param_array(options, int, NULL, 0);
82module_param_array(full_duplex, int, NULL, 0);
83MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
84MODULE_PARM_DESC(options, "Bit 5: full duplex");
85MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)");
86
87/* Some defines that people can play with if so inclined.
88 */
89
90/* Use 32 bit data-movement operations instead of 16 bit. */
91#define USE_LONGIO
92
93/* Do we implement the read before write bugfix ? */
94/* #define NE_RW_BUGFIX */
95
96/* Flags. We rename an existing ei_status field to store flags!
97 * Thus only the low 8 bits are usable for non-init-time flags.
98 */
99#define ne2k_flags reg0
100
101enum {
102 /* Chip can do only 16/32-bit xfers. */
103 ONLY_16BIT_IO = 8, ONLY_32BIT_IO = 4,
104 /* User override. */
105 FORCE_FDX = 0x20,
106 REALTEK_FDX = 0x40, HOLTEK_FDX = 0x80,
107 STOP_PG_0x60 = 0x100,
108};
109
110enum ne2k_pci_chipsets {
111 CH_RealTek_RTL_8029 = 0,
112 CH_Winbond_89C940,
113 CH_Compex_RL2000,
114 CH_KTI_ET32P2,
115 CH_NetVin_NV5000SC,
116 CH_Via_86C926,
117 CH_SureCom_NE34,
118 CH_Winbond_W89C940F,
119 CH_Holtek_HT80232,
120 CH_Holtek_HT80229,
121 CH_Winbond_89C940_8c4a,
122};
123
124
125static struct {
126 char *name;
127 int flags;
128} pci_clone_list[] = {
129 {"RealTek RTL-8029(AS)", REALTEK_FDX},
130 {"Winbond 89C940", 0},
131 {"Compex RL2000", 0},
132 {"KTI ET32P2", 0},
133 {"NetVin NV5000SC", 0},
134 {"Via 86C926", ONLY_16BIT_IO},
135 {"SureCom NE34", 0},
136 {"Winbond W89C940F", 0},
137 {"Holtek HT80232", ONLY_16BIT_IO | HOLTEK_FDX},
138 {"Holtek HT80229", ONLY_32BIT_IO | HOLTEK_FDX | STOP_PG_0x60 },
139 {"Winbond W89C940(misprogrammed)", 0},
140 {NULL,}
141};
142
143
144static const struct pci_device_id ne2k_pci_tbl[] = {
145 { 0x10ec, 0x8029, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_RealTek_RTL_8029 },
146 { 0x1050, 0x0940, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940 },
147 { 0x11f6, 0x1401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Compex_RL2000 },
148 { 0x8e2e, 0x3000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_KTI_ET32P2 },
149 { 0x4a14, 0x5000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_NetVin_NV5000SC },
150 { 0x1106, 0x0926, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Via_86C926 },
151 { 0x10bd, 0x0e34, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_SureCom_NE34 },
152 { 0x1050, 0x5a5a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_W89C940F },
153 { 0x12c3, 0x0058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80232 },
154 { 0x12c3, 0x5598, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Holtek_HT80229 },
155 { 0x8c4a, 0x1980, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_Winbond_89C940_8c4a },
156 { 0, }
157};
158
159MODULE_DEVICE_TABLE(pci, ne2k_pci_tbl);
160
161
162/* ---- No user-serviceable parts below ---- */
163
164#define NE_BASE (dev->base_addr)
165#define NE_CMD 0x00
166#define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
167#define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
168#define NE_IO_EXTENT 0x20
169
170#define NESM_START_PG 0x40 /* First page of TX buffer */
171#define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
172
173
174static int ne2k_pci_open(struct net_device *dev);
175static int ne2k_pci_close(struct net_device *dev);
176
177static void ne2k_pci_reset_8390(struct net_device *dev);
178static void ne2k_pci_get_8390_hdr(struct net_device *dev,
179 struct e8390_pkt_hdr *hdr, int ring_page);
180static void ne2k_pci_block_input(struct net_device *dev, int count,
181 struct sk_buff *skb, int ring_offset);
182static void ne2k_pci_block_output(struct net_device *dev, const int count,
183 const unsigned char *buf,
184 const int start_page);
185static const struct ethtool_ops ne2k_pci_ethtool_ops;
186
187
188
189/* There is no room in the standard 8390 structure for extra info we need,
190 * so we build a meta/outer-wrapper structure..
191 */
192struct ne2k_pci_card {
193 struct net_device *dev;
194 struct pci_dev *pci_dev;
195};
196
197
198
199/* NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
200 * buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
201 * 0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
202 * detected by their SA prefix.
203 *
204 * Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
205 * mode results in doubled values, which can be detected and compensated for.
206 *
207 * The probe is also responsible for initializing the card and filling
208 * in the 'dev' and 'ei_status' structures.
209 */
210
211static const struct net_device_ops ne2k_netdev_ops = {
212 .ndo_open = ne2k_pci_open,
213 .ndo_stop = ne2k_pci_close,
214 .ndo_start_xmit = ei_start_xmit,
215 .ndo_tx_timeout = ei_tx_timeout,
216 .ndo_get_stats = ei_get_stats,
217 .ndo_set_rx_mode = ei_set_multicast_list,
218 .ndo_validate_addr = eth_validate_addr,
219 .ndo_set_mac_address = eth_mac_addr,
220#ifdef CONFIG_NET_POLL_CONTROLLER
221 .ndo_poll_controller = ei_poll,
222#endif
223};
224
225static int ne2k_pci_init_one(struct pci_dev *pdev,
226 const struct pci_device_id *ent)
227{
228 struct net_device *dev;
229 int i;
230 unsigned char SA_prom[32];
231 int start_page, stop_page;
232 int irq, reg0, chip_idx = ent->driver_data;
233 static unsigned int fnd_cnt;
234 long ioaddr;
235 int flags = pci_clone_list[chip_idx].flags;
236 struct ei_device *ei_local;
237
238 fnd_cnt++;
239
240 i = pci_enable_device(pdev);
241 if (i)
242 return i;
243
244 ioaddr = pci_resource_start(pdev, 0);
245 irq = pdev->irq;
246
247 if (!ioaddr || ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) == 0)) {
248 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
249 goto err_out;
250 }
251
252 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME)) {
253 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
254 NE_IO_EXTENT, ioaddr);
255 goto err_out;
256 }
257
258 reg0 = inb(ioaddr);
259 if (reg0 == 0xFF)
260 goto err_out_free_res;
261
262 /* Do a preliminary verification that we have a 8390. */
263 {
264 int regd;
265
266 outb(E8390_NODMA + E8390_PAGE1 + E8390_STOP, ioaddr + E8390_CMD);
267 regd = inb(ioaddr + 0x0d);
268 outb(0xff, ioaddr + 0x0d);
269 outb(E8390_NODMA + E8390_PAGE0, ioaddr + E8390_CMD);
270 /* Clear the counter by reading. */
271 inb(ioaddr + EN0_COUNTER0);
272 if (inb(ioaddr + EN0_COUNTER0) != 0) {
273 outb(reg0, ioaddr);
274 /* Restore the old values. */
275 outb(regd, ioaddr + 0x0d);
276 goto err_out_free_res;
277 }
278 }
279
280 /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
281 dev = alloc_ei_netdev();
282 if (!dev) {
283 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
284 goto err_out_free_res;
285 }
286 dev->netdev_ops = &ne2k_netdev_ops;
287 ei_local = netdev_priv(dev);
288 ei_local->msg_enable = netif_msg_init(ne2k_msg_enable, default_msg_level);
289
290 SET_NETDEV_DEV(dev, &pdev->dev);
291
292 /* Reset card. Who knows what dain-bramaged state it was left in. */
293 {
294 unsigned long reset_start_time = jiffies;
295
296 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
297
298 /* This looks like a horrible timing loop, but it should never
299 * take more than a few cycles.
300 */
301 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
302 /* Limit wait: '2' avoids jiffy roll-over. */
303 if (jiffies - reset_start_time > 2) {
304 dev_err(&pdev->dev,
305 "Card failure (no reset ack).\n");
306 goto err_out_free_netdev;
307 }
308 /* Ack all intr. */
309 outb(0xff, ioaddr + EN0_ISR);
310 }
311
312 /* Read the 16 bytes of station address PROM.
313 * We must first initialize registers, similar
314 * to NS8390_init(eifdev, 0).
315 * We can't reliably read the SAPROM address without this.
316 * (I learned the hard way!).
317 */
318 {
319 struct {unsigned char value, offset; } program_seq[] = {
320 /* Select page 0 */
321 {E8390_NODMA + E8390_PAGE0 + E8390_STOP, E8390_CMD},
322 /* Set word-wide access */
323 {0x49, EN0_DCFG},
324 /* Clear the count regs. */
325 {0x00, EN0_RCNTLO},
326 /* Mask completion IRQ */
327 {0x00, EN0_RCNTHI},
328 {0x00, EN0_IMR},
329 {0xFF, EN0_ISR},
330 /* 0x20 Set to monitor */
331 {E8390_RXOFF, EN0_RXCR},
332 /* 0x02 and loopback mode */
333 {E8390_TXOFF, EN0_TXCR},
334 {32, EN0_RCNTLO},
335 {0x00, EN0_RCNTHI},
336 /* DMA starting at 0x0000 */
337 {0x00, EN0_RSARLO},
338 {0x00, EN0_RSARHI},
339 {E8390_RREAD+E8390_START, E8390_CMD},
340 };
341 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
342 outb(program_seq[i].value,
343 ioaddr + program_seq[i].offset);
344
345 }
346
347 /* Note: all PCI cards have at least 16 bit access, so we don't have
348 * to check for 8 bit cards. Most cards permit 32 bit access.
349 */
350 if (flags & ONLY_32BIT_IO) {
351 for (i = 0; i < 4 ; i++)
352 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
353 } else
354 for (i = 0; i < 32 /* sizeof(SA_prom )*/; i++)
355 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
356
357 /* We always set the 8390 registers for word mode. */
358 outb(0x49, ioaddr + EN0_DCFG);
359 start_page = NESM_START_PG;
360
361 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
362
363 /* Set up the rest of the parameters. */
364 dev->irq = irq;
365 dev->base_addr = ioaddr;
366 pci_set_drvdata(pdev, dev);
367
368 ei_status.name = pci_clone_list[chip_idx].name;
369 ei_status.tx_start_page = start_page;
370 ei_status.stop_page = stop_page;
371 ei_status.word16 = 1;
372 ei_status.ne2k_flags = flags;
373 if (fnd_cnt < MAX_UNITS) {
374 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
375 ei_status.ne2k_flags |= FORCE_FDX;
376 }
377
378 ei_status.rx_start_page = start_page + TX_PAGES;
379#ifdef PACKETBUF_MEMSIZE
380 /* Allow the packet buffer size to be overridden by know-it-alls. */
381 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
382#endif
383
384 ei_status.reset_8390 = &ne2k_pci_reset_8390;
385 ei_status.block_input = &ne2k_pci_block_input;
386 ei_status.block_output = &ne2k_pci_block_output;
387 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
388 ei_status.priv = (unsigned long) pdev;
389
390 dev->ethtool_ops = &ne2k_pci_ethtool_ops;
391 NS8390_init(dev, 0);
392
393 memcpy(dev->dev_addr, SA_prom, dev->addr_len);
394
395 i = register_netdev(dev);
396 if (i)
397 goto err_out_free_netdev;
398
399 netdev_info(dev, "%s found at %#lx, IRQ %d, %pM.\n",
400 pci_clone_list[chip_idx].name, ioaddr, dev->irq,
401 dev->dev_addr);
402
403 return 0;
404
405err_out_free_netdev:
406 free_netdev(dev);
407err_out_free_res:
408 release_region(ioaddr, NE_IO_EXTENT);
409err_out:
410 pci_disable_device(pdev);
411 return -ENODEV;
412}
413
414/* Magic incantation sequence for full duplex on the supported cards.
415 */
416static inline int set_realtek_fdx(struct net_device *dev)
417{
418 long ioaddr = dev->base_addr;
419
420 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
421 outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
422 outb(0x40, ioaddr + 0x06); /* Enable full duplex */
423 outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
424 outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
425 return 0;
426}
427
428static inline int set_holtek_fdx(struct net_device *dev)
429{
430 long ioaddr = dev->base_addr;
431
432 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
433 return 0;
434}
435
436static int ne2k_pci_set_fdx(struct net_device *dev)
437{
438 if (ei_status.ne2k_flags & REALTEK_FDX)
439 return set_realtek_fdx(dev);
440 else if (ei_status.ne2k_flags & HOLTEK_FDX)
441 return set_holtek_fdx(dev);
442
443 return -EOPNOTSUPP;
444}
445
446static int ne2k_pci_open(struct net_device *dev)
447{
448 int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED,
449 dev->name, dev);
450
451 if (ret)
452 return ret;
453
454 if (ei_status.ne2k_flags & FORCE_FDX)
455 ne2k_pci_set_fdx(dev);
456
457 ei_open(dev);
458 return 0;
459}
460
461static int ne2k_pci_close(struct net_device *dev)
462{
463 ei_close(dev);
464 free_irq(dev->irq, dev);
465 return 0;
466}
467
468/* Hard reset the card. This used to pause for the same period that a
469 * 8390 reset command required, but that shouldn't be necessary.
470 */
471static void ne2k_pci_reset_8390(struct net_device *dev)
472{
473 unsigned long reset_start_time = jiffies;
474 struct ei_device *ei_local = netdev_priv(dev);
475
476 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n",
477 jiffies);
478
479 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
480
481 ei_status.txing = 0;
482 ei_status.dmaing = 0;
483
484 /* This check _should_not_ be necessary, omit eventually. */
485 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
486 if (jiffies - reset_start_time > 2) {
487 netdev_err(dev, "%s did not complete.\n", __func__);
488 break;
489 }
490 /* Ack intr. */
491 outb(ENISR_RESET, NE_BASE + EN0_ISR);
492}
493
494/* Grab the 8390 specific header. Similar to the block_input routine, but
495 * we don't need to be concerned with ring wrap as the header will be at
496 * the start of a page, so we optimize accordingly.
497 */
498
499static void ne2k_pci_get_8390_hdr(struct net_device *dev,
500 struct e8390_pkt_hdr *hdr, int ring_page)
501{
502
503 long nic_base = dev->base_addr;
504
505 /* This *shouldn't* happen. If it does, it's the last thing you'll see
506 */
507 if (ei_status.dmaing) {
508 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d].\n",
509 __func__, ei_status.dmaing, ei_status.irqlock);
510 return;
511 }
512
513 ei_status.dmaing |= 0x01;
514 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
515 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
516 outb(0, nic_base + EN0_RCNTHI);
517 outb(0, nic_base + EN0_RSARLO); /* On page boundary */
518 outb(ring_page, nic_base + EN0_RSARHI);
519 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
520
521 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
522 insw(NE_BASE + NE_DATAPORT, hdr,
523 sizeof(struct e8390_pkt_hdr) >> 1);
524 } else {
525 *(u32 *)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
526 le16_to_cpus(&hdr->count);
527 }
528 /* Ack intr. */
529 outb(ENISR_RDC, nic_base + EN0_ISR);
530 ei_status.dmaing &= ~0x01;
531}
532
533/* Block input and output, similar to the Crynwr packet driver. If you
534 *are porting to a new ethercard, look at the packet driver source for hints.
535 *The NEx000 doesn't share the on-board packet memory -- you have to put
536 *the packet out through the "remote DMA" dataport using outb.
537 */
538
539static void ne2k_pci_block_input(struct net_device *dev, int count,
540 struct sk_buff *skb, int ring_offset)
541{
542 long nic_base = dev->base_addr;
543 char *buf = skb->data;
544
545 /* This *shouldn't* happen.
546 * If it does, it's the last thing you'll see.
547 */
548 if (ei_status.dmaing) {
549 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
550 __func__, ei_status.dmaing, ei_status.irqlock);
551 return;
552 }
553 ei_status.dmaing |= 0x01;
554 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
555 count = (count + 3) & 0xFFFC;
556 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
557 outb(count & 0xff, nic_base + EN0_RCNTLO);
558 outb(count >> 8, nic_base + EN0_RCNTHI);
559 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
560 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
561 outb(E8390_RREAD + E8390_START, nic_base + NE_CMD);
562
563 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
564 insw(NE_BASE + NE_DATAPORT, buf, count >> 1);
565 if (count & 0x01)
566 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
567 } else {
568 insl(NE_BASE + NE_DATAPORT, buf, count >> 2);
569 if (count & 3) {
570 buf += count & ~3;
571 if (count & 2) {
572 __le16 *b = (__le16 *)buf;
573
574 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
575 buf = (char *)b;
576 }
577 if (count & 1)
578 *buf = inb(NE_BASE + NE_DATAPORT);
579 }
580 }
581 /* Ack intr. */
582 outb(ENISR_RDC, nic_base + EN0_ISR);
583 ei_status.dmaing &= ~0x01;
584}
585
586static void ne2k_pci_block_output(struct net_device *dev, int count,
587 const unsigned char *buf, const int start_page)
588{
589 long nic_base = NE_BASE;
590 unsigned long dma_start;
591
592 /* On little-endian it's always safe to round the count up for
593 * word writes.
594 */
595 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
596 count = (count + 3) & 0xFFFC;
597 else
598 if (count & 0x01)
599 count++;
600
601 /* This *shouldn't* happen.
602 * If it does, it's the last thing you'll see.
603 */
604 if (ei_status.dmaing) {
605 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
606 __func__, ei_status.dmaing, ei_status.irqlock);
607 return;
608 }
609 ei_status.dmaing |= 0x01;
610 /* We should already be in page 0, but to be safe... */
611 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
612
613#ifdef NE8390_RW_BUGFIX
614 /* Handle the read-before-write bug the same way as the
615 * Crynwr packet driver -- the NatSemi method doesn't work.
616 * Actually this doesn't always work either, but if you have
617 * problems with your NEx000 this is better than nothing!
618 */
619 outb(0x42, nic_base + EN0_RCNTLO);
620 outb(0x00, nic_base + EN0_RCNTHI);
621 outb(0x42, nic_base + EN0_RSARLO);
622 outb(0x00, nic_base + EN0_RSARHI);
623 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
624#endif
625 outb(ENISR_RDC, nic_base + EN0_ISR);
626
627 /* Now the normal output. */
628 outb(count & 0xff, nic_base + EN0_RCNTLO);
629 outb(count >> 8, nic_base + EN0_RCNTHI);
630 outb(0x00, nic_base + EN0_RSARLO);
631 outb(start_page, nic_base + EN0_RSARHI);
632 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
633 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
634 outsw(NE_BASE + NE_DATAPORT, buf, count >> 1);
635 } else {
636 outsl(NE_BASE + NE_DATAPORT, buf, count >> 2);
637 if (count & 3) {
638 buf += count & ~3;
639 if (count & 2) {
640 __le16 *b = (__le16 *)buf;
641
642 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
643 buf = (char *)b;
644 }
645 }
646 }
647
648 dma_start = jiffies;
649
650 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
651 /* Avoid clock roll-over. */
652 if (jiffies - dma_start > 2) {
653 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
654 ne2k_pci_reset_8390(dev);
655 NS8390_init(dev, 1);
656 break;
657 }
658 /* Ack intr. */
659 outb(ENISR_RDC, nic_base + EN0_ISR);
660 ei_status.dmaing &= ~0x01;
661}
662
663static void ne2k_pci_get_drvinfo(struct net_device *dev,
664 struct ethtool_drvinfo *info)
665{
666 struct ei_device *ei = netdev_priv(dev);
667 struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
668
669 strscpy(info->driver, DRV_NAME, sizeof(info->driver));
670 strscpy(info->version, DRV_VERSION, sizeof(info->version));
671 strscpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
672}
673
674static u32 ne2k_pci_get_msglevel(struct net_device *dev)
675{
676 struct ei_device *ei_local = netdev_priv(dev);
677
678 return ei_local->msg_enable;
679}
680
681static void ne2k_pci_set_msglevel(struct net_device *dev, u32 v)
682{
683 struct ei_device *ei_local = netdev_priv(dev);
684
685 ei_local->msg_enable = v;
686}
687
688static const struct ethtool_ops ne2k_pci_ethtool_ops = {
689 .get_drvinfo = ne2k_pci_get_drvinfo,
690 .get_msglevel = ne2k_pci_get_msglevel,
691 .set_msglevel = ne2k_pci_set_msglevel,
692};
693
694static void ne2k_pci_remove_one(struct pci_dev *pdev)
695{
696 struct net_device *dev = pci_get_drvdata(pdev);
697
698 BUG_ON(!dev);
699 unregister_netdev(dev);
700 release_region(dev->base_addr, NE_IO_EXTENT);
701 free_netdev(dev);
702 pci_disable_device(pdev);
703}
704
705static int __maybe_unused ne2k_pci_suspend(struct device *dev_d)
706{
707 struct net_device *dev = dev_get_drvdata(dev_d);
708
709 netif_device_detach(dev);
710
711 return 0;
712}
713
714static int __maybe_unused ne2k_pci_resume(struct device *dev_d)
715{
716 struct net_device *dev = dev_get_drvdata(dev_d);
717
718 NS8390_init(dev, 1);
719 netif_device_attach(dev);
720
721 return 0;
722}
723
724static SIMPLE_DEV_PM_OPS(ne2k_pci_pm_ops, ne2k_pci_suspend, ne2k_pci_resume);
725
726static struct pci_driver ne2k_driver = {
727 .name = DRV_NAME,
728 .probe = ne2k_pci_init_one,
729 .remove = ne2k_pci_remove_one,
730 .id_table = ne2k_pci_tbl,
731 .driver.pm = &ne2k_pci_pm_ops,
732};
733
734
735static int __init ne2k_pci_init(void)
736{
737 return pci_register_driver(&ne2k_driver);
738}
739
740
741static void __exit ne2k_pci_cleanup(void)
742{
743 pci_unregister_driver(&ne2k_driver);
744}
745
746module_init(ne2k_pci_init);
747module_exit(ne2k_pci_cleanup);