2 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
4 * (C) Copyright 1997 Alain Malek
5 * (Alain.Malek@cryogen.com)
7 * ----------------------------------------------------------------------------
9 * This program is based on
11 * ne.c: A general non-shared-memory NS8390 ethernet driver for linux
12 * Written 1992-94 by Donald Becker.
14 * 8390.c: A general NS8390 ethernet driver core for linux.
15 * Written 1992-94 by Donald Becker.
17 * cnetdevice: A Sana-II ethernet driver for AmigaOS
18 * Written by Bruce Abbott (bhabbott@inhb.co.nz)
20 * ----------------------------------------------------------------------------
22 * This file is subject to the terms and conditions of the GNU General Public
23 * License. See the file COPYING in the main directory of the Linux
24 * distribution for more details.
26 * ----------------------------------------------------------------------------
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/errno.h>
34 #include <linux/pci.h>
35 #include <linux/init.h>
36 #include <linux/delay.h>
37 #include <linux/netdevice.h>
38 #include <linux/etherdevice.h>
40 #include <asm/system.h>
42 #include <asm/setup.h>
43 #include <asm/amigaints.h>
44 #include <asm/amigahw.h>
45 #include <asm/amigayle.h>
46 #include <asm/amipcmcia.h>
50 /* ---- No user-serviceable parts below ---- */
52 #define NE_BASE (dev->base_addr)
54 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
55 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
56 #define NE_IO_EXTENT 0x20
58 #define NE_EN0_ISR 0x07
59 #define NE_EN0_DCFG 0x0e
61 #define NE_EN0_RSARLO 0x08
62 #define NE_EN0_RSARHI 0x09
63 #define NE_EN0_RCNTLO 0x0a
64 #define NE_EN0_RXCR 0x0c
65 #define NE_EN0_TXCR 0x0d
66 #define NE_EN0_RCNTHI 0x0b
67 #define NE_EN0_IMR 0x0f
69 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
70 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
71 #define NESM_START_PG 0x40 /* First page of TX buffer */
72 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
75 struct net_device * __init apne_probe(int unit);
76 static int apne_probe1(struct net_device *dev, int ioaddr);
78 static int apne_open(struct net_device *dev);
79 static int apne_close(struct net_device *dev);
81 static void apne_reset_8390(struct net_device *dev);
82 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
84 static void apne_block_input(struct net_device *dev, int count,
85 struct sk_buff *skb, int ring_offset);
86 static void apne_block_output(struct net_device *dev, const int count,
87 const unsigned char *buf, const int start_page);
88 static irqreturn_t apne_interrupt(int irq, void *dev_id, struct pt_regs *regs);
90 static int init_pcmcia(void);
92 /* IO base address used for nic */
97 use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
98 you can find the values to use by looking at the cnet.device
99 config file example (the default values are for the CNET40BC card)
103 #define MANUAL_CONFIG 0x20
104 #define MANUAL_OFFSET 0x3f8
106 #define MANUAL_HWADDR0 0x00
107 #define MANUAL_HWADDR1 0x12
108 #define MANUAL_HWADDR2 0x34
109 #define MANUAL_HWADDR3 0x56
110 #define MANUAL_HWADDR4 0x78
111 #define MANUAL_HWADDR5 0x9a
114 static const char version[] =
115 "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
117 static int apne_owned; /* signal if card already owned */
119 struct net_device * __init apne_probe(int unit)
121 struct net_device *dev;
122 #ifndef MANUAL_CONFIG
128 return ERR_PTR(-ENODEV);
130 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
131 return ERR_PTR(-ENODEV);
133 printk("Looking for PCMCIA ethernet card : ");
135 /* check if a card is inserted */
136 if (!(PCMCIA_INSERTED)) {
137 printk("NO PCMCIA card inserted\n");
138 return ERR_PTR(-ENODEV);
141 dev = alloc_ei_netdev();
143 return ERR_PTR(-ENOMEM);
145 sprintf(dev->name, "eth%d", unit);
146 netdev_boot_setup_check(dev);
148 SET_MODULE_OWNER(dev);
150 /* disable pcmcia irq for readtuple */
151 pcmcia_disable_irq();
153 #ifndef MANUAL_CONFIG
154 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
155 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
156 printk("not an ethernet card\n");
157 /* XXX: shouldn't we re-enable irq here? */
159 return ERR_PTR(-ENODEV);
163 printk("ethernet PCMCIA card inserted\n");
165 if (!init_pcmcia()) {
166 /* XXX: shouldn't we re-enable irq here? */
168 return ERR_PTR(-ENODEV);
171 if (!request_region(IOBASE, 0x20, dev->name)) {
173 return ERR_PTR(-EBUSY);
176 err = apne_probe1(dev, IOBASE);
178 release_region(IOBASE, 0x20);
182 err = register_netdev(dev);
186 pcmcia_disable_irq();
187 free_irq(IRQ_AMIGA_PORTS, dev);
189 release_region(IOBASE, 0x20);
194 static int __init apne_probe1(struct net_device *dev, int ioaddr)
197 unsigned char SA_prom[32];
199 const char *name = NULL;
200 int start_page, stop_page;
201 #ifndef MANUAL_HWADDR0
204 static unsigned version_printed;
206 if (ei_debug && version_printed++ == 0)
209 printk("PCMCIA NE*000 ethercard probe");
211 /* Reset card. Who knows what dain-bramaged state it was left in. */
212 { unsigned long reset_start_time = jiffies;
214 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
216 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
217 if (jiffies - reset_start_time > 2*HZ/100) {
218 printk(" not found (no reset ack).\n");
222 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
225 #ifndef MANUAL_HWADDR0
227 /* Read the 16 bytes of station address PROM.
228 We must first initialize registers, similar to NS8390_init(eifdev, 0).
229 We can't reliably read the SAPROM address without this.
230 (I learned the hard way!). */
232 struct {unsigned long value, offset; } program_seq[] = {
233 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
234 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
235 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
236 {0x00, NE_EN0_RCNTHI},
237 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
239 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
240 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
242 {0x00, NE_EN0_RCNTHI},
243 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
244 {0x00, NE_EN0_RSARHI},
245 {E8390_RREAD+E8390_START, NE_CMD},
247 for (i = 0; i < sizeof(program_seq)/sizeof(program_seq[0]); i++) {
248 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
252 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
253 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
254 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
255 if (SA_prom[i] != SA_prom[i+1])
259 /* At this point, wordlength *only* tells us if the SA_prom is doubled
260 up or not because some broken PCI cards don't respect the byte-wide
261 request in program_seq above, and hence don't have doubled up values.
262 These broken cards would otherwise be detected as an ne1000. */
265 for (i = 0; i < 16; i++)
266 SA_prom[i] = SA_prom[i+i];
268 if (wordlength == 2) {
269 /* We must set the 8390 for word mode. */
270 outb(0x49, ioaddr + NE_EN0_DCFG);
271 start_page = NESM_START_PG;
272 stop_page = NESM_STOP_PG;
274 start_page = NE1SM_START_PG;
275 stop_page = NE1SM_STOP_PG;
278 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
279 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
281 /* Set up the rest of the parameters. */
283 name = (wordlength == 2) ? "NE2000" : "NE1000";
285 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
287 stop_page = (wordlength == 2) ? 0x40 : 0x20;
289 printk(" not found.\n");
296 /* We must set the 8390 for word mode. */
297 outb(0x49, ioaddr + NE_EN0_DCFG);
298 start_page = NESM_START_PG;
299 stop_page = NESM_STOP_PG;
301 SA_prom[0] = MANUAL_HWADDR0;
302 SA_prom[1] = MANUAL_HWADDR1;
303 SA_prom[2] = MANUAL_HWADDR2;
304 SA_prom[3] = MANUAL_HWADDR3;
305 SA_prom[4] = MANUAL_HWADDR4;
306 SA_prom[5] = MANUAL_HWADDR5;
310 dev->base_addr = ioaddr;
312 /* Install the Interrupt handler */
313 i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt, SA_SHIRQ, dev->name, dev);
316 for(i = 0; i < ETHER_ADDR_LEN; i++) {
317 printk(" %2.2x", SA_prom[i]);
318 dev->dev_addr[i] = SA_prom[i];
321 printk("\n%s: %s found.\n", dev->name, name);
323 ei_status.name = name;
324 ei_status.tx_start_page = start_page;
325 ei_status.stop_page = stop_page;
326 ei_status.word16 = (wordlength == 2);
328 ei_status.rx_start_page = start_page + TX_PAGES;
330 ei_status.reset_8390 = &apne_reset_8390;
331 ei_status.block_input = &apne_block_input;
332 ei_status.block_output = &apne_block_output;
333 ei_status.get_8390_hdr = &apne_get_8390_hdr;
334 dev->open = &apne_open;
335 dev->stop = &apne_close;
336 #ifdef CONFIG_NET_POLL_CONTROLLER
337 dev->poll_controller = ei_poll;
341 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
350 apne_open(struct net_device *dev)
357 apne_close(struct net_device *dev)
360 printk("%s: Shutting down ethercard.\n", dev->name);
365 /* Hard reset the card. This used to pause for the same period that a
366 8390 reset command required, but that shouldn't be necessary. */
368 apne_reset_8390(struct net_device *dev)
370 unsigned long reset_start_time = jiffies;
374 if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
376 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
379 ei_status.dmaing = 0;
381 /* This check _should_not_ be necessary, omit eventually. */
382 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
383 if (jiffies - reset_start_time > 2*HZ/100) {
384 printk("%s: ne_reset_8390() did not complete.\n", dev->name);
387 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
390 /* Grab the 8390 specific header. Similar to the block_input routine, but
391 we don't need to be concerned with ring wrap as the header will be at
392 the start of a page, so we optimize accordingly. */
395 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
398 int nic_base = dev->base_addr;
403 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
404 if (ei_status.dmaing) {
405 printk("%s: DMAing conflict in ne_get_8390_hdr "
406 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
407 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
411 ei_status.dmaing |= 0x01;
412 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
413 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
414 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
415 outb(0, nic_base + NE_EN0_RCNTHI);
416 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
417 outb(ring_page, nic_base + NE_EN0_RSARHI);
418 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
420 if (ei_status.word16) {
422 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
423 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
426 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
427 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
430 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
431 ei_status.dmaing &= ~0x01;
433 le16_to_cpus(&hdr->count);
436 /* Block input and output, similar to the Crynwr packet driver. If you
437 are porting to a new ethercard, look at the packet driver source for hints.
438 The NEx000 doesn't share the on-board packet memory -- you have to put
439 the packet out through the "remote DMA" dataport using outb. */
442 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
444 int nic_base = dev->base_addr;
445 char *buf = skb->data;
450 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
451 if (ei_status.dmaing) {
452 printk("%s: DMAing conflict in ne_block_input "
453 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
454 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
457 ei_status.dmaing |= 0x01;
458 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
459 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
460 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
461 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
462 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
463 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
464 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
465 if (ei_status.word16) {
467 for (cnt = 0; cnt < (count>>1); cnt++)
468 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
470 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
474 for (cnt = 0; cnt < count; cnt++)
475 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
478 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
479 ei_status.dmaing &= ~0x01;
483 apne_block_output(struct net_device *dev, int count,
484 const unsigned char *buf, const int start_page)
486 int nic_base = NE_BASE;
487 unsigned long dma_start;
492 /* Round the count up for word writes. Do we need to do this?
493 What effect will an odd byte count have on the 8390?
494 I should check someday. */
495 if (ei_status.word16 && (count & 0x01))
498 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
499 if (ei_status.dmaing) {
500 printk("%s: DMAing conflict in ne_block_output."
501 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
502 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
505 ei_status.dmaing |= 0x01;
506 /* We should already be in page 0, but to be safe... */
507 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
509 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
511 /* Now the normal output. */
512 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
513 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
514 outb(0x00, nic_base + NE_EN0_RSARLO);
515 outb(start_page, nic_base + NE_EN0_RSARHI);
517 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
518 if (ei_status.word16) {
520 for (cnt = 0; cnt < count>>1; cnt++)
521 outw(*ptrs++, NE_BASE+NE_DATAPORT);
524 for (cnt = 0; cnt < count; cnt++)
525 outb(*ptrc++, NE_BASE + NE_DATAPORT);
530 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
531 if (jiffies - dma_start > 2*HZ/100) { /* 20ms */
532 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
533 apne_reset_8390(dev);
538 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
539 ei_status.dmaing &= ~0x01;
543 static irqreturn_t apne_interrupt(int irq, void *dev_id, struct pt_regs *regs)
545 unsigned char pcmcia_intreq;
547 if (!(gayle.inten & GAYLE_IRQ_IRQ))
550 pcmcia_intreq = pcmcia_get_intreq();
552 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
553 pcmcia_ack_int(pcmcia_intreq);
557 printk("pcmcia intreq = %x\n", pcmcia_intreq);
558 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
559 ei_interrupt(irq, dev_id, regs);
560 pcmcia_ack_int(pcmcia_get_intreq());
566 static struct net_device *apne_dev;
568 int init_module(void)
570 apne_dev = apne_probe(-1);
571 if (IS_ERR(apne_dev))
572 return PTR_ERR(apne_dev);
576 void cleanup_module(void)
578 unregister_netdev(apne_dev);
580 pcmcia_disable_irq();
582 free_irq(IRQ_AMIGA_PORTS, apne_dev);
586 release_region(IOBASE, 0x20);
588 free_netdev(apne_dev);
593 static int init_pcmcia(void)
596 #ifndef MANUAL_CONFIG
603 pcmcia_program_voltage(PCMCIA_0V);
604 pcmcia_access_speed(PCMCIA_SPEED_250NS);
605 pcmcia_write_enable();
608 config = MANUAL_CONFIG;
610 /* get and write config byte to enable IO port */
612 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
615 config = tuple[2] & 0x3f;
618 offset = MANUAL_OFFSET;
620 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
623 offset_len = (tuple[2] & 0x3) + 1;
625 while(offset_len--) {
626 offset = (offset << 8) | tuple[4+offset_len];
630 out_8(GAYLE_ATTRIBUTE+offset, config);
635 MODULE_LICENSE("GPL");