1 /* ne2k-pci.c: A NE2000 clone on PCI bus driver for Linux. */
3 A Linux device driver for PCI NE2000 clones.
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.
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.
18 The author may be reached as becker@scyld.com, or C/O
19 Scyld Computing Corporation
20 410 Severn Ave., Suite 210
24 People are making PCI ne2000 clones! Oh the horror, the horror...
25 Limited full-duplex support.
28 /* These identify the driver base version and may not be removed. */
29 static const char version1
[] =
30 "ne2k-pci.c:v1.02 10/19/2000 D. Becker/P. Gortmaker\n";
31 static const char version2
[] =
32 " http://www.scyld.com/network/ne2k-pci.html\n";
34 /* The user-configurable values.
35 These may be modified when a driver module is loaded.*/
37 static int debug
= 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
39 #define MAX_UNITS 8 /* More are supported, limit only on options */
40 /* Used to pass the full-duplex flag, etc. */
41 static int full_duplex
[MAX_UNITS
];
42 static int options
[MAX_UNITS
];
44 /* Force a non std. amount of memory. Units are 256 byte pages. */
45 /* #define PACKETBUF_MEMSIZE 0x40 */
48 #include <linux/module.h>
49 #include <linux/kernel.h>
50 #include <linux/sched.h>
51 #include <linux/errno.h>
52 #include <linux/pci.h>
53 #include <linux/init.h>
55 #include <asm/system.h>
59 #include <linux/netdevice.h>
60 #include <linux/etherdevice.h>
63 #if defined(__powerpc__)
64 #define inl_le(addr) le32_to_cpu(inl(addr))
65 #define inw_le(addr) le16_to_cpu(inw(addr))
67 #define outsl outsl_ns
70 MODULE_AUTHOR("Donald Becker / Paul Gortmaker");
71 MODULE_DESCRIPTION("PCI NE2000 clone driver");
72 MODULE_PARM(debug
, "i");
73 MODULE_PARM(options
, "1-" __MODULE_STRING(MAX_UNITS
) "i");
74 MODULE_PARM(full_duplex
, "1-" __MODULE_STRING(MAX_UNITS
) "i");
76 /* Some defines that people can play with if so inclined. */
78 /* Use 32 bit data-movement operations instead of 16 bit. */
81 /* Do we implement the read before write bugfix ? */
82 /* #define NE_RW_BUGFIX */
84 /* Flags. We rename an existing ei_status field to store flags! */
85 /* Thus only the low 8 bits are usable for non-init-time flags. */
86 #define ne2k_flags reg0
88 ONLY_16BIT_IO
=8, ONLY_32BIT_IO
=4, /* Chip can do only 16/32-bit xfers. */
89 FORCE_FDX
=0x20, /* User override. */
90 REALTEK_FDX
=0x40, HOLTEK_FDX
=0x80,
94 enum ne2k_pci_chipsets
{
95 CH_RealTek_RTL_8029
= 0,
111 } pci_clone_list
[] __devinitdata
= {
112 {"RealTek RTL-8029", REALTEK_FDX
},
113 {"Winbond 89C940", 0},
114 {"Compex RL2000", 0},
116 {"NetVin NV5000SC", 0},
117 {"Via 86C926", ONLY_16BIT_IO
},
119 {"Winbond W89C940F", 0},
120 {"Holtek HT80232", ONLY_16BIT_IO
| HOLTEK_FDX
},
121 {"Holtek HT80229", ONLY_32BIT_IO
| HOLTEK_FDX
| STOP_PG_0x60
},
126 static struct pci_device_id ne2k_pci_tbl
[] __devinitdata
= {
127 { 0x10ec, 0x8029, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_RealTek_RTL_8029
},
128 { 0x1050, 0x0940, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Winbond_89C940
},
129 { 0x11f6, 0x1401, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Compex_RL2000
},
130 { 0x8e2e, 0x3000, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_KTI_ET32P2
},
131 { 0x4a14, 0x5000, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_NetVin_NV5000SC
},
132 { 0x1106, 0x0926, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Via_86C926
},
133 { 0x10bd, 0x0e34, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_SureCom_NE34
},
134 { 0x1050, 0x5a5a, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Winbond_W89C940F
},
135 { 0x12c3, 0x0058, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Holtek_HT80232
},
136 { 0x12c3, 0x5598, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, CH_Holtek_HT80229
},
139 MODULE_DEVICE_TABLE(pci
, ne2k_pci_tbl
);
142 /* ---- No user-serviceable parts below ---- */
144 #define NE_BASE (dev->base_addr)
146 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
147 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
148 #define NE_IO_EXTENT 0x20
150 #define NESM_START_PG 0x40 /* First page of TX buffer */
151 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
154 static int ne2k_pci_open(struct net_device
*dev
);
155 static int ne2k_pci_close(struct net_device
*dev
);
157 static void ne2k_pci_reset_8390(struct net_device
*dev
);
158 static void ne2k_pci_get_8390_hdr(struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
,
160 static void ne2k_pci_block_input(struct net_device
*dev
, int count
,
161 struct sk_buff
*skb
, int ring_offset
);
162 static void ne2k_pci_block_output(struct net_device
*dev
, const int count
,
163 const unsigned char *buf
, const int start_page
);
167 /* There is no room in the standard 8390 structure for extra info we need,
168 so we build a meta/outer-wrapper structure.. */
169 struct ne2k_pci_card
{
170 struct net_device
*dev
;
171 struct pci_dev
*pci_dev
;
177 NEx000-clone boards have a Station Address (SA) PROM (SAPROM) in the packet
178 buffer memory space. By-the-spec NE2000 clones have 0x57,0x57 in bytes
179 0x0e,0x0f of the SAPROM, while other supposed NE2000 clones must be
180 detected by their SA prefix.
182 Reading the SAPROM from a word-wide card with the 8390 set in byte-wide
183 mode results in doubled values, which can be detected and compensated for.
185 The probe is also responsible for initializing the card and filling
186 in the 'dev' and 'ei_status' structures.
190 static int __devinit
ne2k_pci_init_one (struct pci_dev
*pdev
,
191 const struct pci_device_id
*ent
)
193 struct net_device
*dev
;
195 unsigned char SA_prom
[32];
196 int start_page
, stop_page
;
197 int irq
, reg0
, chip_idx
= ent
->driver_data
;
198 static unsigned int fnd_cnt
;
200 int flags
= pci_clone_list
[chip_idx
].flags
;
203 printk(KERN_INFO
"%s" KERN_INFO
"%s", version1
, version2
);
205 ioaddr
= pci_resource_start (pdev
, 0);
208 if (!ioaddr
|| ((pci_resource_flags (pdev
, 0) & IORESOURCE_IO
) == 0)) {
209 printk (KERN_ERR
"ne2k-pci: no I/O resource at PCI BAR #0\n");
213 i
= pci_enable_device (pdev
);
217 if (request_region (ioaddr
, NE_IO_EXTENT
, "ne2k-pci") == NULL
) {
218 printk (KERN_ERR
"ne2k-pci: I/O resource 0x%x @ 0x%lx busy\n",
219 NE_IO_EXTENT
, ioaddr
);
225 goto err_out_free_res
;
227 /* Do a preliminary verification that we have a 8390. */
230 outb(E8390_NODMA
+E8390_PAGE1
+E8390_STOP
, ioaddr
+ E8390_CMD
);
231 regd
= inb(ioaddr
+ 0x0d);
232 outb(0xff, ioaddr
+ 0x0d);
233 outb(E8390_NODMA
+E8390_PAGE0
, ioaddr
+ E8390_CMD
);
234 inb(ioaddr
+ EN0_COUNTER0
); /* Clear the counter by reading. */
235 if (inb(ioaddr
+ EN0_COUNTER0
) != 0) {
237 outb(regd
, ioaddr
+ 0x0d); /* Restore the old values. */
238 goto err_out_free_res
;
242 dev
= init_etherdev(NULL
, 0);
244 printk (KERN_ERR
"ne2k-pci: cannot allocate ethernet device\n");
245 goto err_out_free_res
;
248 /* Reset card. Who knows what dain-bramaged state it was left in. */
250 unsigned long reset_start_time
= jiffies
;
252 outb(inb(ioaddr
+ NE_RESET
), ioaddr
+ NE_RESET
);
254 /* This looks like a horrible timing loop, but it should never take
255 more than a few cycles.
257 while ((inb(ioaddr
+ EN0_ISR
) & ENISR_RESET
) == 0)
258 /* Limit wait: '2' avoids jiffy roll-over. */
259 if (jiffies
- reset_start_time
> 2) {
260 printk("ne2k-pci: Card failure (no reset ack).\n");
261 goto err_out_free_netdev
;
264 outb(0xff, ioaddr
+ EN0_ISR
); /* Ack all intr. */
267 /* Read the 16 bytes of station address PROM.
268 We must first initialize registers, similar to NS8390_init(eifdev, 0).
269 We can't reliably read the SAPROM address without this.
270 (I learned the hard way!). */
272 struct {unsigned char value
, offset
; } program_seq
[] = {
273 {E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, E8390_CMD
}, /* Select page 0*/
274 {0x49, EN0_DCFG
}, /* Set word-wide access. */
275 {0x00, EN0_RCNTLO
}, /* Clear the count regs. */
277 {0x00, EN0_IMR
}, /* Mask completion irq. */
279 {E8390_RXOFF
, EN0_RXCR
}, /* 0x20 Set to monitor */
280 {E8390_TXOFF
, EN0_TXCR
}, /* 0x02 and loopback mode. */
283 {0x00, EN0_RSARLO
}, /* DMA starting at 0x0000. */
285 {E8390_RREAD
+E8390_START
, E8390_CMD
},
287 for (i
= 0; i
< sizeof(program_seq
)/sizeof(program_seq
[0]); i
++)
288 outb(program_seq
[i
].value
, ioaddr
+ program_seq
[i
].offset
);
292 /* Note: all PCI cards have at least 16 bit access, so we don't have
293 to check for 8 bit cards. Most cards permit 32 bit access. */
294 if (flags
& ONLY_32BIT_IO
) {
295 for (i
= 0; i
< 4 ; i
++)
296 ((u32
*)SA_prom
)[i
] = le32_to_cpu(inl(ioaddr
+ NE_DATAPORT
));
298 for(i
= 0; i
< 32 /*sizeof(SA_prom)*/; i
++)
299 SA_prom
[i
] = inb(ioaddr
+ NE_DATAPORT
);
301 /* We always set the 8390 registers for word mode. */
302 outb(0x49, ioaddr
+ EN0_DCFG
);
303 start_page
= NESM_START_PG
;
305 stop_page
= flags
& STOP_PG_0x60
? 0x60 : NESM_STOP_PG
;
307 /* Set up the rest of the parameters. */
309 dev
->base_addr
= ioaddr
;
310 pci_set_drvdata(pdev
, dev
);
312 /* Allocate dev->priv and fill in 8390 specific dev fields. */
313 if (ethdev_init(dev
)) {
314 printk (KERN_ERR
"%s: unable to get memory for dev->priv.\n", dev
->name
);
315 goto err_out_free_netdev
;
318 printk("%s: %s found at %#lx, IRQ %d, ",
319 dev
->name
, pci_clone_list
[chip_idx
].name
, ioaddr
, dev
->irq
);
320 for(i
= 0; i
< 6; i
++) {
321 printk("%2.2X%s", SA_prom
[i
], i
== 5 ? ".\n": ":");
322 dev
->dev_addr
[i
] = SA_prom
[i
];
325 ei_status
.name
= pci_clone_list
[chip_idx
].name
;
326 ei_status
.tx_start_page
= start_page
;
327 ei_status
.stop_page
= stop_page
;
328 ei_status
.word16
= 1;
329 ei_status
.ne2k_flags
= flags
;
330 if (fnd_cnt
< MAX_UNITS
) {
331 if (full_duplex
[fnd_cnt
] > 0 || (options
[fnd_cnt
] & FORCE_FDX
))
332 ei_status
.ne2k_flags
|= FORCE_FDX
;
335 ei_status
.rx_start_page
= start_page
+ TX_PAGES
;
336 #ifdef PACKETBUF_MEMSIZE
337 /* Allow the packet buffer size to be overridden by know-it-alls. */
338 ei_status
.stop_page
= ei_status
.tx_start_page
+ PACKETBUF_MEMSIZE
;
341 ei_status
.reset_8390
= &ne2k_pci_reset_8390
;
342 ei_status
.block_input
= &ne2k_pci_block_input
;
343 ei_status
.block_output
= &ne2k_pci_block_output
;
344 ei_status
.get_8390_hdr
= &ne2k_pci_get_8390_hdr
;
345 dev
->open
= &ne2k_pci_open
;
346 dev
->stop
= &ne2k_pci_close
;
351 unregister_netdev (dev
);
354 release_region (ioaddr
, NE_IO_EXTENT
);
359 static int ne2k_pci_open(struct net_device
*dev
)
362 if (request_irq(dev
->irq
, ei_interrupt
, SA_SHIRQ
, dev
->name
, dev
)) {
366 /* Set full duplex for the chips that we know about. */
367 if (ei_status
.ne2k_flags
& FORCE_FDX
) {
368 long ioaddr
= dev
->base_addr
;
369 if (ei_status
.ne2k_flags
& REALTEK_FDX
) {
370 outb(0xC0 + E8390_NODMA
, ioaddr
+ NE_CMD
); /* Page 3 */
371 outb(inb(ioaddr
+ 0x20) | 0x80, ioaddr
+ 0x20);
372 } else if (ei_status
.ne2k_flags
& HOLTEK_FDX
)
373 outb(inb(ioaddr
+ 0x20) | 0x80, ioaddr
+ 0x20);
379 static int ne2k_pci_close(struct net_device
*dev
)
382 free_irq(dev
->irq
, dev
);
387 /* Hard reset the card. This used to pause for the same period that a
388 8390 reset command required, but that shouldn't be necessary. */
389 static void ne2k_pci_reset_8390(struct net_device
*dev
)
391 unsigned long reset_start_time
= jiffies
;
393 if (debug
> 1) printk("%s: Resetting the 8390 t=%ld...",
396 outb(inb(NE_BASE
+ NE_RESET
), NE_BASE
+ NE_RESET
);
399 ei_status
.dmaing
= 0;
401 /* This check _should_not_ be necessary, omit eventually. */
402 while ((inb(NE_BASE
+EN0_ISR
) & ENISR_RESET
) == 0)
403 if (jiffies
- reset_start_time
> 2) {
404 printk("%s: ne2k_pci_reset_8390() did not complete.\n", dev
->name
);
407 outb(ENISR_RESET
, NE_BASE
+ EN0_ISR
); /* Ack intr. */
410 /* Grab the 8390 specific header. Similar to the block_input routine, but
411 we don't need to be concerned with ring wrap as the header will be at
412 the start of a page, so we optimize accordingly. */
414 static void ne2k_pci_get_8390_hdr(struct net_device
*dev
, struct e8390_pkt_hdr
*hdr
, int ring_page
)
417 long nic_base
= dev
->base_addr
;
419 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
420 if (ei_status
.dmaing
) {
421 printk("%s: DMAing conflict in ne2k_pci_get_8390_hdr "
422 "[DMAstat:%d][irqlock:%d].\n",
423 dev
->name
, ei_status
.dmaing
, ei_status
.irqlock
);
427 ei_status
.dmaing
|= 0x01;
428 outb(E8390_NODMA
+E8390_PAGE0
+E8390_START
, nic_base
+ NE_CMD
);
429 outb(sizeof(struct e8390_pkt_hdr
), nic_base
+ EN0_RCNTLO
);
430 outb(0, nic_base
+ EN0_RCNTHI
);
431 outb(0, nic_base
+ EN0_RSARLO
); /* On page boundary */
432 outb(ring_page
, nic_base
+ EN0_RSARHI
);
433 outb(E8390_RREAD
+E8390_START
, nic_base
+ NE_CMD
);
435 if (ei_status
.ne2k_flags
& ONLY_16BIT_IO
) {
436 insw(NE_BASE
+ NE_DATAPORT
, hdr
, sizeof(struct e8390_pkt_hdr
)>>1);
438 *(u32
*)hdr
= le32_to_cpu(inl(NE_BASE
+ NE_DATAPORT
));
439 le16_to_cpus(&hdr
->count
);
442 outb(ENISR_RDC
, nic_base
+ EN0_ISR
); /* Ack intr. */
443 ei_status
.dmaing
&= ~0x01;
446 /* Block input and output, similar to the Crynwr packet driver. If you
447 are porting to a new ethercard, look at the packet driver source for hints.
448 The NEx000 doesn't share the on-board packet memory -- you have to put
449 the packet out through the "remote DMA" dataport using outb. */
451 static void ne2k_pci_block_input(struct net_device
*dev
, int count
,
452 struct sk_buff
*skb
, int ring_offset
)
454 long nic_base
= dev
->base_addr
;
455 char *buf
= skb
->data
;
457 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
458 if (ei_status
.dmaing
) {
459 printk("%s: DMAing conflict in ne2k_pci_block_input "
460 "[DMAstat:%d][irqlock:%d].\n",
461 dev
->name
, ei_status
.dmaing
, ei_status
.irqlock
);
464 ei_status
.dmaing
|= 0x01;
465 if (ei_status
.ne2k_flags
& ONLY_32BIT_IO
)
466 count
= (count
+ 3) & 0xFFFC;
467 outb(E8390_NODMA
+E8390_PAGE0
+E8390_START
, nic_base
+ NE_CMD
);
468 outb(count
& 0xff, nic_base
+ EN0_RCNTLO
);
469 outb(count
>> 8, nic_base
+ EN0_RCNTHI
);
470 outb(ring_offset
& 0xff, nic_base
+ EN0_RSARLO
);
471 outb(ring_offset
>> 8, nic_base
+ EN0_RSARHI
);
472 outb(E8390_RREAD
+E8390_START
, nic_base
+ NE_CMD
);
474 if (ei_status
.ne2k_flags
& ONLY_16BIT_IO
) {
475 insw(NE_BASE
+ NE_DATAPORT
,buf
,count
>>1);
477 buf
[count
-1] = inb(NE_BASE
+ NE_DATAPORT
);
480 insl(NE_BASE
+ NE_DATAPORT
, buf
, count
>>2);
484 *((u16
*)buf
)++ = le16_to_cpu(inw(NE_BASE
+ NE_DATAPORT
));
486 *buf
= inb(NE_BASE
+ NE_DATAPORT
);
490 outb(ENISR_RDC
, nic_base
+ EN0_ISR
); /* Ack intr. */
491 ei_status
.dmaing
&= ~0x01;
494 static void ne2k_pci_block_output(struct net_device
*dev
, int count
,
495 const unsigned char *buf
, const int start_page
)
497 long nic_base
= NE_BASE
;
498 unsigned long dma_start
;
500 /* On little-endian it's always safe to round the count up for
502 if (ei_status
.ne2k_flags
& ONLY_32BIT_IO
)
503 count
= (count
+ 3) & 0xFFFC;
508 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
509 if (ei_status
.dmaing
) {
510 printk("%s: DMAing conflict in ne2k_pci_block_output."
511 "[DMAstat:%d][irqlock:%d]\n",
512 dev
->name
, ei_status
.dmaing
, ei_status
.irqlock
);
515 ei_status
.dmaing
|= 0x01;
516 /* We should already be in page 0, but to be safe... */
517 outb(E8390_PAGE0
+E8390_START
+E8390_NODMA
, nic_base
+ NE_CMD
);
519 #ifdef NE8390_RW_BUGFIX
520 /* Handle the read-before-write bug the same way as the
521 Crynwr packet driver -- the NatSemi method doesn't work.
522 Actually this doesn't always work either, but if you have
523 problems with your NEx000 this is better than nothing! */
524 outb(0x42, nic_base
+ EN0_RCNTLO
);
525 outb(0x00, nic_base
+ EN0_RCNTHI
);
526 outb(0x42, nic_base
+ EN0_RSARLO
);
527 outb(0x00, nic_base
+ EN0_RSARHI
);
528 outb(E8390_RREAD
+E8390_START
, nic_base
+ NE_CMD
);
530 outb(ENISR_RDC
, nic_base
+ EN0_ISR
);
532 /* Now the normal output. */
533 outb(count
& 0xff, nic_base
+ EN0_RCNTLO
);
534 outb(count
>> 8, nic_base
+ EN0_RCNTHI
);
535 outb(0x00, nic_base
+ EN0_RSARLO
);
536 outb(start_page
, nic_base
+ EN0_RSARHI
);
537 outb(E8390_RWRITE
+E8390_START
, nic_base
+ NE_CMD
);
538 if (ei_status
.ne2k_flags
& ONLY_16BIT_IO
) {
539 outsw(NE_BASE
+ NE_DATAPORT
, buf
, count
>>1);
541 outsl(NE_BASE
+ NE_DATAPORT
, buf
, count
>>2);
545 outw(cpu_to_le16(*((u16
*)buf
)++), NE_BASE
+ NE_DATAPORT
);
551 while ((inb(nic_base
+ EN0_ISR
) & ENISR_RDC
) == 0)
552 if (jiffies
- dma_start
> 2) { /* Avoid clock roll-over. */
553 printk(KERN_WARNING
"%s: timeout waiting for Tx RDC.\n", dev
->name
);
554 ne2k_pci_reset_8390(dev
);
559 outb(ENISR_RDC
, nic_base
+ EN0_ISR
); /* Ack intr. */
560 ei_status
.dmaing
&= ~0x01;
565 static void __devexit
ne2k_pci_remove_one (struct pci_dev
*pdev
)
567 struct net_device
*dev
= pci_get_drvdata(pdev
);
572 unregister_netdev(dev
);
573 release_region(dev
->base_addr
, NE_IO_EXTENT
);
575 pci_set_drvdata(pdev
, NULL
);
579 static struct pci_driver ne2k_driver
= {
581 probe
: ne2k_pci_init_one
,
582 remove
: ne2k_pci_remove_one
,
583 id_table
: ne2k_pci_tbl
,
587 static int __init
ne2k_pci_init(void)
589 return pci_module_init (&ne2k_driver
);
593 static void __exit
ne2k_pci_cleanup(void)
595 pci_unregister_driver (&ne2k_driver
);
598 module_init(ne2k_pci_init
);
599 module_exit(ne2k_pci_cleanup
);