[PATCH] fix a few "warning: 'cleanup_card' defined but not used"
[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 \f
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         SET_MODULE_OWNER(dev);
107
108         if (ioaddr > 0x1ff)             /* Check a single specified location. */
109                 return ac_probe1(ioaddr, dev);
110         else if (ioaddr > 0)            /* Don't probe at all. */
111                 return -ENXIO;
112
113         if ( ! EISA_bus)
114                 return -ENXIO;
115
116         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
117                 if (ac_probe1(ioaddr, dev) == 0)
118                         return 0;
119                 dev->irq = irq;
120                 dev->mem_start = mem_start;
121         }
122
123         return -ENODEV;
124 }
125
126 #ifndef MODULE
127 struct net_device * __init ac3200_probe(int unit)
128 {
129         struct net_device *dev = alloc_ei_netdev();
130         int err;
131
132         if (!dev)
133                 return ERR_PTR(-ENOMEM);
134
135         sprintf(dev->name, "eth%d", unit);
136         netdev_boot_setup_check(dev);
137
138         err = do_ac3200_probe(dev);
139         if (err)
140                 goto out;
141         return dev;
142 out:
143         free_netdev(dev);
144         return ERR_PTR(err);
145 }
146 #endif
147
148 static int __init ac_probe1(int ioaddr, struct net_device *dev)
149 {
150         int i, retval;
151
152         if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
153                 return -EBUSY;
154
155         if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
156                 retval = -ENODEV;
157                 goto out;
158         }
159
160         if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
161                 retval = -ENODEV;
162                 goto out;
163         }
164
165 #ifndef final_version
166         printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
167                    " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
168                    inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
169                    inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
170 #endif
171
172         printk("AC3200 in EISA slot %d, node", ioaddr/0x1000);
173         for(i = 0; i < 6; i++)
174                 printk(" %02x", dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i));
175
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                 /* Packet is in one chunk -- we can copy + cksum. */
331                 eth_io_copy_and_sum(skb, start, count, 0);
332         }
333 }
334
335 static void ac_block_output(struct net_device *dev, int count,
336                                                         const unsigned char *buf, int start_page)
337 {
338         void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8);
339
340         memcpy_toio(shmem, buf, count);
341 }
342
343 static int ac_close_card(struct net_device *dev)
344 {
345         if (ei_debug > 1)
346                 printk("%s: Shutting down ethercard.\n", dev->name);
347
348 #ifdef notyet
349         /* We should someday disable shared memory and interrupts. */
350         outb(0x00, ioaddr + 6); /* Disable interrupts. */
351         free_irq(dev->irq, dev);
352 #endif
353
354         ei_close(dev);
355         return 0;
356 }
357
358 #ifdef MODULE
359 #define MAX_AC32_CARDS  4       /* Max number of AC32 cards per module */
360 static struct net_device *dev_ac32[MAX_AC32_CARDS];
361 static int io[MAX_AC32_CARDS];
362 static int irq[MAX_AC32_CARDS];
363 static int mem[MAX_AC32_CARDS];
364 module_param_array(io, int, NULL, 0);
365 module_param_array(irq, int, NULL, 0);
366 module_param_array(mem, int, NULL, 0);
367 MODULE_PARM_DESC(io, "I/O base address(es)");
368 MODULE_PARM_DESC(irq, "IRQ number(s)");
369 MODULE_PARM_DESC(mem, "Memory base address(es)");
370 MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
371 MODULE_LICENSE("GPL");
372
373 int
374 init_module(void)
375 {
376         struct net_device *dev;
377         int this_dev, found = 0;
378
379         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
380                 if (io[this_dev] == 0 && this_dev != 0)
381                         break;
382                 dev = alloc_ei_netdev();
383                 if (!dev)
384                         break;
385                 dev->irq = irq[this_dev];
386                 dev->base_addr = io[this_dev];
387                 dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
388                 if (do_ac3200_probe(dev) == 0) {
389                         dev_ac32[found++] = dev;
390                         continue;
391                 }
392                 free_netdev(dev);
393                 printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
394                 break;
395         }
396         if (found)
397                 return 0;
398         return -ENXIO;
399 }
400
401 static void cleanup_card(struct net_device *dev)
402 {
403         /* Someday free_irq may be in ac_close_card() */
404         free_irq(dev->irq, dev);
405         release_region(dev->base_addr, AC_IO_EXTENT);
406         iounmap(ei_status.mem);
407 }
408
409 void
410 cleanup_module(void)
411 {
412         int this_dev;
413
414         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
415                 struct net_device *dev = dev_ac32[this_dev];
416                 if (dev) {
417                         unregister_netdev(dev);
418                         cleanup_card(dev);
419                         free_netdev(dev);
420                 }
421         }
422 }
423 #endif /* MODULE */