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