Root/
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 const struct net_device_ops ac_netdev_ops = { |
147 | .ndo_open = ac_open, |
148 | .ndo_stop = ac_close_card, |
149 | |
150 | .ndo_start_xmit = ei_start_xmit, |
151 | .ndo_tx_timeout = ei_tx_timeout, |
152 | .ndo_get_stats = ei_get_stats, |
153 | .ndo_set_multicast_list = ei_set_multicast_list, |
154 | .ndo_validate_addr = eth_validate_addr, |
155 | .ndo_set_mac_address = eth_mac_addr, |
156 | .ndo_change_mtu = eth_change_mtu, |
157 | #ifdef CONFIG_NET_POLL_CONTROLLER |
158 | .ndo_poll_controller = ei_poll, |
159 | #endif |
160 | }; |
161 | |
162 | static int __init ac_probe1(int ioaddr, struct net_device *dev) |
163 | { |
164 | int i, retval; |
165 | |
166 | if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME)) |
167 | return -EBUSY; |
168 | |
169 | if (inb_p(ioaddr + AC_ID_PORT) == 0xff) { |
170 | retval = -ENODEV; |
171 | goto out; |
172 | } |
173 | |
174 | if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) { |
175 | retval = -ENODEV; |
176 | goto out; |
177 | } |
178 | |
179 | #ifndef final_version |
180 | printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x," |
181 | " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG), |
182 | inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1), |
183 | inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3)); |
184 | #endif |
185 | |
186 | for (i = 0; i < 6; i++) |
187 | dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i); |
188 | |
189 | printk(KERN_DEBUG "AC3200 in EISA slot %d, node %pM", |
190 | ioaddr/0x1000, dev->dev_addr); |
191 | #if 0 |
192 | /* Check the vendor ID/prefix. Redundant after checking the EISA ID */ |
193 | if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0 |
194 | || inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1 |
195 | || inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) { |
196 | printk(", not found (invalid prefix).\n"); |
197 | retval = -ENODEV; |
198 | goto out; |
199 | } |
200 | #endif |
201 | |
202 | /* Assign and allocate the interrupt now. */ |
203 | if (dev->irq == 0) { |
204 | dev->irq = config2irq(inb(ioaddr + AC_CONFIG)); |
205 | printk(", using"); |
206 | } else { |
207 | dev->irq = irq_canonicalize(dev->irq); |
208 | printk(", assigning"); |
209 | } |
210 | |
211 | retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev); |
212 | if (retval) { |
213 | printk (" nothing! Unable to get IRQ %d.\n", dev->irq); |
214 | goto out1; |
215 | } |
216 | |
217 | printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]); |
218 | |
219 | dev->base_addr = ioaddr; |
220 | |
221 | #ifdef notyet |
222 | if (dev->mem_start) { /* Override the value from the board. */ |
223 | for (i = 0; i < 7; i++) |
224 | if (addrmap[i] == dev->mem_start) |
225 | break; |
226 | if (i >= 7) |
227 | i = 0; |
228 | outb((inb(ioaddr + AC_CONFIG) & ~7) | i, ioaddr + AC_CONFIG); |
229 | } |
230 | #endif |
231 | |
232 | dev->if_port = inb(ioaddr + AC_CONFIG) >> 6; |
233 | dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG)); |
234 | |
235 | printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n", |
236 | dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start); |
237 | |
238 | /* |
239 | * BEWARE!! Some dain-bramaged EISA SCUs will allow you to put |
240 | * the card mem within the region covered by `normal' RAM !!! |
241 | * |
242 | * ioremap() will fail in that case. |
243 | */ |
244 | ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100); |
245 | if (!ei_status.mem) { |
246 | printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n"); |
247 | printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n"); |
248 | printk(KERN_ERR "ac3200.c: Driver NOT installed.\n"); |
249 | retval = -EINVAL; |
250 | goto out1; |
251 | } |
252 | printk("ac3200.c: remapped %dkB card memory to virtual address %p\n", |
253 | AC_STOP_PG/4, ei_status.mem); |
254 | |
255 | dev->mem_start = (unsigned long)ei_status.mem; |
256 | dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256; |
257 | |
258 | ei_status.name = "AC3200"; |
259 | ei_status.tx_start_page = AC_START_PG; |
260 | ei_status.rx_start_page = AC_START_PG + TX_PAGES; |
261 | ei_status.stop_page = AC_STOP_PG; |
262 | ei_status.word16 = 1; |
263 | |
264 | if (ei_debug > 0) |
265 | printk(version); |
266 | |
267 | ei_status.reset_8390 = &ac_reset_8390; |
268 | ei_status.block_input = &ac_block_input; |
269 | ei_status.block_output = &ac_block_output; |
270 | ei_status.get_8390_hdr = &ac_get_8390_hdr; |
271 | |
272 | dev->netdev_ops = &ac_netdev_ops; |
273 | NS8390_init(dev, 0); |
274 | |
275 | retval = register_netdev(dev); |
276 | if (retval) |
277 | goto out2; |
278 | return 0; |
279 | out2: |
280 | if (ei_status.reg0) |
281 | iounmap(ei_status.mem); |
282 | out1: |
283 | free_irq(dev->irq, dev); |
284 | out: |
285 | release_region(ioaddr, AC_IO_EXTENT); |
286 | return retval; |
287 | } |
288 | |
289 | static int ac_open(struct net_device *dev) |
290 | { |
291 | #ifdef notyet |
292 | /* Someday we may enable the IRQ and shared memory here. */ |
293 | int ioaddr = dev->base_addr; |
294 | #endif |
295 | |
296 | ei_open(dev); |
297 | return 0; |
298 | } |
299 | |
300 | static void ac_reset_8390(struct net_device *dev) |
301 | { |
302 | ushort ioaddr = dev->base_addr; |
303 | |
304 | outb(AC_RESET, ioaddr + AC_RESET_PORT); |
305 | if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies); |
306 | |
307 | ei_status.txing = 0; |
308 | outb(AC_ENABLE, ioaddr + AC_RESET_PORT); |
309 | if (ei_debug > 1) printk("reset done\n"); |
310 | |
311 | return; |
312 | } |
313 | |
314 | /* Grab the 8390 specific header. Similar to the block_input routine, but |
315 | we don't need to be concerned with ring wrap as the header will be at |
316 | the start of a page, so we optimize accordingly. */ |
317 | |
318 | static void |
319 | ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page) |
320 | { |
321 | void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8); |
322 | memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr)); |
323 | } |
324 | |
325 | /* Block input and output are easy on shared memory ethercards, the only |
326 | complication is when the ring buffer wraps. */ |
327 | |
328 | static void ac_block_input(struct net_device *dev, int count, struct sk_buff *skb, |
329 | int ring_offset) |
330 | { |
331 | void __iomem *start = ei_status.mem + ring_offset - AC_START_PG*256; |
332 | |
333 | if (ring_offset + count > AC_STOP_PG*256) { |
334 | /* We must wrap the input move. */ |
335 | int semi_count = AC_STOP_PG*256 - ring_offset; |
336 | memcpy_fromio(skb->data, start, semi_count); |
337 | count -= semi_count; |
338 | memcpy_fromio(skb->data + semi_count, |
339 | ei_status.mem + TX_PAGES*256, count); |
340 | } else { |
341 | memcpy_fromio(skb->data, start, count); |
342 | } |
343 | } |
344 | |
345 | static void ac_block_output(struct net_device *dev, int count, |
346 | const unsigned char *buf, int start_page) |
347 | { |
348 | void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8); |
349 | |
350 | memcpy_toio(shmem, buf, count); |
351 | } |
352 | |
353 | static int ac_close_card(struct net_device *dev) |
354 | { |
355 | if (ei_debug > 1) |
356 | printk("%s: Shutting down ethercard.\n", dev->name); |
357 | |
358 | #ifdef notyet |
359 | /* We should someday disable shared memory and interrupts. */ |
360 | outb(0x00, ioaddr + 6); /* Disable interrupts. */ |
361 | free_irq(dev->irq, dev); |
362 | #endif |
363 | |
364 | ei_close(dev); |
365 | return 0; |
366 | } |
367 | |
368 | #ifdef MODULE |
369 | #define MAX_AC32_CARDS 4 /* Max number of AC32 cards per module */ |
370 | static struct net_device *dev_ac32[MAX_AC32_CARDS]; |
371 | static int io[MAX_AC32_CARDS]; |
372 | static int irq[MAX_AC32_CARDS]; |
373 | static int mem[MAX_AC32_CARDS]; |
374 | module_param_array(io, int, NULL, 0); |
375 | module_param_array(irq, int, NULL, 0); |
376 | module_param_array(mem, int, NULL, 0); |
377 | MODULE_PARM_DESC(io, "I/O base address(es)"); |
378 | MODULE_PARM_DESC(irq, "IRQ number(s)"); |
379 | MODULE_PARM_DESC(mem, "Memory base address(es)"); |
380 | MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver"); |
381 | MODULE_LICENSE("GPL"); |
382 | |
383 | static int __init ac3200_module_init(void) |
384 | { |
385 | struct net_device *dev; |
386 | int this_dev, found = 0; |
387 | |
388 | for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) { |
389 | if (io[this_dev] == 0 && this_dev != 0) |
390 | break; |
391 | dev = alloc_ei_netdev(); |
392 | if (!dev) |
393 | break; |
394 | dev->irq = irq[this_dev]; |
395 | dev->base_addr = io[this_dev]; |
396 | dev->mem_start = mem[this_dev]; /* Currently ignored by driver */ |
397 | if (do_ac3200_probe(dev) == 0) { |
398 | dev_ac32[found++] = dev; |
399 | continue; |
400 | } |
401 | free_netdev(dev); |
402 | printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]); |
403 | break; |
404 | } |
405 | if (found) |
406 | return 0; |
407 | return -ENXIO; |
408 | } |
409 | |
410 | static void cleanup_card(struct net_device *dev) |
411 | { |
412 | /* Someday free_irq may be in ac_close_card() */ |
413 | free_irq(dev->irq, dev); |
414 | release_region(dev->base_addr, AC_IO_EXTENT); |
415 | iounmap(ei_status.mem); |
416 | } |
417 | |
418 | static void __exit ac3200_module_exit(void) |
419 | { |
420 | int this_dev; |
421 | |
422 | for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) { |
423 | struct net_device *dev = dev_ac32[this_dev]; |
424 | if (dev) { |
425 | unregister_netdev(dev); |
426 | cleanup_card(dev); |
427 | free_netdev(dev); |
428 | } |
429 | } |
430 | } |
431 | module_init(ac3200_module_init); |
432 | module_exit(ac3200_module_exit); |
433 | #endif /* MODULE */ |
434 |
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.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9