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. */
43 static int full_duplex[MAX_UNITS];
44 static 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
66 static int ne2k_msg_enable;
67
68 static 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
76 MODULE_AUTHOR(DRV_AUTHOR);
77 MODULE_DESCRIPTION(DRV_DESCRIPTION);
78 MODULE_VERSION(DRV_VERSION);
79 MODULE_LICENSE("GPL");
80
81 module_param_named(msg_enable, ne2k_msg_enable, int, 0444);
82 module_param_array(options, int, NULL, 0);
83 module_param_array(full_duplex, int, NULL, 0);
84 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
85 MODULE_PARM_DESC(options, "Bit 5: full duplex");
86 MODULE_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
102 enum {
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
111 enum 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
126 static 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
145 static 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
160 MODULE_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
175 static int ne2k_pci_open(struct net_device *dev);
176 static int ne2k_pci_close(struct net_device *dev);
177
178 static void ne2k_pci_reset_8390(struct net_device *dev);
179 static void ne2k_pci_get_8390_hdr(struct net_device *dev,
180 struct e8390_pkt_hdr *hdr, int ring_page);
181 static void ne2k_pci_block_input(struct net_device *dev, int count,
182 struct sk_buff *skb, int ring_offset);
183 static void ne2k_pci_block_output(struct net_device *dev, const int count,
184 const unsigned char *buf,
185 const int start_page);
186 static const struct ethtool_ops ne2k_pci_ethtool_ops;
187
188
189 /* NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
190 * buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
191 * 0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
192 * detected by their SA prefix.
193 *
194 * Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
195 * mode results in doubled values, which can be detected and compensated for.
196 *
197 * The probe is also responsible for initializing the card and filling
198 * in the 'dev' and 'ei_status' structures.
199 */
200
201 static const struct net_device_ops ne2k_netdev_ops = {
202 .ndo_open = ne2k_pci_open,
203 .ndo_stop = ne2k_pci_close,
204 .ndo_start_xmit = ei_start_xmit,
205 .ndo_tx_timeout = ei_tx_timeout,
206 .ndo_get_stats = ei_get_stats,
207 .ndo_set_rx_mode = ei_set_multicast_list,
208 .ndo_validate_addr = eth_validate_addr,
209 .ndo_set_mac_address = eth_mac_addr,
210 #ifdef CONFIG_NET_POLL_CONTROLLER
211 .ndo_poll_controller = ei_poll,
212 #endif
213 };
214
ne2k_pci_init_one(struct pci_dev * pdev,const struct pci_device_id * ent)215 static int ne2k_pci_init_one(struct pci_dev *pdev,
216 const struct pci_device_id *ent)
217 {
218 struct net_device *dev;
219 int i;
220 unsigned char SA_prom[32];
221 int start_page, stop_page;
222 int irq, reg0, chip_idx = ent->driver_data;
223 static unsigned int fnd_cnt;
224 long ioaddr;
225 int flags = pci_clone_list[chip_idx].flags;
226 struct ei_device *ei_local;
227
228 fnd_cnt++;
229
230 i = pci_enable_device(pdev);
231 if (i)
232 return i;
233
234 ioaddr = pci_resource_start(pdev, 0);
235 irq = pdev->irq;
236
237 if (!ioaddr || ((pci_resource_flags(pdev, 0) & IORESOURCE_IO) == 0)) {
238 dev_err(&pdev->dev, "no I/O resource at PCI BAR #0\n");
239 goto err_out;
240 }
241
242 if (!request_region(ioaddr, NE_IO_EXTENT, DRV_NAME)) {
243 dev_err(&pdev->dev, "I/O resource 0x%x @ 0x%lx busy\n",
244 NE_IO_EXTENT, ioaddr);
245 goto err_out;
246 }
247
248 reg0 = inb(ioaddr);
249 if (reg0 == 0xFF)
250 goto err_out_free_res;
251
252 /* Do a preliminary verification that we have a 8390. */
253 {
254 int regd;
255
256 outb(E8390_NODMA + E8390_PAGE1 + E8390_STOP, ioaddr + E8390_CMD);
257 regd = inb(ioaddr + 0x0d);
258 outb(0xff, ioaddr + 0x0d);
259 outb(E8390_NODMA + E8390_PAGE0, ioaddr + E8390_CMD);
260 /* Clear the counter by reading. */
261 inb(ioaddr + EN0_COUNTER0);
262 if (inb(ioaddr + EN0_COUNTER0) != 0) {
263 outb(reg0, ioaddr);
264 /* Restore the old values. */
265 outb(regd, ioaddr + 0x0d);
266 goto err_out_free_res;
267 }
268 }
269
270 /* Allocate net_device, dev->priv; fill in 8390 specific dev fields. */
271 dev = alloc_ei_netdev();
272 if (!dev) {
273 dev_err(&pdev->dev, "cannot allocate ethernet device\n");
274 goto err_out_free_res;
275 }
276 dev->netdev_ops = &ne2k_netdev_ops;
277 ei_local = netdev_priv(dev);
278 ei_local->msg_enable = netif_msg_init(ne2k_msg_enable, default_msg_level);
279
280 SET_NETDEV_DEV(dev, &pdev->dev);
281
282 /* Reset card. Who knows what dain-bramaged state it was left in. */
283 {
284 unsigned long reset_start_time = jiffies;
285
286 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
287
288 /* This looks like a horrible timing loop, but it should never
289 * take more than a few cycles.
290 */
291 while ((inb(ioaddr + EN0_ISR) & ENISR_RESET) == 0)
292 /* Limit wait: '2' avoids jiffy roll-over. */
293 if (jiffies - reset_start_time > 2) {
294 dev_err(&pdev->dev,
295 "Card failure (no reset ack).\n");
296 goto err_out_free_netdev;
297 }
298 /* Ack all intr. */
299 outb(0xff, ioaddr + EN0_ISR);
300 }
301
302 /* Read the 16 bytes of station address PROM.
303 * We must first initialize registers, similar
304 * to NS8390_init(eifdev, 0).
305 * We can't reliably read the SAPROM address without this.
306 * (I learned the hard way!).
307 */
308 {
309 struct {unsigned char value, offset; } program_seq[] = {
310 /* Select page 0 */
311 {E8390_NODMA + E8390_PAGE0 + E8390_STOP, E8390_CMD},
312 /* Set word-wide access */
313 {0x49, EN0_DCFG},
314 /* Clear the count regs. */
315 {0x00, EN0_RCNTLO},
316 /* Mask completion IRQ */
317 {0x00, EN0_RCNTHI},
318 {0x00, EN0_IMR},
319 {0xFF, EN0_ISR},
320 /* 0x20 Set to monitor */
321 {E8390_RXOFF, EN0_RXCR},
322 /* 0x02 and loopback mode */
323 {E8390_TXOFF, EN0_TXCR},
324 {32, EN0_RCNTLO},
325 {0x00, EN0_RCNTHI},
326 /* DMA starting at 0x0000 */
327 {0x00, EN0_RSARLO},
328 {0x00, EN0_RSARHI},
329 {E8390_RREAD+E8390_START, E8390_CMD},
330 };
331 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
332 outb(program_seq[i].value,
333 ioaddr + program_seq[i].offset);
334
335 }
336
337 /* Note: all PCI cards have at least 16 bit access, so we don't have
338 * to check for 8 bit cards. Most cards permit 32 bit access.
339 */
340 if (flags & ONLY_32BIT_IO) {
341 for (i = 0; i < 4 ; i++)
342 ((u32 *)SA_prom)[i] = le32_to_cpu(inl(ioaddr + NE_DATAPORT));
343 } else
344 for (i = 0; i < 32 /* sizeof(SA_prom )*/; i++)
345 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
346
347 /* We always set the 8390 registers for word mode. */
348 outb(0x49, ioaddr + EN0_DCFG);
349 start_page = NESM_START_PG;
350
351 stop_page = flags & STOP_PG_0x60 ? 0x60 : NESM_STOP_PG;
352
353 /* Set up the rest of the parameters. */
354 dev->irq = irq;
355 dev->base_addr = ioaddr;
356 pci_set_drvdata(pdev, dev);
357
358 ei_status.name = pci_clone_list[chip_idx].name;
359 ei_status.tx_start_page = start_page;
360 ei_status.stop_page = stop_page;
361 ei_status.word16 = 1;
362 ei_status.ne2k_flags = flags;
363 if (fnd_cnt < MAX_UNITS) {
364 if (full_duplex[fnd_cnt] > 0 || (options[fnd_cnt] & FORCE_FDX))
365 ei_status.ne2k_flags |= FORCE_FDX;
366 }
367
368 ei_status.rx_start_page = start_page + TX_PAGES;
369 #ifdef PACKETBUF_MEMSIZE
370 /* Allow the packet buffer size to be overridden by know-it-alls. */
371 ei_status.stop_page = ei_status.tx_start_page + PACKETBUF_MEMSIZE;
372 #endif
373
374 ei_status.reset_8390 = &ne2k_pci_reset_8390;
375 ei_status.block_input = &ne2k_pci_block_input;
376 ei_status.block_output = &ne2k_pci_block_output;
377 ei_status.get_8390_hdr = &ne2k_pci_get_8390_hdr;
378 ei_status.priv = (unsigned long) pdev;
379
380 dev->ethtool_ops = &ne2k_pci_ethtool_ops;
381 NS8390_init(dev, 0);
382
383 eth_hw_addr_set(dev, SA_prom);
384
385 i = register_netdev(dev);
386 if (i)
387 goto err_out_free_netdev;
388
389 netdev_info(dev, "%s found at %#lx, IRQ %d, %pM.\n",
390 pci_clone_list[chip_idx].name, ioaddr, dev->irq,
391 dev->dev_addr);
392
393 return 0;
394
395 err_out_free_netdev:
396 free_netdev(dev);
397 err_out_free_res:
398 release_region(ioaddr, NE_IO_EXTENT);
399 err_out:
400 pci_disable_device(pdev);
401 return -ENODEV;
402 }
403
404 /* Magic incantation sequence for full duplex on the supported cards.
405 */
set_realtek_fdx(struct net_device * dev)406 static inline int set_realtek_fdx(struct net_device *dev)
407 {
408 long ioaddr = dev->base_addr;
409
410 outb(0xC0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 3 */
411 outb(0xC0, ioaddr + 0x01); /* Enable writes to CONFIG3 */
412 outb(0x40, ioaddr + 0x06); /* Enable full duplex */
413 outb(0x00, ioaddr + 0x01); /* Disable writes to CONFIG3 */
414 outb(E8390_PAGE0 + E8390_NODMA, ioaddr + NE_CMD); /* Page 0 */
415 return 0;
416 }
417
set_holtek_fdx(struct net_device * dev)418 static inline int set_holtek_fdx(struct net_device *dev)
419 {
420 long ioaddr = dev->base_addr;
421
422 outb(inb(ioaddr + 0x20) | 0x80, ioaddr + 0x20);
423 return 0;
424 }
425
ne2k_pci_set_fdx(struct net_device * dev)426 static int ne2k_pci_set_fdx(struct net_device *dev)
427 {
428 if (ei_status.ne2k_flags & REALTEK_FDX)
429 return set_realtek_fdx(dev);
430 else if (ei_status.ne2k_flags & HOLTEK_FDX)
431 return set_holtek_fdx(dev);
432
433 return -EOPNOTSUPP;
434 }
435
ne2k_pci_open(struct net_device * dev)436 static int ne2k_pci_open(struct net_device *dev)
437 {
438 int ret = request_irq(dev->irq, ei_interrupt, IRQF_SHARED,
439 dev->name, dev);
440
441 if (ret)
442 return ret;
443
444 if (ei_status.ne2k_flags & FORCE_FDX)
445 ne2k_pci_set_fdx(dev);
446
447 ei_open(dev);
448 return 0;
449 }
450
ne2k_pci_close(struct net_device * dev)451 static int ne2k_pci_close(struct net_device *dev)
452 {
453 ei_close(dev);
454 free_irq(dev->irq, dev);
455 return 0;
456 }
457
458 /* Hard reset the card. This used to pause for the same period that a
459 * 8390 reset command required, but that shouldn't be necessary.
460 */
ne2k_pci_reset_8390(struct net_device * dev)461 static void ne2k_pci_reset_8390(struct net_device *dev)
462 {
463 unsigned long reset_start_time = jiffies;
464 struct ei_device *ei_local = netdev_priv(dev);
465
466 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n",
467 jiffies);
468
469 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
470
471 ei_status.txing = 0;
472 ei_status.dmaing = 0;
473
474 /* This check _should_not_ be necessary, omit eventually. */
475 while ((inb(NE_BASE+EN0_ISR) & ENISR_RESET) == 0)
476 if (jiffies - reset_start_time > 2) {
477 netdev_err(dev, "%s did not complete.\n", __func__);
478 break;
479 }
480 /* Ack intr. */
481 outb(ENISR_RESET, NE_BASE + EN0_ISR);
482 }
483
484 /* Grab the 8390 specific header. Similar to the block_input routine, but
485 * we don't need to be concerned with ring wrap as the header will be at
486 * the start of a page, so we optimize accordingly.
487 */
488
ne2k_pci_get_8390_hdr(struct net_device * dev,struct e8390_pkt_hdr * hdr,int ring_page)489 static void ne2k_pci_get_8390_hdr(struct net_device *dev,
490 struct e8390_pkt_hdr *hdr, int ring_page)
491 {
492
493 long nic_base = dev->base_addr;
494
495 /* This *shouldn't* happen. If it does, it's the last thing you'll see
496 */
497 if (ei_status.dmaing) {
498 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d].\n",
499 __func__, ei_status.dmaing, ei_status.irqlock);
500 return;
501 }
502
503 ei_status.dmaing |= 0x01;
504 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
505 outb(sizeof(struct e8390_pkt_hdr), nic_base + EN0_RCNTLO);
506 outb(0, nic_base + EN0_RCNTHI);
507 outb(0, nic_base + EN0_RSARLO); /* On page boundary */
508 outb(ring_page, nic_base + EN0_RSARHI);
509 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
510
511 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
512 insw(NE_BASE + NE_DATAPORT, hdr,
513 sizeof(struct e8390_pkt_hdr) >> 1);
514 } else {
515 *(u32 *)hdr = le32_to_cpu(inl(NE_BASE + NE_DATAPORT));
516 le16_to_cpus(&hdr->count);
517 }
518 /* Ack intr. */
519 outb(ENISR_RDC, nic_base + EN0_ISR);
520 ei_status.dmaing &= ~0x01;
521 }
522
523 /* Block input and output, similar to the Crynwr packet driver. If you
524 *are porting to a new ethercard, look at the packet driver source for hints.
525 *The NEx000 doesn't share the on-board packet memory -- you have to put
526 *the packet out through the "remote DMA" dataport using outb.
527 */
528
ne2k_pci_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)529 static void ne2k_pci_block_input(struct net_device *dev, int count,
530 struct sk_buff *skb, int ring_offset)
531 {
532 long nic_base = dev->base_addr;
533 char *buf = skb->data;
534
535 /* This *shouldn't* happen.
536 * If it does, it's the last thing you'll see.
537 */
538 if (ei_status.dmaing) {
539 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
540 __func__, ei_status.dmaing, ei_status.irqlock);
541 return;
542 }
543 ei_status.dmaing |= 0x01;
544 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
545 count = (count + 3) & 0xFFFC;
546 outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD);
547 outb(count & 0xff, nic_base + EN0_RCNTLO);
548 outb(count >> 8, nic_base + EN0_RCNTHI);
549 outb(ring_offset & 0xff, nic_base + EN0_RSARLO);
550 outb(ring_offset >> 8, nic_base + EN0_RSARHI);
551 outb(E8390_RREAD + E8390_START, nic_base + NE_CMD);
552
553 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
554 insw(NE_BASE + NE_DATAPORT, buf, count >> 1);
555 if (count & 0x01)
556 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
557 } else {
558 insl(NE_BASE + NE_DATAPORT, buf, count >> 2);
559 if (count & 3) {
560 buf += count & ~3;
561 if (count & 2) {
562 __le16 *b = (__le16 *)buf;
563
564 *b++ = cpu_to_le16(inw(NE_BASE + NE_DATAPORT));
565 buf = (char *)b;
566 }
567 if (count & 1)
568 *buf = inb(NE_BASE + NE_DATAPORT);
569 }
570 }
571 /* Ack intr. */
572 outb(ENISR_RDC, nic_base + EN0_ISR);
573 ei_status.dmaing &= ~0x01;
574 }
575
ne2k_pci_block_output(struct net_device * dev,int count,const unsigned char * buf,const int start_page)576 static void ne2k_pci_block_output(struct net_device *dev, int count,
577 const unsigned char *buf, const int start_page)
578 {
579 long nic_base = NE_BASE;
580 unsigned long dma_start;
581
582 /* On little-endian it's always safe to round the count up for
583 * word writes.
584 */
585 if (ei_status.ne2k_flags & ONLY_32BIT_IO)
586 count = (count + 3) & 0xFFFC;
587 else
588 if (count & 0x01)
589 count++;
590
591 /* This *shouldn't* happen.
592 * If it does, it's the last thing you'll see.
593 */
594 if (ei_status.dmaing) {
595 netdev_err(dev, "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n",
596 __func__, ei_status.dmaing, ei_status.irqlock);
597 return;
598 }
599 ei_status.dmaing |= 0x01;
600 /* We should already be in page 0, but to be safe... */
601 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
602
603 #ifdef NE_RW_BUGFIX
604 /* Handle the read-before-write bug the same way as the
605 * Crynwr packet driver -- the NatSemi method doesn't work.
606 * Actually this doesn't always work either, but if you have
607 * problems with your NEx000 this is better than nothing!
608 */
609 outb(0x42, nic_base + EN0_RCNTLO);
610 outb(0x00, nic_base + EN0_RCNTHI);
611 outb(0x42, nic_base + EN0_RSARLO);
612 outb(0x00, nic_base + EN0_RSARHI);
613 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
614 #endif
615 outb(ENISR_RDC, nic_base + EN0_ISR);
616
617 /* Now the normal output. */
618 outb(count & 0xff, nic_base + EN0_RCNTLO);
619 outb(count >> 8, nic_base + EN0_RCNTHI);
620 outb(0x00, nic_base + EN0_RSARLO);
621 outb(start_page, nic_base + EN0_RSARHI);
622 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
623 if (ei_status.ne2k_flags & ONLY_16BIT_IO) {
624 outsw(NE_BASE + NE_DATAPORT, buf, count >> 1);
625 } else {
626 outsl(NE_BASE + NE_DATAPORT, buf, count >> 2);
627 if (count & 3) {
628 buf += count & ~3;
629 if (count & 2) {
630 __le16 *b = (__le16 *)buf;
631
632 outw(le16_to_cpu(*b++), NE_BASE + NE_DATAPORT);
633 buf = (char *)b;
634 }
635 }
636 }
637
638 dma_start = jiffies;
639
640 while ((inb(nic_base + EN0_ISR) & ENISR_RDC) == 0)
641 /* Avoid clock roll-over. */
642 if (jiffies - dma_start > 2) {
643 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
644 ne2k_pci_reset_8390(dev);
645 NS8390_init(dev, 1);
646 break;
647 }
648 /* Ack intr. */
649 outb(ENISR_RDC, nic_base + EN0_ISR);
650 ei_status.dmaing &= ~0x01;
651 }
652
ne2k_pci_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)653 static void ne2k_pci_get_drvinfo(struct net_device *dev,
654 struct ethtool_drvinfo *info)
655 {
656 struct ei_device *ei = netdev_priv(dev);
657 struct pci_dev *pci_dev = (struct pci_dev *) ei->priv;
658
659 strscpy(info->driver, DRV_NAME, sizeof(info->driver));
660 strscpy(info->version, DRV_VERSION, sizeof(info->version));
661 strscpy(info->bus_info, pci_name(pci_dev), sizeof(info->bus_info));
662 }
663
ne2k_pci_get_msglevel(struct net_device * dev)664 static u32 ne2k_pci_get_msglevel(struct net_device *dev)
665 {
666 struct ei_device *ei_local = netdev_priv(dev);
667
668 return ei_local->msg_enable;
669 }
670
ne2k_pci_set_msglevel(struct net_device * dev,u32 v)671 static void ne2k_pci_set_msglevel(struct net_device *dev, u32 v)
672 {
673 struct ei_device *ei_local = netdev_priv(dev);
674
675 ei_local->msg_enable = v;
676 }
677
678 static const struct ethtool_ops ne2k_pci_ethtool_ops = {
679 .get_drvinfo = ne2k_pci_get_drvinfo,
680 .get_msglevel = ne2k_pci_get_msglevel,
681 .set_msglevel = ne2k_pci_set_msglevel,
682 };
683
ne2k_pci_remove_one(struct pci_dev * pdev)684 static void ne2k_pci_remove_one(struct pci_dev *pdev)
685 {
686 struct net_device *dev = pci_get_drvdata(pdev);
687
688 BUG_ON(!dev);
689 unregister_netdev(dev);
690 release_region(dev->base_addr, NE_IO_EXTENT);
691 free_netdev(dev);
692 pci_disable_device(pdev);
693 }
694
ne2k_pci_suspend(struct device * dev_d)695 static int __maybe_unused ne2k_pci_suspend(struct device *dev_d)
696 {
697 struct net_device *dev = dev_get_drvdata(dev_d);
698
699 netif_device_detach(dev);
700
701 return 0;
702 }
703
ne2k_pci_resume(struct device * dev_d)704 static int __maybe_unused ne2k_pci_resume(struct device *dev_d)
705 {
706 struct net_device *dev = dev_get_drvdata(dev_d);
707
708 NS8390_init(dev, 1);
709 netif_device_attach(dev);
710
711 return 0;
712 }
713
714 static SIMPLE_DEV_PM_OPS(ne2k_pci_pm_ops, ne2k_pci_suspend, ne2k_pci_resume);
715
716 static struct pci_driver ne2k_driver = {
717 .name = DRV_NAME,
718 .probe = ne2k_pci_init_one,
719 .remove = ne2k_pci_remove_one,
720 .id_table = ne2k_pci_tbl,
721 .driver.pm = &ne2k_pci_pm_ops,
722 };
723 module_pci_driver(ne2k_driver);
724