Commit | Line | Data |
---|---|---|
1da177e4 LT |
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. */ | |
6aa20a22 | 48 | #define AC_ADDR1 0x40 |
1da177e4 LT |
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); | |
6aa20a22 | 92 | |
1da177e4 LT |
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 | ||
1da177e4 LT |
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; | |
1da177e4 | 141 | return dev; |
1da177e4 LT |
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 | ||
6aa20a22 | 220 | printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n", |
1da177e4 LT |
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); | |
b1fc5505 | 263 | |
264 | retval = register_netdev(dev); | |
265 | if (retval) | |
266 | goto out2; | |
1da177e4 | 267 | return 0; |
b1fc5505 | 268 | out2: |
269 | if (ei_status.reg0) | |
5ac90037 | 270 | iounmap(ei_status.mem); |
1da177e4 LT |
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 { | |
4ec03116 | 330 | memcpy_fromio(skb->data, start, count); |
1da177e4 LT |
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 | ||
62a87b80 | 372 | int __init init_module(void) |
1da177e4 LT |
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) { | |
b1fc5505 | 387 | dev_ac32[found++] = dev; |
388 | continue; | |
1da177e4 LT |
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 | ||
64916f1e DV |
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 | ||
afc8eb46 | 407 | void __exit |
1da177e4 LT |
408 | cleanup_module(void) |
409 | { | |
410 | int this_dev; | |
411 | ||
412 | for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) { | |
413 | struct net_device *dev = dev_ac32[this_dev]; | |
414 | if (dev) { | |
415 | unregister_netdev(dev); | |
416 | cleanup_card(dev); | |
417 | free_netdev(dev); | |
418 | } | |
419 | } | |
420 | } | |
421 | #endif /* MODULE */ |