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>
39 #include <linux/interrupt.h>
40 #include <linux/jiffies.h>
43 #include <asm/setup.h>
44 #include <asm/amigaints.h>
45 #include <asm/amigahw.h>
46 #include <asm/amigayle.h>
47 #include <asm/amipcmcia.h>
51 /* ---- No user-serviceable parts below ---- */
53 #define DRV_NAME "apne"
55 #define NE_BASE (dev->base_addr)
57 #define NE_DATAPORT 0x10 /* NatSemi-defined port window offset. */
58 #define NE_RESET 0x1f /* Issue a read to reset, a write to clear. */
59 #define NE_IO_EXTENT 0x20
61 #define NE_EN0_ISR 0x07
62 #define NE_EN0_DCFG 0x0e
64 #define NE_EN0_RSARLO 0x08
65 #define NE_EN0_RSARHI 0x09
66 #define NE_EN0_RCNTLO 0x0a
67 #define NE_EN0_RXCR 0x0c
68 #define NE_EN0_TXCR 0x0d
69 #define NE_EN0_RCNTHI 0x0b
70 #define NE_EN0_IMR 0x0f
72 #define NE1SM_START_PG 0x20 /* First page of TX buffer */
73 #define NE1SM_STOP_PG 0x40 /* Last page +1 of RX ring */
74 #define NESM_START_PG 0x40 /* First page of TX buffer */
75 #define NESM_STOP_PG 0x80 /* Last page +1 of RX ring */
78 struct net_device * __init apne_probe(int unit);
79 static int apne_probe1(struct net_device *dev, int ioaddr);
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);
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 static u32 apne_msg_enable;
120 module_param_named(msg_enable, apne_msg_enable, uint, (S_IRUSR|S_IRGRP|S_IROTH));
121 MODULE_PARM_DESC(msg_enable, "Debug message level (see linux/netdevice.h for bitmap)");
123 struct net_device * __init apne_probe(int unit)
125 struct net_device *dev;
126 struct ei_device *ei_local;
128 #ifndef MANUAL_CONFIG
134 return ERR_PTR(-ENODEV);
137 return ERR_PTR(-ENODEV);
139 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
140 return ERR_PTR(-ENODEV);
142 pr_info("Looking for PCMCIA ethernet card : ");
144 /* check if a card is inserted */
145 if (!(PCMCIA_INSERTED)) {
146 pr_cont("NO PCMCIA card inserted\n");
147 return ERR_PTR(-ENODEV);
150 dev = alloc_ei_netdev();
152 return ERR_PTR(-ENOMEM);
154 sprintf(dev->name, "eth%d", unit);
155 netdev_boot_setup_check(dev);
157 ei_local = netdev_priv(dev);
158 ei_local->msg_enable = apne_msg_enable;
160 /* disable pcmcia irq for readtuple */
161 pcmcia_disable_irq();
163 #ifndef MANUAL_CONFIG
164 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
165 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
166 pr_cont("not an ethernet card\n");
167 /* XXX: shouldn't we re-enable irq here? */
169 return ERR_PTR(-ENODEV);
173 pr_cont("ethernet PCMCIA card inserted\n");
175 if (!init_pcmcia()) {
176 /* XXX: shouldn't we re-enable irq here? */
178 return ERR_PTR(-ENODEV);
181 if (!request_region(IOBASE, 0x20, DRV_NAME)) {
183 return ERR_PTR(-EBUSY);
186 err = apne_probe1(dev, IOBASE);
188 release_region(IOBASE, 0x20);
192 err = register_netdev(dev);
196 pcmcia_disable_irq();
197 free_irq(IRQ_AMIGA_PORTS, dev);
199 release_region(IOBASE, 0x20);
204 static int __init apne_probe1(struct net_device *dev, int ioaddr)
207 unsigned char SA_prom[32];
209 const char *name = NULL;
210 int start_page, stop_page;
211 #ifndef MANUAL_HWADDR0
214 static unsigned version_printed;
215 struct ei_device *ei_local = netdev_priv(dev);
217 if ((apne_msg_enable & NETIF_MSG_DRV) && (version_printed++ == 0))
218 netdev_info(dev, version);
220 netdev_info(dev, "PCMCIA NE*000 ethercard probe");
222 /* Reset card. Who knows what dain-bramaged state it was left in. */
223 { unsigned long reset_start_time = jiffies;
225 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
227 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
228 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
229 pr_cont(" not found (no reset ack).\n");
233 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
236 #ifndef MANUAL_HWADDR0
238 /* Read the 16 bytes of station address PROM.
239 We must first initialize registers, similar to NS8390_init(eifdev, 0).
240 We can't reliably read the SAPROM address without this.
241 (I learned the hard way!). */
243 struct {unsigned long value, offset; } program_seq[] = {
244 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
245 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
246 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
247 {0x00, NE_EN0_RCNTHI},
248 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
250 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
251 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
253 {0x00, NE_EN0_RCNTHI},
254 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
255 {0x00, NE_EN0_RSARHI},
256 {E8390_RREAD+E8390_START, NE_CMD},
258 for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
259 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
263 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
264 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
265 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
266 if (SA_prom[i] != SA_prom[i+1])
270 /* At this point, wordlength *only* tells us if the SA_prom is doubled
271 up or not because some broken PCI cards don't respect the byte-wide
272 request in program_seq above, and hence don't have doubled up values.
273 These broken cards would otherwise be detected as an ne1000. */
276 for (i = 0; i < 16; i++)
277 SA_prom[i] = SA_prom[i+i];
279 if (wordlength == 2) {
280 /* We must set the 8390 for word mode. */
281 outb(0x49, ioaddr + NE_EN0_DCFG);
282 start_page = NESM_START_PG;
283 stop_page = NESM_STOP_PG;
285 start_page = NE1SM_START_PG;
286 stop_page = NE1SM_STOP_PG;
289 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
290 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
292 /* Set up the rest of the parameters. */
294 name = (wordlength == 2) ? "NE2000" : "NE1000";
296 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
298 stop_page = (wordlength == 2) ? 0x40 : 0x20;
300 pr_cont(" not found.\n");
307 /* We must set the 8390 for word mode. */
308 outb(0x49, ioaddr + NE_EN0_DCFG);
309 start_page = NESM_START_PG;
310 stop_page = NESM_STOP_PG;
312 SA_prom[0] = MANUAL_HWADDR0;
313 SA_prom[1] = MANUAL_HWADDR1;
314 SA_prom[2] = MANUAL_HWADDR2;
315 SA_prom[3] = MANUAL_HWADDR3;
316 SA_prom[4] = MANUAL_HWADDR4;
317 SA_prom[5] = MANUAL_HWADDR5;
321 dev->base_addr = ioaddr;
322 dev->irq = IRQ_AMIGA_PORTS;
323 dev->netdev_ops = &ei_netdev_ops;
325 /* Install the Interrupt handler */
326 i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
329 for (i = 0; i < ETH_ALEN; i++)
330 dev->dev_addr[i] = SA_prom[i];
332 pr_cont(" %pM\n", dev->dev_addr);
334 netdev_info(dev, "%s found.\n", name);
336 ei_status.name = name;
337 ei_status.tx_start_page = start_page;
338 ei_status.stop_page = stop_page;
339 ei_status.word16 = (wordlength == 2);
341 ei_status.rx_start_page = start_page + TX_PAGES;
343 ei_status.reset_8390 = &apne_reset_8390;
344 ei_status.block_input = &apne_block_input;
345 ei_status.block_output = &apne_block_output;
346 ei_status.get_8390_hdr = &apne_get_8390_hdr;
350 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
358 /* Hard reset the card. This used to pause for the same period that a
359 8390 reset command required, but that shouldn't be necessary. */
361 apne_reset_8390(struct net_device *dev)
363 unsigned long reset_start_time = jiffies;
364 struct ei_device *ei_local = netdev_priv(dev);
368 netif_dbg(ei_local, hw, dev, "resetting the 8390 t=%ld...\n", jiffies);
370 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
373 ei_status.dmaing = 0;
375 /* This check _should_not_ be necessary, omit eventually. */
376 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
377 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
378 netdev_err(dev, "ne_reset_8390() did not complete.\n");
381 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
384 /* Grab the 8390 specific header. Similar to the block_input routine, but
385 we don't need to be concerned with ring wrap as the header will be at
386 the start of a page, so we optimize accordingly. */
389 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
392 int nic_base = dev->base_addr;
397 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
398 if (ei_status.dmaing) {
399 netdev_err(dev, "DMAing conflict in ne_get_8390_hdr "
400 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
401 ei_status.dmaing, ei_status.irqlock, dev->irq);
405 ei_status.dmaing |= 0x01;
406 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
407 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
408 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
409 outb(0, nic_base + NE_EN0_RCNTHI);
410 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
411 outb(ring_page, nic_base + NE_EN0_RSARHI);
412 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
414 if (ei_status.word16) {
416 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
417 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
420 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
421 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
424 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
425 ei_status.dmaing &= ~0x01;
427 le16_to_cpus(&hdr->count);
430 /* Block input and output, similar to the Crynwr packet driver. If you
431 are porting to a new ethercard, look at the packet driver source for hints.
432 The NEx000 doesn't share the on-board packet memory -- you have to put
433 the packet out through the "remote DMA" dataport using outb. */
436 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
438 int nic_base = dev->base_addr;
439 char *buf = skb->data;
444 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
445 if (ei_status.dmaing) {
446 netdev_err(dev, "DMAing conflict in ne_block_input "
447 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
448 ei_status.dmaing, ei_status.irqlock, dev->irq);
451 ei_status.dmaing |= 0x01;
452 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
453 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
454 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
455 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
456 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
457 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
458 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
459 if (ei_status.word16) {
461 for (cnt = 0; cnt < (count>>1); cnt++)
462 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
464 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
468 for (cnt = 0; cnt < count; cnt++)
469 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
472 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
473 ei_status.dmaing &= ~0x01;
477 apne_block_output(struct net_device *dev, int count,
478 const unsigned char *buf, const int start_page)
480 int nic_base = NE_BASE;
481 unsigned long dma_start;
486 /* Round the count up for word writes. Do we need to do this?
487 What effect will an odd byte count have on the 8390?
488 I should check someday. */
489 if (ei_status.word16 && (count & 0x01))
492 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
493 if (ei_status.dmaing) {
494 netdev_err(dev, "DMAing conflict in ne_block_output."
495 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
496 ei_status.dmaing, ei_status.irqlock, dev->irq);
499 ei_status.dmaing |= 0x01;
500 /* We should already be in page 0, but to be safe... */
501 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
503 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
505 /* Now the normal output. */
506 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
507 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
508 outb(0x00, nic_base + NE_EN0_RSARLO);
509 outb(start_page, nic_base + NE_EN0_RSARHI);
511 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
512 if (ei_status.word16) {
514 for (cnt = 0; cnt < count>>1; cnt++)
515 outw(*ptrs++, NE_BASE+NE_DATAPORT);
518 for (cnt = 0; cnt < count; cnt++)
519 outb(*ptrc++, NE_BASE + NE_DATAPORT);
524 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
525 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
526 netdev_warn(dev, "timeout waiting for Tx RDC.\n");
527 apne_reset_8390(dev);
532 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
533 ei_status.dmaing &= ~0x01;
536 static irqreturn_t apne_interrupt(int irq, void *dev_id)
538 unsigned char pcmcia_intreq;
540 if (!(gayle.inten & GAYLE_IRQ_IRQ))
543 pcmcia_intreq = pcmcia_get_intreq();
545 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
546 pcmcia_ack_int(pcmcia_intreq);
549 if (apne_msg_enable & NETIF_MSG_INTR)
550 pr_debug("pcmcia intreq = %x\n", pcmcia_intreq);
551 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
552 ei_interrupt(irq, dev_id);
553 pcmcia_ack_int(pcmcia_get_intreq());
559 static struct net_device *apne_dev;
561 static int __init apne_module_init(void)
563 apne_dev = apne_probe(-1);
564 if (IS_ERR(apne_dev))
565 return PTR_ERR(apne_dev);
569 static void __exit apne_module_exit(void)
571 unregister_netdev(apne_dev);
573 pcmcia_disable_irq();
575 free_irq(IRQ_AMIGA_PORTS, apne_dev);
579 release_region(IOBASE, 0x20);
581 free_netdev(apne_dev);
583 module_init(apne_module_init);
584 module_exit(apne_module_exit);
587 static int init_pcmcia(void)
590 #ifndef MANUAL_CONFIG
597 pcmcia_program_voltage(PCMCIA_0V);
598 pcmcia_access_speed(PCMCIA_SPEED_250NS);
599 pcmcia_write_enable();
602 config = MANUAL_CONFIG;
604 /* get and write config byte to enable IO port */
606 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
609 config = tuple[2] & 0x3f;
612 offset = MANUAL_OFFSET;
614 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
617 offset_len = (tuple[2] & 0x3) + 1;
619 while(offset_len--) {
620 offset = (offset << 8) | tuple[4+offset_len];
624 out_8(GAYLE_ATTRIBUTE+offset, config);
629 MODULE_LICENSE("GPL");