?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Committer: Michael Beasley <mike@snafu.setup>
[mikesnafu-overlay.git] / drivers / net / apne.c
blob47a8275d396281bd79f6a2631dbfd1da93273529
1 /*
2 * Amiga Linux/68k 8390 based PCMCIA Ethernet Driver for the Amiga 1200
3 *
4 * (C) Copyright 1997 Alain Malek
5 * (Alain.Malek@cryogen.com)
6 *
7 * ----------------------------------------------------------------------------
8 *
9 * This program is based on
10 *
11 * ne.c: A general non-shared-memory NS8390 ethernet driver for linux
12 * Written 1992-94 by Donald Becker.
13 *
14 * 8390.c: A general NS8390 ethernet driver core for linux.
15 * Written 1992-94 by Donald Becker.
16 *
17 * cnetdevice: A Sana-II ethernet driver for AmigaOS
18 * Written by Bruce Abbott (bhabbott@inhb.co.nz)
19 *
20 * ----------------------------------------------------------------------------
21 *
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.
25 *
26 * ----------------------------------------------------------------------------
27 *
28 */
29
30
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/jiffies.h>
40
41 #include <asm/system.h>
42 #include <asm/io.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>
48
49 #include "8390.h"
50
51 /* ---- No user-serviceable parts below ---- */
52
53 #define DRV_NAME "apne"
54
55 #define NE_BASE (dev->base_addr)
56 #define NE_CMD 0x00
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
60
61 #define NE_EN0_ISR 0x07
62 #define NE_EN0_DCFG 0x0e
63
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
71
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 */
76
77
78 struct net_device * __init apne_probe(int unit);
79 static int apne_probe1(struct net_device *dev, int ioaddr);
80
81 static int apne_open(struct net_device *dev);
82 static int apne_close(struct net_device *dev);
83
84 static void apne_reset_8390(struct net_device *dev);
85 static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
86 int ring_page);
87 static void apne_block_input(struct net_device *dev, int count,
88 struct sk_buff *skb, int ring_offset);
89 static void apne_block_output(struct net_device *dev, const int count,
90 const unsigned char *buf, const int start_page);
91 static irqreturn_t apne_interrupt(int irq, void *dev_id);
92
93 static int init_pcmcia(void);
94
95 /* IO base address used for nic */
96
97 #define IOBASE 0x300
98
99 /*
100 use MANUAL_CONFIG and MANUAL_OFFSET for enabling IO by hand
101 you can find the values to use by looking at the cnet.device
102 config file example (the default values are for the CNET40BC card)
103 */
104
105 /*
106 #define MANUAL_CONFIG 0x20
107 #define MANUAL_OFFSET 0x3f8
108
109 #define MANUAL_HWADDR0 0x00
110 #define MANUAL_HWADDR1 0x12
111 #define MANUAL_HWADDR2 0x34
112 #define MANUAL_HWADDR3 0x56
113 #define MANUAL_HWADDR4 0x78
114 #define MANUAL_HWADDR5 0x9a
115 */
116
117 static const char version[] =
118 "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
119
120 static int apne_owned; /* signal if card already owned */
121
122 struct net_device * __init apne_probe(int unit)
123 {
124 struct net_device *dev;
125 #ifndef MANUAL_CONFIG
126 char tuple[8];
127 #endif
128 int err;
129
130 if (apne_owned)
131 return ERR_PTR(-ENODEV);
132
133 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
134 return ERR_PTR(-ENODEV);
135
136 printk("Looking for PCMCIA ethernet card : ");
137
138 /* check if a card is inserted */
139 if (!(PCMCIA_INSERTED)) {
140 printk("NO PCMCIA card inserted\n");
141 return ERR_PTR(-ENODEV);
142 }
143
144 dev = alloc_ei_netdev();
145 if (!dev)
146 return ERR_PTR(-ENOMEM);
147 if (unit >= 0) {
148 sprintf(dev->name, "eth%d", unit);
149 netdev_boot_setup_check(dev);
150 }
151
152 /* disable pcmcia irq for readtuple */
153 pcmcia_disable_irq();
154
155 #ifndef MANUAL_CONFIG
156 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
157 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
158 printk("not an ethernet card\n");
159 /* XXX: shouldn't we re-enable irq here? */
160 free_netdev(dev);
161 return ERR_PTR(-ENODEV);
162 }
163 #endif
164
165 printk("ethernet PCMCIA card inserted\n");
166
167 if (!init_pcmcia()) {
168 /* XXX: shouldn't we re-enable irq here? */
169 free_netdev(dev);
170 return ERR_PTR(-ENODEV);
171 }
172
173 if (!request_region(IOBASE, 0x20, DRV_NAME)) {
174 free_netdev(dev);
175 return ERR_PTR(-EBUSY);
176 }
177
178 err = apne_probe1(dev, IOBASE);
179 if (err) {
180 release_region(IOBASE, 0x20);
181 free_netdev(dev);
182 return ERR_PTR(err);
183 }
184 err = register_netdev(dev);
185 if (!err)
186 return dev;
187
188 pcmcia_disable_irq();
189 free_irq(IRQ_AMIGA_PORTS, dev);
190 pcmcia_reset();
191 release_region(IOBASE, 0x20);
192 free_netdev(dev);
193 return ERR_PTR(err);
194 }
195
196 static int __init apne_probe1(struct net_device *dev, int ioaddr)
197 {
198 int i;
199 unsigned char SA_prom[32];
200 int wordlength = 2;
201 const char *name = NULL;
202 int start_page, stop_page;
203 #ifndef MANUAL_HWADDR0
204 int neX000, ctron;
205 #endif
206 static unsigned version_printed;
207 DECLARE_MAC_BUF(mac);
208
209 if (ei_debug && version_printed++ == 0)
210 printk(version);
211
212 printk("PCMCIA NE*000 ethercard probe");
213
214 /* Reset card. Who knows what dain-bramaged state it was left in. */
215 { unsigned long reset_start_time = jiffies;
216
217 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
218
219 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
220 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
221 printk(" not found (no reset ack).\n");
222 return -ENODEV;
223 }
224
225 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
226 }
227
228 #ifndef MANUAL_HWADDR0
229
230 /* Read the 16 bytes of station address PROM.
231 We must first initialize registers, similar to NS8390_init(eifdev, 0).
232 We can't reliably read the SAPROM address without this.
233 (I learned the hard way!). */
234 {
235 struct {unsigned long value, offset; } program_seq[] = {
236 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
237 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
238 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
239 {0x00, NE_EN0_RCNTHI},
240 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
241 {0xFF, NE_EN0_ISR},
242 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
243 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
244 {32, NE_EN0_RCNTLO},
245 {0x00, NE_EN0_RCNTHI},
246 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
247 {0x00, NE_EN0_RSARHI},
248 {E8390_RREAD+E8390_START, NE_CMD},
249 };
250 for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
251 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
252 }
253
254 }
255 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
256 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
257 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
258 if (SA_prom[i] != SA_prom[i+1])
259 wordlength = 1;
260 }
261
262 /* At this point, wordlength *only* tells us if the SA_prom is doubled
263 up or not because some broken PCI cards don't respect the byte-wide
264 request in program_seq above, and hence don't have doubled up values.
265 These broken cards would otherwise be detected as an ne1000. */
266
267 if (wordlength == 2)
268 for (i = 0; i < 16; i++)
269 SA_prom[i] = SA_prom[i+i];
270
271 if (wordlength == 2) {
272 /* We must set the 8390 for word mode. */
273 outb(0x49, ioaddr + NE_EN0_DCFG);
274 start_page = NESM_START_PG;
275 stop_page = NESM_STOP_PG;
276 } else {
277 start_page = NE1SM_START_PG;
278 stop_page = NE1SM_STOP_PG;
279 }
280
281 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
282 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
283
284 /* Set up the rest of the parameters. */
285 if (neX000) {
286 name = (wordlength == 2) ? "NE2000" : "NE1000";
287 } else if (ctron) {
288 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
289 start_page = 0x01;
290 stop_page = (wordlength == 2) ? 0x40 : 0x20;
291 } else {
292 printk(" not found.\n");
293 return -ENXIO;
294
295 }
296
297 #else
298 wordlength = 2;
299 /* We must set the 8390 for word mode. */
300 outb(0x49, ioaddr + NE_EN0_DCFG);
301 start_page = NESM_START_PG;
302 stop_page = NESM_STOP_PG;
303
304 SA_prom[0] = MANUAL_HWADDR0;
305 SA_prom[1] = MANUAL_HWADDR1;
306 SA_prom[2] = MANUAL_HWADDR2;
307 SA_prom[3] = MANUAL_HWADDR3;
308 SA_prom[4] = MANUAL_HWADDR4;
309 SA_prom[5] = MANUAL_HWADDR5;
310 name = "NE2000";
311 #endif
312
313 dev->base_addr = ioaddr;
314 dev->irq = IRQ_AMIGA_PORTS;
315
316 /* Install the Interrupt handler */
317 i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
318 if (i) return i;
319
320 for(i = 0; i < ETHER_ADDR_LEN; i++)
321 dev->dev_addr[i] = SA_prom[i];
322
323 printk(" %s\n", print_mac(mac, dev->dev_addr));
324
325 printk("%s: %s found.\n", dev->name, name);
326
327 ei_status.name = name;
328 ei_status.tx_start_page = start_page;
329 ei_status.stop_page = stop_page;
330 ei_status.word16 = (wordlength == 2);
331
332 ei_status.rx_start_page = start_page + TX_PAGES;
333
334 ei_status.reset_8390 = &apne_reset_8390;
335 ei_status.block_input = &apne_block_input;
336 ei_status.block_output = &apne_block_output;
337 ei_status.get_8390_hdr = &apne_get_8390_hdr;
338 dev->open = &apne_open;
339 dev->stop = &apne_close;
340 #ifdef CONFIG_NET_POLL_CONTROLLER
341 dev->poll_controller = ei_poll;
342 #endif
343 NS8390_init(dev, 0);
344
345 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
346 pcmcia_enable_irq();
347
348 apne_owned = 1;
349
350 return 0;
351 }
352
353 static int
354 apne_open(struct net_device *dev)
355 {
356 ei_open(dev);
357 return 0;
358 }
359
360 static int
361 apne_close(struct net_device *dev)
362 {
363 if (ei_debug > 1)
364 printk("%s: Shutting down ethercard.\n", dev->name);
365 ei_close(dev);
366 return 0;
367 }
368
369 /* Hard reset the card. This used to pause for the same period that a
370 8390 reset command required, but that shouldn't be necessary. */
371 static void
372 apne_reset_8390(struct net_device *dev)
373 {
374 unsigned long reset_start_time = jiffies;
375
376 init_pcmcia();
377
378 if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
379
380 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
381
382 ei_status.txing = 0;
383 ei_status.dmaing = 0;
384
385 /* This check _should_not_ be necessary, omit eventually. */
386 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
387 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
388 printk("%s: ne_reset_8390() did not complete.\n", dev->name);
389 break;
390 }
391 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
392 }
393
394 /* Grab the 8390 specific header. Similar to the block_input routine, but
395 we don't need to be concerned with ring wrap as the header will be at
396 the start of a page, so we optimize accordingly. */
397
398 static void
399 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
400 {
401
402 int nic_base = dev->base_addr;
403 int cnt;
404 char *ptrc;
405 short *ptrs;
406
407 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
408 if (ei_status.dmaing) {
409 printk("%s: DMAing conflict in ne_get_8390_hdr "
410 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
411 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
412 return;
413 }
414
415 ei_status.dmaing |= 0x01;
416 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
417 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
418 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
419 outb(0, nic_base + NE_EN0_RCNTHI);
420 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
421 outb(ring_page, nic_base + NE_EN0_RSARHI);
422 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
423
424 if (ei_status.word16) {
425 ptrs = (short*)hdr;
426 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
427 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
428 } else {
429 ptrc = (char*)hdr;
430 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
431 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
432 }
433
434 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
435 ei_status.dmaing &= ~0x01;
436
437 le16_to_cpus(&hdr->count);
438 }
439
440 /* Block input and output, similar to the Crynwr packet driver. If you
441 are porting to a new ethercard, look at the packet driver source for hints.
442 The NEx000 doesn't share the on-board packet memory -- you have to put
443 the packet out through the "remote DMA" dataport using outb. */
444
445 static void
446 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
447 {
448 int nic_base = dev->base_addr;
449 char *buf = skb->data;
450 char *ptrc;
451 short *ptrs;
452 int cnt;
453
454 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
455 if (ei_status.dmaing) {
456 printk("%s: DMAing conflict in ne_block_input "
457 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
458 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
459 return;
460 }
461 ei_status.dmaing |= 0x01;
462 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
463 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
464 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
465 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
466 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
467 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
468 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
469 if (ei_status.word16) {
470 ptrs = (short*)buf;
471 for (cnt = 0; cnt < (count>>1); cnt++)
472 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
473 if (count & 0x01) {
474 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
475 }
476 } else {
477 ptrc = (char*)buf;
478 for (cnt = 0; cnt < count; cnt++)
479 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
480 }
481
482 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
483 ei_status.dmaing &= ~0x01;
484 }
485
486 static void
487 apne_block_output(struct net_device *dev, int count,
488 const unsigned char *buf, const int start_page)
489 {
490 int nic_base = NE_BASE;
491 unsigned long dma_start;
492 char *ptrc;
493 short *ptrs;
494 int cnt;
495
496 /* Round the count up for word writes. Do we need to do this?
497 What effect will an odd byte count have on the 8390?
498 I should check someday. */
499 if (ei_status.word16 && (count & 0x01))
500 count++;
501
502 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
503 if (ei_status.dmaing) {
504 printk("%s: DMAing conflict in ne_block_output."
505 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
506 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
507 return;
508 }
509 ei_status.dmaing |= 0x01;
510 /* We should already be in page 0, but to be safe... */
511 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
512
513 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
514
515 /* Now the normal output. */
516 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
517 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
518 outb(0x00, nic_base + NE_EN0_RSARLO);
519 outb(start_page, nic_base + NE_EN0_RSARHI);
520
521 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
522 if (ei_status.word16) {
523 ptrs = (short*)buf;
524 for (cnt = 0; cnt < count>>1; cnt++)
525 outw(*ptrs++, NE_BASE+NE_DATAPORT);
526 } else {
527 ptrc = (char*)buf;
528 for (cnt = 0; cnt < count; cnt++)
529 outb(*ptrc++, NE_BASE + NE_DATAPORT);
530 }
531
532 dma_start = jiffies;
533
534 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
535 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
536 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
537 apne_reset_8390(dev);
538 NS8390_init(dev,1);
539 break;
540 }
541
542 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
543 ei_status.dmaing &= ~0x01;
544 return;
545 }
546
547 static irqreturn_t apne_interrupt(int irq, void *dev_id)
548 {
549 unsigned char pcmcia_intreq;
550
551 if (!(gayle.inten & GAYLE_IRQ_IRQ))
552 return IRQ_NONE;
553
554 pcmcia_intreq = pcmcia_get_intreq();
555
556 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
557 pcmcia_ack_int(pcmcia_intreq);
558 return IRQ_NONE;
559 }
560 if (ei_debug > 3)
561 printk("pcmcia intreq = %x\n", pcmcia_intreq);
562 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
563 ei_interrupt(irq, dev_id);
564 pcmcia_ack_int(pcmcia_get_intreq());
565 pcmcia_enable_irq();
566 return IRQ_HANDLED;
567 }
568
569 #ifdef MODULE
570 static struct net_device *apne_dev;
571
572 static int __init apne_module_init(void)
573 {
574 apne_dev = apne_probe(-1);
575 if (IS_ERR(apne_dev))
576 return PTR_ERR(apne_dev);
577 return 0;
578 }
579
580 static void __exit apne_module_exit(void)
581 {
582 unregister_netdev(apne_dev);
583
584 pcmcia_disable_irq();
585
586 free_irq(IRQ_AMIGA_PORTS, apne_dev);
587
588 pcmcia_reset();
589
590 release_region(IOBASE, 0x20);
591
592 free_netdev(apne_dev);
593 }
594 module_init(apne_module_init);
595 module_exit(apne_module_exit);
596 #endif
597
598 static int init_pcmcia(void)
599 {
600 u_char config;
601 #ifndef MANUAL_CONFIG
602 u_char tuple[32];
603 int offset_len;
604 #endif
605 u_long offset;
606
607 pcmcia_reset();
608 pcmcia_program_voltage(PCMCIA_0V);
609 pcmcia_access_speed(PCMCIA_SPEED_250NS);
610 pcmcia_write_enable();
611
612 #ifdef MANUAL_CONFIG
613 config = MANUAL_CONFIG;
614 #else
615 /* get and write config byte to enable IO port */
616
617 if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
618 return 0;
619
620 config = tuple[2] & 0x3f;
621 #endif
622 #ifdef MANUAL_OFFSET
623 offset = MANUAL_OFFSET;
624 #else
625 if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
626 return 0;
627
628 offset_len = (tuple[2] & 0x3) + 1;
629 offset = 0;
630 while(offset_len--) {
631 offset = (offset << 8) | tuple[4+offset_len];
632 }
633 #endif
634
635 out_8(GAYLE_ATTRIBUTE+offset, config);
636
637 return 1;
638 }
639
640 MODULE_LICENSE("GPL");
mah project overlay