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