[PATCH] irq-flags: drivers/net: Use the new IRQF_ constants
[linux-2.6.git] / drivers / net / apne.c
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, struct pt_regs *regs);
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         SET_MODULE_OWNER(dev);
152
153         /* disable pcmcia irq for readtuple */
154         pcmcia_disable_irq();
155
156 #ifndef MANUAL_CONFIG
157         if ((pcmcia_copy_tuple(CISTPL_FUNCID, tuple, 8) < 3) ||
158                 (tuple[2] != CISTPL_FUNCID_NETWORK)) {
159                 printk("not an ethernet card\n");
160                 /* XXX: shouldn't we re-enable irq here? */
161                 free_netdev(dev);
162                 return ERR_PTR(-ENODEV);
163         }
164 #endif
165
166         printk("ethernet PCMCIA card inserted\n");
167
168         if (!init_pcmcia()) {
169                 /* XXX: shouldn't we re-enable irq here? */
170                 free_netdev(dev);
171                 return ERR_PTR(-ENODEV);
172         }
173
174         if (!request_region(IOBASE, 0x20, DRV_NAME)) {
175                 free_netdev(dev);
176                 return ERR_PTR(-EBUSY);
177         }
178
179         err = apne_probe1(dev, IOBASE);
180         if (err) {
181                 release_region(IOBASE, 0x20);
182                 free_netdev(dev);
183                 return ERR_PTR(err);
184         }
185         err = register_netdev(dev);
186         if (!err)
187                 return dev;
188
189         pcmcia_disable_irq();
190         free_irq(IRQ_AMIGA_PORTS, dev);
191         pcmcia_reset();
192         release_region(IOBASE, 0x20);
193         free_netdev(dev);
194         return ERR_PTR(err);
195 }
196
197 static int __init apne_probe1(struct net_device *dev, int ioaddr)
198 {
199     int i;
200     unsigned char SA_prom[32];
201     int wordlength = 2;
202     const char *name = NULL;
203     int start_page, stop_page;
204 #ifndef MANUAL_HWADDR0
205     int neX000, ctron;
206 #endif
207     static unsigned version_printed;
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 < sizeof(program_seq)/sizeof(program_seq[0]); 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
315     /* Install the Interrupt handler */
316     i = request_irq(IRQ_AMIGA_PORTS, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
317     if (i) return i;
318
319     for(i = 0; i < ETHER_ADDR_LEN; i++) {
320         printk(" %2.2x", SA_prom[i]);
321         dev->dev_addr[i] = SA_prom[i];
322     }
323
324     printk("\n%s: %s found.\n", dev->name, name);
325
326     ei_status.name = name;
327     ei_status.tx_start_page = start_page;
328     ei_status.stop_page = stop_page;
329     ei_status.word16 = (wordlength == 2);
330
331     ei_status.rx_start_page = start_page + TX_PAGES;
332
333     ei_status.reset_8390 = &apne_reset_8390;
334     ei_status.block_input = &apne_block_input;
335     ei_status.block_output = &apne_block_output;
336     ei_status.get_8390_hdr = &apne_get_8390_hdr;
337     dev->open = &apne_open;
338     dev->stop = &apne_close;
339 #ifdef CONFIG_NET_POLL_CONTROLLER
340     dev->poll_controller = ei_poll;
341 #endif
342     NS8390_init(dev, 0);
343
344     pcmcia_ack_int(pcmcia_get_intreq());                /* ack PCMCIA int req */
345     pcmcia_enable_irq();
346
347     apne_owned = 1;
348
349     return 0;
350 }
351
352 static int
353 apne_open(struct net_device *dev)
354 {
355     ei_open(dev);
356     return 0;
357 }
358
359 static int
360 apne_close(struct net_device *dev)
361 {
362     if (ei_debug > 1)
363         printk("%s: Shutting down ethercard.\n", dev->name);
364     ei_close(dev);
365     return 0;
366 }
367
368 /* Hard reset the card.  This used to pause for the same period that a
369    8390 reset command required, but that shouldn't be necessary. */
370 static void
371 apne_reset_8390(struct net_device *dev)
372 {
373     unsigned long reset_start_time = jiffies;
374
375     init_pcmcia();
376
377     if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
378
379     outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
380
381     ei_status.txing = 0;
382     ei_status.dmaing = 0;
383
384     /* This check _should_not_ be necessary, omit eventually. */
385     while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
386         if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
387             printk("%s: ne_reset_8390() did not complete.\n", dev->name);
388             break;
389         }
390     outb(ENISR_RESET, NE_BASE + NE_EN0_ISR);    /* Ack intr. */
391 }
392
393 /* Grab the 8390 specific header. Similar to the block_input routine, but
394    we don't need to be concerned with ring wrap as the header will be at
395    the start of a page, so we optimize accordingly. */
396
397 static void
398 apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
399 {
400
401     int nic_base = dev->base_addr;
402     int cnt;
403     char *ptrc;
404     short *ptrs;
405
406     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
407     if (ei_status.dmaing) {
408         printk("%s: DMAing conflict in ne_get_8390_hdr "
409            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
410            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
411         return;
412     }
413
414     ei_status.dmaing |= 0x01;
415     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
416     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
417     outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
418     outb(0, nic_base + NE_EN0_RCNTHI);
419     outb(0, nic_base + NE_EN0_RSARLO);          /* On page boundary */
420     outb(ring_page, nic_base + NE_EN0_RSARHI);
421     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
422
423     if (ei_status.word16) {
424         ptrs = (short*)hdr;
425         for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
426             *ptrs++ = inw(NE_BASE + NE_DATAPORT);
427     } else {
428         ptrc = (char*)hdr;
429         for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
430             *ptrc++ = inb(NE_BASE + NE_DATAPORT);
431     }
432
433     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
434     ei_status.dmaing &= ~0x01;
435
436     le16_to_cpus(&hdr->count);
437 }
438
439 /* Block input and output, similar to the Crynwr packet driver.  If you
440    are porting to a new ethercard, look at the packet driver source for hints.
441    The NEx000 doesn't share the on-board packet memory -- you have to put
442    the packet out through the "remote DMA" dataport using outb. */
443
444 static void
445 apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
446 {
447     int nic_base = dev->base_addr;
448     char *buf = skb->data;
449     char *ptrc;
450     short *ptrs;
451     int cnt;
452
453     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
454     if (ei_status.dmaing) {
455         printk("%s: DMAing conflict in ne_block_input "
456            "[DMAstat:%d][irqlock:%d][intr:%d].\n",
457            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
458         return;
459     }
460     ei_status.dmaing |= 0x01;
461     outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
462     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
463     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
464     outb(count >> 8, nic_base + NE_EN0_RCNTHI);
465     outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
466     outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
467     outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
468     if (ei_status.word16) {
469       ptrs = (short*)buf;
470       for (cnt = 0; cnt < (count>>1); cnt++)
471         *ptrs++ = inw(NE_BASE + NE_DATAPORT);
472       if (count & 0x01) {
473         buf[count-1] = inb(NE_BASE + NE_DATAPORT);
474       }
475     } else {
476       ptrc = (char*)buf;
477       for (cnt = 0; cnt < count; cnt++)
478         *ptrc++ = inb(NE_BASE + NE_DATAPORT);
479     }
480
481     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
482     ei_status.dmaing &= ~0x01;
483 }
484
485 static void
486 apne_block_output(struct net_device *dev, int count,
487                 const unsigned char *buf, const int start_page)
488 {
489     int nic_base = NE_BASE;
490     unsigned long dma_start;
491     char *ptrc;
492     short *ptrs;
493     int cnt;
494
495     /* Round the count up for word writes.  Do we need to do this?
496        What effect will an odd byte count have on the 8390?
497        I should check someday. */
498     if (ei_status.word16 && (count & 0x01))
499       count++;
500
501     /* This *shouldn't* happen. If it does, it's the last thing you'll see */
502     if (ei_status.dmaing) {
503         printk("%s: DMAing conflict in ne_block_output."
504            "[DMAstat:%d][irqlock:%d][intr:%d]\n",
505            dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
506         return;
507     }
508     ei_status.dmaing |= 0x01;
509     /* We should already be in page 0, but to be safe... */
510     outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
511
512     outb(ENISR_RDC, nic_base + NE_EN0_ISR);
513
514    /* Now the normal output. */
515     outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
516     outb(count >> 8,   nic_base + NE_EN0_RCNTHI);
517     outb(0x00, nic_base + NE_EN0_RSARLO);
518     outb(start_page, nic_base + NE_EN0_RSARHI);
519
520     outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
521     if (ei_status.word16) {
522         ptrs = (short*)buf;
523         for (cnt = 0; cnt < count>>1; cnt++)
524             outw(*ptrs++, NE_BASE+NE_DATAPORT);
525     } else {
526         ptrc = (char*)buf;
527         for (cnt = 0; cnt < count; cnt++)
528             outb(*ptrc++, NE_BASE + NE_DATAPORT);
529     }
530
531     dma_start = jiffies;
532
533     while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
534         if (time_after(jiffies, dma_start + 2*HZ/100)) {        /* 20ms */
535                 printk("%s: timeout waiting for Tx RDC.\n", dev->name);
536                 apne_reset_8390(dev);
537                 NS8390_init(dev,1);
538                 break;
539         }
540
541     outb(ENISR_RDC, nic_base + NE_EN0_ISR);     /* Ack intr. */
542     ei_status.dmaing &= ~0x01;
543     return;
544 }
545
546 static irqreturn_t apne_interrupt(int irq, void *dev_id, struct pt_regs *regs)
547 {
548     unsigned char pcmcia_intreq;
549
550     if (!(gayle.inten & GAYLE_IRQ_IRQ))
551         return IRQ_NONE;
552
553     pcmcia_intreq = pcmcia_get_intreq();
554
555     if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
556         pcmcia_ack_int(pcmcia_intreq);
557         return IRQ_NONE;
558     }
559     if (ei_debug > 3)
560         printk("pcmcia intreq = %x\n", pcmcia_intreq);
561     pcmcia_disable_irq();                       /* to get rid of the sti() within ei_interrupt */
562     ei_interrupt(irq, dev_id, regs);
563     pcmcia_ack_int(pcmcia_get_intreq());
564     pcmcia_enable_irq();
565     return IRQ_HANDLED;
566 }
567
568 #ifdef MODULE
569 static struct net_device *apne_dev;
570
571 int init_module(void)
572 {
573         apne_dev = apne_probe(-1);
574         if (IS_ERR(apne_dev))
575                 return PTR_ERR(apne_dev);
576         return 0;
577 }
578
579 void cleanup_module(void)
580 {
581         unregister_netdev(apne_dev);
582
583         pcmcia_disable_irq();
584
585         free_irq(IRQ_AMIGA_PORTS, apne_dev);
586
587         pcmcia_reset();
588
589         release_region(IOBASE, 0x20);
590
591         free_netdev(apne_dev);
592 }
593
594 #endif
595
596 static int init_pcmcia(void)
597 {
598         u_char config;
599 #ifndef MANUAL_CONFIG
600         u_char tuple[32];
601         int offset_len;
602 #endif
603         u_long offset;
604
605         pcmcia_reset();
606         pcmcia_program_voltage(PCMCIA_0V);
607         pcmcia_access_speed(PCMCIA_SPEED_250NS);
608         pcmcia_write_enable();
609
610 #ifdef MANUAL_CONFIG
611         config = MANUAL_CONFIG;
612 #else
613         /* get and write config byte to enable IO port */
614
615         if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
616                 return 0;
617
618         config = tuple[2] & 0x3f;
619 #endif
620 #ifdef MANUAL_OFFSET
621         offset = MANUAL_OFFSET;
622 #else
623         if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
624                 return 0;
625
626         offset_len = (tuple[2] & 0x3) + 1;
627         offset = 0;
628         while(offset_len--) {
629                 offset = (offset << 8) | tuple[4+offset_len];
630         }
631 #endif
632
633         out_8(GAYLE_ATTRIBUTE+offset, config);
634
635         return 1;
636 }
637
638 MODULE_LICENSE("GPL");