b1448637107f3fada6f1a97536dfd6492a9d9117
[linux-2.6.git] / drivers / net / ac3200.c
1 /* ac3200.c: A driver for the Ansel Communications EISA ethernet adaptor. */
2 /*
3         Written 1993, 1994 by Donald Becker.
4         Copyright 1993 United States Government as represented by the Director,
5         National Security Agency.  This software may only be used and distributed
6         according to the terms of the GNU General Public License as modified by SRC,
7         incorporated herein by reference.
8
9         The author may be reached as becker@scyld.com, or C/O
10         Scyld Computing Corporation
11         410 Severn Ave., Suite 210
12         Annapolis MD 21403
13
14         This is driver for the Ansel Communications Model 3200 EISA Ethernet LAN
15         Adapter.  The programming information is from the users manual, as related
16         by glee@ardnassak.math.clemson.edu.
17
18         Changelog:
19
20         Paul Gortmaker 05/98    : add support for shared mem above 1MB.
21
22   */
23
24 static const char version[] =
25         "ac3200.c:v1.01 7/1/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
26
27 #include <linux/module.h>
28 #include <linux/eisa.h>
29 #include <linux/kernel.h>
30 #include <linux/errno.h>
31 #include <linux/string.h>
32 #include <linux/netdevice.h>
33 #include <linux/etherdevice.h>
34 #include <linux/init.h>
35
36 #include <asm/system.h>
37 #include <asm/io.h>
38 #include <asm/irq.h>
39
40 #include "8390.h"
41
42 #define DRV_NAME        "ac3200"
43
44 /* Offsets from the base address. */
45 #define AC_NIC_BASE     0x00
46 #define AC_SA_PROM      0x16                    /* The station address PROM. */
47 #define AC_ADDR0        0x00                    /* Prefix station address values. */
48 #define AC_ADDR1        0x40
49 #define AC_ADDR2        0x90
50 #define AC_ID_PORT      0xC80
51 #define AC_EISA_ID      0x0110d305
52 #define AC_RESET_PORT   0xC84
53 #define AC_RESET        0x00
54 #define AC_ENABLE       0x01
55 #define AC_CONFIG       0xC90   /* The configuration port. */
56
57 #define AC_IO_EXTENT 0x20
58                                 /* Actually accessed is:
59                                                                  * AC_NIC_BASE (0-15)
60                                                                  * AC_SA_PROM (0-5)
61                                                                  * AC_ID_PORT (0-3)
62                                                                  * AC_RESET_PORT
63                                                                  * AC_CONFIG
64                                                                  */
65
66 /* Decoding of the configuration register. */
67 static unsigned char config2irqmap[8] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
68 static int addrmap[8] =
69 {0xFF0000, 0xFE0000, 0xFD0000, 0xFFF0000, 0xFFE0000, 0xFFC0000,  0xD0000, 0 };
70 static const char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};
71
72 #define config2irq(configval)   config2irqmap[((configval) >> 3) & 7]
73 #define config2mem(configval)   addrmap[(configval) & 7]
74 #define config2name(configval)  port_name[((configval) >> 6) & 3]
75
76 /* First and last 8390 pages. */
77 #define AC_START_PG             0x00    /* First page of 8390 TX buffer */
78 #define AC_STOP_PG              0x80    /* Last page +1 of the 8390 RX ring */
79
80 static int ac_probe1(int ioaddr, struct net_device *dev);
81
82 static int ac_open(struct net_device *dev);
83 static void ac_reset_8390(struct net_device *dev);
84 static void ac_block_input(struct net_device *dev, int count,
85                                         struct sk_buff *skb, int ring_offset);
86 static void ac_block_output(struct net_device *dev, const int count,
87                                                         const unsigned char *buf, const int start_page);
88 static void ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
89                                         int ring_page);
90
91 static int ac_close_card(struct net_device *dev);
92
93
94 /*      Probe for the AC3200.
95
96         The AC3200 can be identified by either the EISA configuration registers,
97         or the unique value in the station address PROM.
98         */
99
100 static int __init do_ac3200_probe(struct net_device *dev)
101 {
102         unsigned short ioaddr = dev->base_addr;
103         int irq = dev->irq;
104         int mem_start = dev->mem_start;
105
106         if (ioaddr > 0x1ff)             /* Check a single specified location. */
107                 return ac_probe1(ioaddr, dev);
108         else if (ioaddr > 0)            /* Don't probe at all. */
109                 return -ENXIO;
110
111         if ( ! EISA_bus)
112                 return -ENXIO;
113
114         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
115                 if (ac_probe1(ioaddr, dev) == 0)
116                         return 0;
117                 dev->irq = irq;
118                 dev->mem_start = mem_start;
119         }
120
121         return -ENODEV;
122 }
123
124 #ifndef MODULE
125 struct net_device * __init ac3200_probe(int unit)
126 {
127         struct net_device *dev = alloc_ei_netdev();
128         int err;
129
130         if (!dev)
131                 return ERR_PTR(-ENOMEM);
132
133         sprintf(dev->name, "eth%d", unit);
134         netdev_boot_setup_check(dev);
135
136         err = do_ac3200_probe(dev);
137         if (err)
138                 goto out;
139         return dev;
140 out:
141         free_netdev(dev);
142         return ERR_PTR(err);
143 }
144 #endif
145
146 static int __init ac_probe1(int ioaddr, struct net_device *dev)
147 {
148         int i, retval;
149         DECLARE_MAC_BUF(mac);
150
151         if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
152                 return -EBUSY;
153
154         if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
155                 retval = -ENODEV;
156                 goto out;
157         }
158
159         if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
160                 retval = -ENODEV;
161                 goto out;
162         }
163
164 #ifndef final_version
165         printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
166                    " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
167                    inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
168                    inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
169 #endif
170
171         for (i = 0; i < 6; i++)
172                 dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i);
173
174         printk(KERN_DEBUG "AC3200 in EISA slot %d, node %s",
175                ioaddr/0x1000, print_mac(mac, dev->dev_addr));
176 #if 0
177         /* Check the vendor ID/prefix. Redundant after checking the EISA ID */
178         if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
179                 || inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
180                 || inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
181                 printk(", not found (invalid prefix).\n");
182                 retval = -ENODEV;
183                 goto out;
184         }
185 #endif
186
187         /* Assign and allocate the interrupt now. */
188         if (dev->irq == 0) {
189                 dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
190                 printk(", using");
191         } else {
192                 dev->irq = irq_canonicalize(dev->irq);
193                 printk(", assigning");
194         }
195
196         retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
197         if (retval) {
198                 printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
199                 goto out1;
200         }
201
202         printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);
203
204         dev->base_addr = ioaddr;
205
206 #ifdef notyet
207         if (dev->mem_start)     {               /* Override the value from the board. */
208                 for (i = 0; i < 7; i++)
209                         if (addrmap[i] == dev->mem_start)
210                                 break;
211                 if (i >= 7)
212                         i = 0;
213                 outb((inb(ioaddr + AC_CONFIG) & ~7) | i, ioaddr + AC_CONFIG);
214         }
215 #endif
216
217         dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
218         dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));
219
220         printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
221                         dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);
222
223         /*
224          *  BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
225          *  the card mem within the region covered by `normal' RAM  !!!
226          *
227          *  ioremap() will fail in that case.
228          */
229         ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100);
230         if (!ei_status.mem) {
231                 printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
232                 printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
233                 printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
234                 retval = -EINVAL;
235                 goto out1;
236         }
237         printk("ac3200.c: remapped %dkB card memory to virtual address %p\n",
238                         AC_STOP_PG/4, ei_status.mem);
239
240         dev->mem_start = (unsigned long)ei_status.mem;
241         dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256;
242
243         ei_status.name = "AC3200";
244         ei_status.tx_start_page = AC_START_PG;
245         ei_status.rx_start_page = AC_START_PG + TX_PAGES;
246         ei_status.stop_page = AC_STOP_PG;
247         ei_status.word16 = 1;
248
249         if (ei_debug > 0)
250                 printk(version);
251
252         ei_status.reset_8390 = &ac_reset_8390;
253         ei_status.block_input = &ac_block_input;
254         ei_status.block_output = &ac_block_output;
255         ei_status.get_8390_hdr = &ac_get_8390_hdr;
256
257         dev->open = &ac_open;
258         dev->stop = &ac_close_card;
259 #ifdef CONFIG_NET_POLL_CONTROLLER
260         dev->poll_controller = ei_poll;
261 #endif
262         NS8390_init(dev, 0);
263
264         retval = register_netdev(dev);
265         if (retval)
266                 goto out2;
267         return 0;
268 out2:
269         if (ei_status.reg0)
270                 iounmap(ei_status.mem);
271 out1:
272         free_irq(dev->irq, dev);
273 out:
274         release_region(ioaddr, AC_IO_EXTENT);
275         return retval;
276 }
277
278 static int ac_open(struct net_device *dev)
279 {
280 #ifdef notyet
281         /* Someday we may enable the IRQ and shared memory here. */
282         int ioaddr = dev->base_addr;
283 #endif
284
285         ei_open(dev);
286         return 0;
287 }
288
289 static void ac_reset_8390(struct net_device *dev)
290 {
291         ushort ioaddr = dev->base_addr;
292
293         outb(AC_RESET, ioaddr + AC_RESET_PORT);
294         if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);
295
296         ei_status.txing = 0;
297         outb(AC_ENABLE, ioaddr + AC_RESET_PORT);
298         if (ei_debug > 1) printk("reset done\n");
299
300         return;
301 }
302
303 /* Grab the 8390 specific header. Similar to the block_input routine, but
304    we don't need to be concerned with ring wrap as the header will be at
305    the start of a page, so we optimize accordingly. */
306
307 static void
308 ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
309 {
310         void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8);
311         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
312 }
313
314 /*  Block input and output are easy on shared memory ethercards, the only
315         complication is when the ring buffer wraps. */
316
317 static void ac_block_input(struct net_device *dev, int count, struct sk_buff *skb,
318                                                   int ring_offset)
319 {
320         void __iomem *start = ei_status.mem + ring_offset - AC_START_PG*256;
321
322         if (ring_offset + count > AC_STOP_PG*256) {
323                 /* We must wrap the input move. */
324                 int semi_count = AC_STOP_PG*256 - ring_offset;
325                 memcpy_fromio(skb->data, start, semi_count);
326                 count -= semi_count;
327                 memcpy_fromio(skb->data + semi_count,
328                                 ei_status.mem + TX_PAGES*256, count);
329         } else {
330                 memcpy_fromio(skb->data, start, count);
331         }
332 }
333
334 static void ac_block_output(struct net_device *dev, int count,
335                                                         const unsigned char *buf, int start_page)
336 {
337         void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8);
338
339         memcpy_toio(shmem, buf, count);
340 }
341
342 static int ac_close_card(struct net_device *dev)
343 {
344         if (ei_debug > 1)
345                 printk("%s: Shutting down ethercard.\n", dev->name);
346
347 #ifdef notyet
348         /* We should someday disable shared memory and interrupts. */
349         outb(0x00, ioaddr + 6); /* Disable interrupts. */
350         free_irq(dev->irq, dev);
351 #endif
352
353         ei_close(dev);
354         return 0;
355 }
356
357 #ifdef MODULE
358 #define MAX_AC32_CARDS  4       /* Max number of AC32 cards per module */
359 static struct net_device *dev_ac32[MAX_AC32_CARDS];
360 static int io[MAX_AC32_CARDS];
361 static int irq[MAX_AC32_CARDS];
362 static int mem[MAX_AC32_CARDS];
363 module_param_array(io, int, NULL, 0);
364 module_param_array(irq, int, NULL, 0);
365 module_param_array(mem, int, NULL, 0);
366 MODULE_PARM_DESC(io, "I/O base address(es)");
367 MODULE_PARM_DESC(irq, "IRQ number(s)");
368 MODULE_PARM_DESC(mem, "Memory base address(es)");
369 MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
370 MODULE_LICENSE("GPL");
371
372 static int __init ac3200_module_init(void)
373 {
374         struct net_device *dev;
375         int this_dev, found = 0;
376
377         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
378                 if (io[this_dev] == 0 && this_dev != 0)
379                         break;
380                 dev = alloc_ei_netdev();
381                 if (!dev)
382                         break;
383                 dev->irq = irq[this_dev];
384                 dev->base_addr = io[this_dev];
385                 dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
386                 if (do_ac3200_probe(dev) == 0) {
387                         dev_ac32[found++] = dev;
388                         continue;
389                 }
390                 free_netdev(dev);
391                 printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
392                 break;
393         }
394         if (found)
395                 return 0;
396         return -ENXIO;
397 }
398
399 static void cleanup_card(struct net_device *dev)
400 {
401         /* Someday free_irq may be in ac_close_card() */
402         free_irq(dev->irq, dev);
403         release_region(dev->base_addr, AC_IO_EXTENT);
404         iounmap(ei_status.mem);
405 }
406
407 static void __exit ac3200_module_exit(void)
408 {
409         int this_dev;
410
411         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
412                 struct net_device *dev = dev_ac32[this_dev];
413                 if (dev) {
414                         unregister_netdev(dev);
415                         cleanup_card(dev);
416                         free_netdev(dev);
417                 }
418         }
419 }
420 module_init(ac3200_module_init);
421 module_exit(ac3200_module_exit);
422 #endif /* MODULE */