?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ath9k: Move TX completion routine to xmit.c
[linux-2.6/verdex.git] / drivers / net / apne.c
blob7426f69406305821a931a1cd1566673d1f7ddcb3
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 (!MACH_IS_AMIGA)
131 return ERR_PTR(-ENODEV);
132
133 if (apne_owned)
134 return ERR_PTR(-ENODEV);
135
136 if ( !(AMIGAHW_PRESENT(PCMCIA)) )
137 return ERR_PTR(-ENODEV);
138
139 printk("Looking for PCMCIA ethernet card : ");
140
141 /* check if a card is inserted */
142 if (!(PCMCIA_INSERTED)) {
143 printk("NO PCMCIA card inserted\n");
144 return ERR_PTR(-ENODEV);
145 }
146
147 dev = alloc_ei_netdev();
148 if (!dev)
149 return ERR_PTR(-ENOMEM);
150 if (unit >= 0) {
151 sprintf(dev->name, "eth%d", unit);
152 netdev_boot_setup_check(dev);
153 }
154
155 /* disable pcmcia irq for readtuple */
156 pcmcia_disable_irq();
157
158 #ifndef MANUAL_CONFIG
159 if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
160 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
161 printk("not an ethernet card\n");
162 /* XXX: shouldn't we re-enable irq here? */
163 free_netdev(dev);
164 return ERR_PTR(-ENODEV);
165 }
166 #endif
167
168 printk("ethernet PCMCIA card inserted\n");
169
170 if (!init_pcmcia()) {
171 /* XXX: shouldn't we re-enable irq here? */
172 free_netdev(dev);
173 return ERR_PTR(-ENODEV);
174 }
175
176 if (!request_region(IOBASE, 0x20, DRV_NAME)) {
177 free_netdev(dev);
178 return ERR_PTR(-EBUSY);
179 }
180
181 err = apne_probe1(dev, IOBASE);
182 if (err) {
183 release_region(IOBASE, 0x20);
184 free_netdev(dev);
185 return ERR_PTR(err);
186 }
187 err = register_netdev(dev);
188 if (!err)
189 return dev;
190
191 pcmcia_disable_irq();
192 free_irq(IRQ_AMIGA_PORTS, dev);
193 pcmcia_reset();
194 release_region(IOBASE, 0x20);
195 free_netdev(dev);
196 return ERR_PTR(err);
197 }
198
199 static int __init apne_probe1(struct net_device *dev, int ioaddr)
200 {
201 int i;
202 unsigned char SA_prom[32];
203 int wordlength = 2;
204 const char *name = NULL;
205 int start_page, stop_page;
206 #ifndef MANUAL_HWADDR0
207 int neX000, ctron;
208 #endif
209 static unsigned version_printed;
210
211 if (ei_debug && version_printed++ == 0)
212 printk(version);
213
214 printk("PCMCIA NE*000 ethercard probe");
215
216 /* Reset card. Who knows what dain-bramaged state it was left in. */
217 { unsigned long reset_start_time = jiffies;
218
219 outb(inb(ioaddr + NE_RESET), ioaddr + NE_RESET);
220
221 while ((inb(ioaddr + NE_EN0_ISR) & ENISR_RESET) == 0)
222 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
223 printk(" not found (no reset ack).\n");
224 return -ENODEV;
225 }
226
227 outb(0xff, ioaddr + NE_EN0_ISR); /* Ack all intr. */
228 }
229
230 #ifndef MANUAL_HWADDR0
231
232 /* Read the 16 bytes of station address PROM.
233 We must first initialize registers, similar to NS8390_init(eifdev, 0).
234 We can't reliably read the SAPROM address without this.
235 (I learned the hard way!). */
236 {
237 struct {unsigned long value, offset; } program_seq[] = {
238 {E8390_NODMA+E8390_PAGE0+E8390_STOP, NE_CMD}, /* Select page 0*/
239 {0x48, NE_EN0_DCFG}, /* Set byte-wide (0x48) access. */
240 {0x00, NE_EN0_RCNTLO}, /* Clear the count regs. */
241 {0x00, NE_EN0_RCNTHI},
242 {0x00, NE_EN0_IMR}, /* Mask completion irq. */
243 {0xFF, NE_EN0_ISR},
244 {E8390_RXOFF, NE_EN0_RXCR}, /* 0x20 Set to monitor */
245 {E8390_TXOFF, NE_EN0_TXCR}, /* 0x02 and loopback mode. */
246 {32, NE_EN0_RCNTLO},
247 {0x00, NE_EN0_RCNTHI},
248 {0x00, NE_EN0_RSARLO}, /* DMA starting at 0x0000. */
249 {0x00, NE_EN0_RSARHI},
250 {E8390_RREAD+E8390_START, NE_CMD},
251 };
252 for (i = 0; i < ARRAY_SIZE(program_seq); i++) {
253 outb(program_seq[i].value, ioaddr + program_seq[i].offset);
254 }
255
256 }
257 for(i = 0; i < 32 /*sizeof(SA_prom)*/; i+=2) {
258 SA_prom[i] = inb(ioaddr + NE_DATAPORT);
259 SA_prom[i+1] = inb(ioaddr + NE_DATAPORT);
260 if (SA_prom[i] != SA_prom[i+1])
261 wordlength = 1;
262 }
263
264 /* At this point, wordlength *only* tells us if the SA_prom is doubled
265 up or not because some broken PCI cards don't respect the byte-wide
266 request in program_seq above, and hence don't have doubled up values.
267 These broken cards would otherwise be detected as an ne1000. */
268
269 if (wordlength == 2)
270 for (i = 0; i < 16; i++)
271 SA_prom[i] = SA_prom[i+i];
272
273 if (wordlength == 2) {
274 /* We must set the 8390 for word mode. */
275 outb(0x49, ioaddr + NE_EN0_DCFG);
276 start_page = NESM_START_PG;
277 stop_page = NESM_STOP_PG;
278 } else {
279 start_page = NE1SM_START_PG;
280 stop_page = NE1SM_STOP_PG;
281 }
282
283 neX000 = (SA_prom[14] == 0x57 && SA_prom[15] == 0x57);
284 ctron = (SA_prom[0] == 0x00 && SA_prom[1] == 0x00 && SA_prom[2] == 0x1d);
285
286 /* Set up the rest of the parameters. */
287 if (neX000) {
288 name = (wordlength == 2) ? "NE2000" : "NE1000";
289 } else if (ctron) {
290 name = (wordlength == 2) ? "Ctron-8" : "Ctron-16";
291 start_page = 0x01;
292 stop_page = (wordlength == 2) ? 0x40 : 0x20;
293 } else {
294 printk(" not found.\n");
295 return -ENXIO;
296
297 }
298
299 #else
300 wordlength = 2;
301 /* We must set the 8390 for word mode. */
302 outb(0x49, ioaddr + NE_EN0_DCFG);
303 start_page = NESM_START_PG;
304 stop_page = NESM_STOP_PG;
305
306 SA_prom[0] = MANUAL_HWADDR0;
307 SA_prom[1] = MANUAL_HWADDR1;
308 SA_prom[2] = MANUAL_HWADDR2;
309 SA_prom[3] = MANUAL_HWADDR3;
310 SA_prom[4] = MANUAL_HWADDR4;
311 SA_prom[5] = MANUAL_HWADDR5;
312 name = "NE2000";
313 #endif
314
315 dev->base_addr = ioaddr;
316 dev->irq = IRQ_AMIGA_PORTS;
317
318 /* Install the Interrupt handler */
319 i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
320 if (i) return i;
321
322 for(i = 0; i < ETHER_ADDR_LEN; i++)
323 dev->dev_addr[i] = SA_prom[i];
324
325 printk(" %pM\n", dev->dev_addr);
326
327 printk("%s: %s found.\n", dev->name, name);
328
329 ei_status.name = name;
330 ei_status.tx_start_page = start_page;
331 ei_status.stop_page = stop_page;
332 ei_status.word16 = (wordlength == 2);
333
334 ei_status.rx_start_page = start_page + TX_PAGES;
335
336 ei_status.reset_8390 = &apne_reset_8390;
337 ei_status.block_input = &apne_block_input;
338 ei_status.block_output = &apne_block_output;
339 ei_status.get_8390_hdr = &apne_get_8390_hdr;
340 dev->open = &apne_open;
341 dev->stop = &apne_close;
342 #ifdef CONFIG_NET_POLL_CONTROLLER
343 dev->poll_controller = ei_poll;
344 #endif
345 NS8390_init(dev, 0);
346
347 pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
348 pcmcia_enable_irq();
349
350 apne_owned = 1;
351
352 return 0;
353 }
354
355 static int
356 apne_open(struct net_device *dev)
357 {
358 ei_open(dev);
359 return 0;
360 }
361
362 static int
363 apne_close(struct net_device *dev)
364 {
365 if (ei_debug > 1)
366 printk("%s: Shutting down ethercard.\n", dev->name);
367 ei_close(dev);
368 return 0;
369 }
370
371 /* Hard reset the card. This used to pause for the same period that a
372 8390 reset command required, but that shouldn't be necessary. */
373 static void
374 apne_reset_8390(struct net_device *dev)
375 {
376 unsigned long reset_start_time = jiffies;
377
378 init_pcmcia();
379
380 if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
381
382 outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
383
384 ei_status.txing = 0;
385 ei_status.dmaing = 0;
386
387 /* This check _should_not_ be necessary, omit eventually. */
388 while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
389 if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
390 printk("%s: ne_reset_8390() did not complete.\n", dev->name);
391 break;
392 }
393 outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
394 }
395
396 /* Grab the 8390 specific header. Similar to the block_input routine, but
397 we don't need to be concerned with ring wrap as the header will be at
398 the start of a page, so we optimize accordingly. */
399
400 static void
401 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
402 {
403
404 int nic_base = dev->base_addr;
405 int cnt;
406 char *ptrc;
407 short *ptrs;
408
409 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
410 if (ei_status.dmaing) {
411 printk("%s: DMAing conflict in ne_get_8390_hdr "
412 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
413 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
414 return;
415 }
416
417 ei_status.dmaing |= 0x01;
418 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
419 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
420 outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
421 outb(0, nic_base + NE_EN0_RCNTHI);
422 outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
423 outb(ring_page, nic_base + NE_EN0_RSARHI);
424 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
425
426 if (ei_status.word16) {
427 ptrs = (short*)hdr;
428 for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
429 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
430 } else {
431 ptrc = (char*)hdr;
432 for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
433 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
434 }
435
436 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
437 ei_status.dmaing &= ~0x01;
438
439 le16_to_cpus(&hdr->count);
440 }
441
442 /* Block input and output, similar to the Crynwr packet driver. If you
443 are porting to a new ethercard, look at the packet driver source for hints.
444 The NEx000 doesn't share the on-board packet memory -- you have to put
445 the packet out through the "remote DMA" dataport using outb. */
446
447 static void
448 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
449 {
450 int nic_base = dev->base_addr;
451 char *buf = skb->data;
452 char *ptrc;
453 short *ptrs;
454 int cnt;
455
456 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
457 if (ei_status.dmaing) {
458 printk("%s: DMAing conflict in ne_block_input "
459 "[DMAstat:%d][irqlock:%d][intr:%d].\n",
460 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
461 return;
462 }
463 ei_status.dmaing |= 0x01;
464 outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
465 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
466 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
467 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
468 outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
469 outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
470 outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
471 if (ei_status.word16) {
472 ptrs = (short*)buf;
473 for (cnt = 0; cnt < (count>>1); cnt++)
474 *ptrs++ = inw(NE_BASE + NE_DATAPORT);
475 if (count & 0x01) {
476 buf[count-1] = inb(NE_BASE + NE_DATAPORT);
477 }
478 } else {
479 ptrc = (char*)buf;
480 for (cnt = 0; cnt < count; cnt++)
481 *ptrc++ = inb(NE_BASE + NE_DATAPORT);
482 }
483
484 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
485 ei_status.dmaing &= ~0x01;
486 }
487
488 static void
489 apne_block_output(struct net_device *dev, int count,
490 const unsigned char *buf, const int start_page)
491 {
492 int nic_base = NE_BASE;
493 unsigned long dma_start;
494 char *ptrc;
495 short *ptrs;
496 int cnt;
497
498 /* Round the count up for word writes. Do we need to do this?
499 What effect will an odd byte count have on the 8390?
500 I should check someday. */
501 if (ei_status.word16 && (count & 0x01))
502 count++;
503
504 /* This *shouldn't* happen. If it does, it's the last thing you'll see */
505 if (ei_status.dmaing) {
506 printk("%s: DMAing conflict in ne_block_output."
507 "[DMAstat:%d][irqlock:%d][intr:%d]\n",
508 dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
509 return;
510 }
511 ei_status.dmaing |= 0x01;
512 /* We should already be in page 0, but to be safe... */
513 outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
514
515 outb(ENISR_RDC, nic_base + NE_EN0_ISR);
516
517 /* Now the normal output. */
518 outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
519 outb(count >> 8, nic_base + NE_EN0_RCNTHI);
520 outb(0x00, nic_base + NE_EN0_RSARLO);
521 outb(start_page, nic_base + NE_EN0_RSARHI);
522
523 outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
524 if (ei_status.word16) {
525 ptrs = (short*)buf;
526 for (cnt = 0; cnt < count>>1; cnt++)
527 outw(*ptrs++, NE_BASE+NE_DATAPORT);
528 } else {
529 ptrc = (char*)buf;
530 for (cnt = 0; cnt < count; cnt++)
531 outb(*ptrc++, NE_BASE + NE_DATAPORT);
532 }
533
534 dma_start = jiffies;
535
536 while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
537 if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
538 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
539 apne_reset_8390(dev);
540 NS8390_init(dev,1);
541 break;
542 }
543
544 outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
545 ei_status.dmaing &= ~0x01;
546 return;
547 }
548
549 static irqreturn_t apne_interrupt(int irq, void *dev_id)
550 {
551 unsigned char pcmcia_intreq;
552
553 if (!(gayle.inten & GAYLE_IRQ_IRQ))
554 return IRQ_NONE;
555
556 pcmcia_intreq = pcmcia_get_intreq();
557
558 if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
559 pcmcia_ack_int(pcmcia_intreq);
560 return IRQ_NONE;
561 }
562 if (ei_debug > 3)
563 printk("pcmcia intreq = %x\n", pcmcia_intreq);
564 pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
565 ei_interrupt(irq, dev_id);
566 pcmcia_ack_int(pcmcia_get_intreq());
567 pcmcia_enable_irq();
568 return IRQ_HANDLED;
569 }
570
571 #ifdef MODULE
572 static struct net_device *apne_dev;
573
574 static int __init apne_module_init(void)
575 {
576 apne_dev = apne_probe(-1);
577 if (IS_ERR(apne_dev))
578 return PTR_ERR(apne_dev);
579 return 0;
580 }
581
582 static void __exit apne_module_exit(void)
583 {
584 unregister_netdev(apne_dev);
585
586 pcmcia_disable_irq();
587
588 free_irq(IRQ_AMIGA_PORTS, apne_dev);
589
590 pcmcia_reset();
591
592 release_region(IOBASE, 0x20);
593
594 free_netdev(apne_dev);
595 }
596 module_init(apne_module_init);
597 module_exit(apne_module_exit);
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 out_8(GAYLE_ATTRIBUTE+offset, config);
638
639 return 1;
640 }
641
642 MODULE_LICENSE("GPL");
Verdex Pro support