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