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