Root/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
78struct net_device * __init apne_probe(int unit);
79static int apne_probe1(struct net_device *dev, int ioaddr);
80
81static void apne_reset_8390(struct net_device *dev);
82static void apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
83              int ring_page);
84static void apne_block_input(struct net_device *dev, int count,
85                                struct sk_buff *skb, int ring_offset);
86static void apne_block_output(struct net_device *dev, const int count,
87                            const unsigned char *buf, const int start_page);
88static irqreturn_t apne_interrupt(int irq, void *dev_id);
89
90static 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
114static const char version[] =
115    "apne.c:v1.1 7/10/98 Alain Malek (Alain.Malek@cryogen.ch)\n";
116
117static int apne_owned; /* signal if card already owned */
118
119struct net_device * __init apne_probe(int unit)
120{
121    struct net_device *dev;
122#ifndef MANUAL_CONFIG
123    char tuple[8];
124#endif
125    int err;
126
127    if (!MACH_IS_AMIGA)
128        return ERR_PTR(-ENODEV);
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
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
196static 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 (time_after(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 < ARRAY_SIZE(program_seq); 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    dev->irq = IRQ_AMIGA_PORTS;
314    dev->netdev_ops = &ei_netdev_ops;
315
316    /* Install the Interrupt handler */
317    i = request_irq(dev->irq, apne_interrupt, IRQF_SHARED, DRV_NAME, dev);
318    if (i) return i;
319
320    for(i = 0; i < ETHER_ADDR_LEN; i++)
321    dev->dev_addr[i] = SA_prom[i];
322
323    printk(" %pM\n", dev->dev_addr);
324
325    printk("%s: %s found.\n", dev->name, name);
326
327    ei_status.name = name;
328    ei_status.tx_start_page = start_page;
329    ei_status.stop_page = stop_page;
330    ei_status.word16 = (wordlength == 2);
331
332    ei_status.rx_start_page = start_page + TX_PAGES;
333
334    ei_status.reset_8390 = &apne_reset_8390;
335    ei_status.block_input = &apne_block_input;
336    ei_status.block_output = &apne_block_output;
337    ei_status.get_8390_hdr = &apne_get_8390_hdr;
338
339    NS8390_init(dev, 0);
340
341    pcmcia_ack_int(pcmcia_get_intreq()); /* ack PCMCIA int req */
342    pcmcia_enable_irq();
343
344    apne_owned = 1;
345
346    return 0;
347}
348
349/* Hard reset the card. This used to pause for the same period that a
350   8390 reset command required, but that shouldn't be necessary. */
351static void
352apne_reset_8390(struct net_device *dev)
353{
354    unsigned long reset_start_time = jiffies;
355
356    init_pcmcia();
357
358    if (ei_debug > 1) printk("resetting the 8390 t=%ld...", jiffies);
359
360    outb(inb(NE_BASE + NE_RESET), NE_BASE + NE_RESET);
361
362    ei_status.txing = 0;
363    ei_status.dmaing = 0;
364
365    /* This check _should_not_ be necessary, omit eventually. */
366    while ((inb(NE_BASE+NE_EN0_ISR) & ENISR_RESET) == 0)
367    if (time_after(jiffies, reset_start_time + 2*HZ/100)) {
368        printk("%s: ne_reset_8390() did not complete.\n", dev->name);
369        break;
370    }
371    outb(ENISR_RESET, NE_BASE + NE_EN0_ISR); /* Ack intr. */
372}
373
374/* Grab the 8390 specific header. Similar to the block_input routine, but
375   we don't need to be concerned with ring wrap as the header will be at
376   the start of a page, so we optimize accordingly. */
377
378static void
379apne_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
380{
381
382    int nic_base = dev->base_addr;
383    int cnt;
384    char *ptrc;
385    short *ptrs;
386
387    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
388    if (ei_status.dmaing) {
389    printk("%s: DMAing conflict in ne_get_8390_hdr "
390       "[DMAstat:%d][irqlock:%d][intr:%d].\n",
391       dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
392    return;
393    }
394
395    ei_status.dmaing |= 0x01;
396    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
397    outb(ENISR_RDC, nic_base + NE_EN0_ISR);
398    outb(sizeof(struct e8390_pkt_hdr), nic_base + NE_EN0_RCNTLO);
399    outb(0, nic_base + NE_EN0_RCNTHI);
400    outb(0, nic_base + NE_EN0_RSARLO); /* On page boundary */
401    outb(ring_page, nic_base + NE_EN0_RSARHI);
402    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
403
404    if (ei_status.word16) {
405        ptrs = (short*)hdr;
406        for(cnt = 0; cnt < (sizeof(struct e8390_pkt_hdr)>>1); cnt++)
407            *ptrs++ = inw(NE_BASE + NE_DATAPORT);
408    } else {
409        ptrc = (char*)hdr;
410        for(cnt = 0; cnt < sizeof(struct e8390_pkt_hdr); cnt++)
411            *ptrc++ = inb(NE_BASE + NE_DATAPORT);
412    }
413
414    outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
415    ei_status.dmaing &= ~0x01;
416
417    le16_to_cpus(&hdr->count);
418}
419
420/* Block input and output, similar to the Crynwr packet driver. If you
421   are porting to a new ethercard, look at the packet driver source for hints.
422   The NEx000 doesn't share the on-board packet memory -- you have to put
423   the packet out through the "remote DMA" dataport using outb. */
424
425static void
426apne_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
427{
428    int nic_base = dev->base_addr;
429    char *buf = skb->data;
430    char *ptrc;
431    short *ptrs;
432    int cnt;
433
434    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
435    if (ei_status.dmaing) {
436    printk("%s: DMAing conflict in ne_block_input "
437       "[DMAstat:%d][irqlock:%d][intr:%d].\n",
438       dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
439    return;
440    }
441    ei_status.dmaing |= 0x01;
442    outb(E8390_NODMA+E8390_PAGE0+E8390_START, nic_base+ NE_CMD);
443    outb(ENISR_RDC, nic_base + NE_EN0_ISR);
444    outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
445    outb(count >> 8, nic_base + NE_EN0_RCNTHI);
446    outb(ring_offset & 0xff, nic_base + NE_EN0_RSARLO);
447    outb(ring_offset >> 8, nic_base + NE_EN0_RSARHI);
448    outb(E8390_RREAD+E8390_START, nic_base + NE_CMD);
449    if (ei_status.word16) {
450      ptrs = (short*)buf;
451      for (cnt = 0; cnt < (count>>1); cnt++)
452        *ptrs++ = inw(NE_BASE + NE_DATAPORT);
453      if (count & 0x01) {
454    buf[count-1] = inb(NE_BASE + NE_DATAPORT);
455      }
456    } else {
457      ptrc = (char*)buf;
458      for (cnt = 0; cnt < count; cnt++)
459        *ptrc++ = inb(NE_BASE + NE_DATAPORT);
460    }
461
462    outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
463    ei_status.dmaing &= ~0x01;
464}
465
466static void
467apne_block_output(struct net_device *dev, int count,
468        const unsigned char *buf, const int start_page)
469{
470    int nic_base = NE_BASE;
471    unsigned long dma_start;
472    char *ptrc;
473    short *ptrs;
474    int cnt;
475
476    /* Round the count up for word writes. Do we need to do this?
477       What effect will an odd byte count have on the 8390?
478       I should check someday. */
479    if (ei_status.word16 && (count & 0x01))
480      count++;
481
482    /* This *shouldn't* happen. If it does, it's the last thing you'll see */
483    if (ei_status.dmaing) {
484    printk("%s: DMAing conflict in ne_block_output."
485       "[DMAstat:%d][irqlock:%d][intr:%d]\n",
486       dev->name, ei_status.dmaing, ei_status.irqlock, dev->irq);
487    return;
488    }
489    ei_status.dmaing |= 0x01;
490    /* We should already be in page 0, but to be safe... */
491    outb(E8390_PAGE0+E8390_START+E8390_NODMA, nic_base + NE_CMD);
492
493    outb(ENISR_RDC, nic_base + NE_EN0_ISR);
494
495   /* Now the normal output. */
496    outb(count & 0xff, nic_base + NE_EN0_RCNTLO);
497    outb(count >> 8, nic_base + NE_EN0_RCNTHI);
498    outb(0x00, nic_base + NE_EN0_RSARLO);
499    outb(start_page, nic_base + NE_EN0_RSARHI);
500
501    outb(E8390_RWRITE+E8390_START, nic_base + NE_CMD);
502    if (ei_status.word16) {
503        ptrs = (short*)buf;
504        for (cnt = 0; cnt < count>>1; cnt++)
505            outw(*ptrs++, NE_BASE+NE_DATAPORT);
506    } else {
507        ptrc = (char*)buf;
508        for (cnt = 0; cnt < count; cnt++)
509        outb(*ptrc++, NE_BASE + NE_DATAPORT);
510    }
511
512    dma_start = jiffies;
513
514    while ((inb(NE_BASE + NE_EN0_ISR) & ENISR_RDC) == 0)
515    if (time_after(jiffies, dma_start + 2*HZ/100)) { /* 20ms */
516        printk("%s: timeout waiting for Tx RDC.\n", dev->name);
517        apne_reset_8390(dev);
518        NS8390_init(dev,1);
519        break;
520    }
521
522    outb(ENISR_RDC, nic_base + NE_EN0_ISR); /* Ack intr. */
523    ei_status.dmaing &= ~0x01;
524    return;
525}
526
527static irqreturn_t apne_interrupt(int irq, void *dev_id)
528{
529    unsigned char pcmcia_intreq;
530
531    if (!(gayle.inten & GAYLE_IRQ_IRQ))
532        return IRQ_NONE;
533
534    pcmcia_intreq = pcmcia_get_intreq();
535
536    if (!(pcmcia_intreq & GAYLE_IRQ_IRQ)) {
537        pcmcia_ack_int(pcmcia_intreq);
538        return IRQ_NONE;
539    }
540    if (ei_debug > 3)
541        printk("pcmcia intreq = %x\n", pcmcia_intreq);
542    pcmcia_disable_irq(); /* to get rid of the sti() within ei_interrupt */
543    ei_interrupt(irq, dev_id);
544    pcmcia_ack_int(pcmcia_get_intreq());
545    pcmcia_enable_irq();
546    return IRQ_HANDLED;
547}
548
549#ifdef MODULE
550static struct net_device *apne_dev;
551
552static int __init apne_module_init(void)
553{
554    apne_dev = apne_probe(-1);
555    if (IS_ERR(apne_dev))
556        return PTR_ERR(apne_dev);
557    return 0;
558}
559
560static void __exit apne_module_exit(void)
561{
562    unregister_netdev(apne_dev);
563
564    pcmcia_disable_irq();
565
566    free_irq(IRQ_AMIGA_PORTS, apne_dev);
567
568    pcmcia_reset();
569
570    release_region(IOBASE, 0x20);
571
572    free_netdev(apne_dev);
573}
574module_init(apne_module_init);
575module_exit(apne_module_exit);
576#endif
577
578static int init_pcmcia(void)
579{
580    u_char config;
581#ifndef MANUAL_CONFIG
582    u_char tuple[32];
583    int offset_len;
584#endif
585    u_long offset;
586
587    pcmcia_reset();
588    pcmcia_program_voltage(PCMCIA_0V);
589    pcmcia_access_speed(PCMCIA_SPEED_250NS);
590    pcmcia_write_enable();
591
592#ifdef MANUAL_CONFIG
593    config = MANUAL_CONFIG;
594#else
595    /* get and write config byte to enable IO port */
596
597    if (pcmcia_copy_tuple(CISTPL_CFTABLE_ENTRY, tuple, 32) < 3)
598        return 0;
599
600    config = tuple[2] & 0x3f;
601#endif
602#ifdef MANUAL_OFFSET
603    offset = MANUAL_OFFSET;
604#else
605    if (pcmcia_copy_tuple(CISTPL_CONFIG, tuple, 32) < 6)
606        return 0;
607
608    offset_len = (tuple[2] & 0x3) + 1;
609    offset = 0;
610    while(offset_len--) {
611        offset = (offset << 8) | tuple[4+offset_len];
612    }
613#endif
614
615    out_8(GAYLE_ATTRIBUTE+offset, config);
616
617    return 1;
618}
619
620MODULE_LICENSE("GPL");
621

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive