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