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