1 /*
2 es3210.c
3
4 Linux driver for Racal-Interlan ES3210 EISA Network Adapter
5
6 Copyright (C) 1996, Paul Gortmaker.
7
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
10
11 Information and Code Sources:
12
13 1) The existing myriad of Linux 8390 drivers written by Donald Becker.
14
15 2) Once again Russ Nelson's asm packet driver provided additional info.
16
17 3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
18 Too bad it doesn't work -- see below.
19
20 The ES3210 is an EISA shared memory NS8390 implementation. Note
21 that all memory copies to/from the board must be 32bit transfers.
22 Which rules out using eth_io_copy_and_sum() in this driver.
23
24 Apparently there are two slightly different revisions of the
25 card, since there are two distinct EISA cfg files (!rii0101.cfg
26 and !rii0102.cfg) One has media select in the cfg file and the
27 other doesn't. Hopefully this will work with either.
28
29 That is about all I can tell you about it, having never actually
30 even seen one of these cards. :) Try http://www.interlan.com
31 if you want more info.
32
33 Thanks go to Mark Salazar for testing v0.02 of this driver.
34
35 Bugs, to-fix, etc:
36
37 1) The EISA cfg ports that are *supposed* to have the IRQ and shared
38 mem values just read 0xff all the time. Hrrmpf. Apparently the
39 same happens with the packet driver as the code for reading
40 these registers is disabled there. In the meantime, boot with:
41 ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
42 shared memory detection. (The i/o port detection is okay.)
43
44 2) Module support currently untested. Probably works though.
45
46 */
47
48 static const char version[] =
49 "es3210.c: Driver revision v0.03, 14/09/96\n";
50
51 #include <linux/module.h>
52 #include <linux/eisa.h>
53 #include <linux/kernel.h>
54 #include <linux/errno.h>
55 #include <linux/string.h>
56 #include <linux/init.h>
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59
60 #include <asm/io.h>
61 #include <asm/system.h>
62
63 #include "8390.h"
64
65 static int es_probe1(struct net_device *dev, int ioaddr);
66
67 static int es_open(struct net_device *dev);
68 static int es_close(struct net_device *dev);
69
70 static void es_reset_8390(struct net_device *dev);
71
72 static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
73 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
74 static void es_block_output(struct net_device *dev, int count, const unsigned char *buf, int start_page);
75
76 #define ES_START_PG 0x00 /* First page of TX buffer */
77 #define ES_STOP_PG 0x40 /* Last page +1 of RX ring */
78
79 #define ES_IO_EXTENT 0x37 /* The cfg file says 0xc90 -> 0xcc7 */
80 #define ES_ID_PORT 0xc80 /* Same for all EISA cards */
81 #define ES_SA_PROM 0xc90 /* Start of e'net addr. */
82 #define ES_RESET_PORT 0xc84 /* From the packet driver source */
83 #define ES_NIC_OFFSET 0xca0 /* Hello, the 8390 is *here* */
84
85 #define ES_ADDR0 0x02 /* 3 byte vendor prefix */
86 #define ES_ADDR1 0x07
87 #define ES_ADDR2 0x01
88
89 /*
90 * Two card revisions. EISA ID's are always rev. minor, rev. major,, and
91 * then the three vendor letters stored in 5 bits each, with an "a" = 1.
92 * For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
93 * config utility determines automagically what config file(s) to use.
94 */
95 #define ES_EISA_ID1 0x01012949 /* !rii0101.cfg */
96 #define ES_EISA_ID2 0x02012949 /* !rii0102.cfg */
97
98 #define ES_CFG1 0xcc0 /* IOPORT(1) --> IOPORT(6) in cfg file */
99 #define ES_CFG2 0xcc1
100 #define ES_CFG3 0xcc2
101 #define ES_CFG4 0xcc3
102 #define ES_CFG5 0xcc4
103 #define ES_CFG6 0xc84 /* NB: 0xc84 is also "reset" port. */
104
105 /*
106 * You can OR any of the following bits together and assign it
107 * to ES_DEBUG to get verbose driver info during operation.
108 * Some of these don't do anything yet.
109 */
110
111 #define ES_D_PROBE 0x01
112 #define ES_D_RX_PKT 0x02
113 #define ES_D_TX_PKT 0x04
114 #define ED_D_IRQ 0x08
115
116 #define ES_DEBUG 0
117
118 static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
119 static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
120
121 /*
122 * Probe for the card. The best way is to read the EISA ID if it
123 * is known. Then we check the prefix of the station address
124 * PROM for a match against the Racal-Interlan assigned value.
125 */
126
127 static int __init do_es_probe(struct net_device *dev)
128 {
129 unsigned short ioaddr = dev->base_addr;
130 int irq = dev->irq;
131 int mem_start = dev->mem_start;
132
133 if (ioaddr > 0x1ff) /* Check a single specified location. */
134 return es_probe1(dev, ioaddr);
135 else if (ioaddr > 0) /* Don't probe at all. */
136 return -ENXIO;
137
138 if (!EISA_bus) {
139 #if ES_DEBUG & ES_D_PROBE
140 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
141 #endif
142 return -ENXIO;
143 }
144
145 /* EISA spec allows for up to 16 slots, but 8 is typical. */
146 for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
147 if (es_probe1(dev, ioaddr) == 0)
148 return 0;
149 dev->irq = irq;
150 dev->mem_start = mem_start;
151 }
152
153 return -ENODEV;
154 }
155
156 #ifndef MODULE
157 struct net_device * __init es_probe(int unit)
158 {
159 struct net_device *dev = alloc_ei_netdev();
160 int err;
161
162 if (!dev)
163 return ERR_PTR(-ENOMEM);
164
165 sprintf(dev->name, "eth%d", unit);
166 netdev_boot_setup_check(dev);
167
168 err = do_es_probe(dev);
169 if (err)
170 goto out;
171 return dev;
172 out:
173 free_netdev(dev);
174 return ERR_PTR(err);
175 }
176 #endif
177
178 static int __init es_probe1(struct net_device *dev, int ioaddr)
179 {
180 int i, retval;
181 unsigned long eisa_id;
182 DECLARE_MAC_BUF(mac);
183
184 if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
185 return -ENODEV;
186
187 #if ES_DEBUG & ES_D_PROBE
188 printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
189 printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
190 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
191 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
192 #endif
193
194 /* Check the EISA ID of the card. */
195 eisa_id = inl(ioaddr + ES_ID_PORT);
196 if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
197 retval = -ENODEV;
198 goto out;
199 }
200
201 for (i = 0; i < ETHER_ADDR_LEN ; i++)
202 dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i);
203
204 /* Check the Racal vendor ID as well. */
205 if (dev->dev_addr[0] != ES_ADDR0 ||
206 dev->dev_addr[1] != ES_ADDR1 ||
207 dev->dev_addr[2] != ES_ADDR2) {
208 printk("es3210.c: card not found %s (invalid_prefix).\n",
209 print_mac(mac, dev->dev_addr));
210 retval = -ENODEV;
211 goto out;
212 }
213
214 printk("es3210.c: ES3210 rev. %ld at %#x, node %s",
215 eisa_id>>24, ioaddr, print_mac(mac, dev->dev_addr));
216
217 /* Snarf the interrupt now. */
218 if (dev->irq == 0) {
219 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
220 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
221
222 if (hi_irq != 0) {
223 dev->irq = hi_irq_map[hi_irq - 1];
224 } else {
225 int i = 0;
226 while (lo_irq > (1<<i)) i++;
227 dev->irq = lo_irq_map[i];
228 }
229 printk(" using IRQ %d", dev->irq);
230 #if ES_DEBUG & ES_D_PROBE
231 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
232 hi_irq, lo_irq, dev->irq);
233 #endif
234 } else {
235 if (dev->irq == 2)
236 dev->irq = 9; /* Doh! */
237 printk(" assigning IRQ %d", dev->irq);
238 }
239
240 if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
241 printk (" unable to get IRQ %d.\n", dev->irq);
242 retval = -EAGAIN;
243 goto out;
244 }
245
246 if (dev->mem_start == 0) {
247 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
248 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
249
250 if (mem_enabled != 0x80) {
251 printk(" shared mem disabled - giving up\n");
252 retval = -ENXIO;
253 goto out1;
254 }
255 dev->mem_start = 0xC0000 + mem_bits*0x4000;
256 printk(" using ");
257 } else {
258 printk(" assigning ");
259 }
260
261 ei_status.mem = ioremap(dev->mem_start, (ES_STOP_PG - ES_START_PG)*256);
262 if (!ei_status.mem) {
263 printk("ioremap failed - giving up\n");
264 retval = -ENXIO;
265 goto out1;
266 }
267
268 dev->mem_end = dev->mem_start + (ES_STOP_PG - ES_START_PG)*256;
269
270 printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
271
272 #if ES_DEBUG & ES_D_PROBE
273 if (inb(ioaddr + ES_CFG5))
274 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
275 #endif
276 /* Note, point at the 8390, and not the card... */
277 dev->base_addr = ioaddr + ES_NIC_OFFSET;
278
279 ei_status.name = "ES3210";
280 ei_status.tx_start_page = ES_START_PG;
281 ei_status.rx_start_page = ES_START_PG + TX_PAGES;
282 ei_status.stop_page = ES_STOP_PG;
283 ei_status.word16 = 1;
284
285 if (ei_debug > 0)
286 printk(version);
287
288 ei_status.reset_8390 = &es_reset_8390;
289 ei_status.block_input = &es_block_input;
290 ei_status.block_output = &es_block_output;
291 ei_status.get_8390_hdr = &es_get_8390_hdr;
292
293 dev->open = &es_open;
294 dev->stop = &es_close;
295 #ifdef CONFIG_NET_POLL_CONTROLLER
296 dev->poll_controller = ei_poll;
297 #endif
298 NS8390_init(dev, 0);
299
300 retval = register_netdev(dev);
301 if (retval)
302 goto out1;
303 return 0;
304 out1:
305 free_irq(dev->irq, dev);
306 out:
307 release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
308 return retval;
309 }
310
311 /*
312 * Reset as per the packet driver method. Judging by the EISA cfg
313 * file, this just toggles the "Board Enable" bits (bit 2 and 0).
314 */
315
316 static void es_reset_8390(struct net_device *dev)
317 {
318 unsigned short ioaddr = dev->base_addr;
319 unsigned long end;
320
321 outb(0x04, ioaddr + ES_RESET_PORT);
322 if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
323
324 end = jiffies + 2*HZ/100;
325 while ((signed)(end - jiffies) > 0) continue;
326
327 ei_status.txing = 0;
328 outb(0x01, ioaddr + ES_RESET_PORT);
329 if (ei_debug > 1) printk("reset done\n");
330
331 return;
332 }
333
334 /*
335 * Note: In the following three functions is the implicit assumption
336 * that the associated memcpy will only use "rep; movsl" as long as
337 * we keep the counts as some multiple of doublewords. This is a
338 * requirement of the hardware, and also prevents us from using
339 * eth_io_copy_and_sum() since we can't guarantee it will limit
340 * itself to doubleword access.
341 */
342
343 /*
344 * Grab the 8390 specific header. Similar to the block_input routine, but
345 * we don't need to be concerned with ring wrap as the header will be at
346 * the start of a page, so we optimize accordingly. (A single doubleword.)
347 */
348
349 static void
350 es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
351 {
352 void __iomem *hdr_start = ei_status.mem + ((ring_page - ES_START_PG)<<8);
353 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
354 hdr->count = (hdr->count + 3) & ~3; /* Round up allocation. */
355 }
356
357 /*
358 * Block input and output are easy on shared memory ethercards, the only
359 * complication is when the ring buffer wraps. The count will already
360 * be rounded up to a doubleword value via es_get_8390_hdr() above.
361 */
362
363 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
364 int ring_offset)
365 {
366 void __iomem *xfer_start = ei_status.mem + ring_offset - ES_START_PG*256;
367
368 if (ring_offset + count > ES_STOP_PG*256) {
369 /* Packet wraps over end of ring buffer. */
370 int semi_count = ES_STOP_PG*256 - ring_offset;
371 memcpy_fromio(skb->data, xfer_start, semi_count);
372 count -= semi_count;
373 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
374 } else {
375 /* Packet is in one chunk. */
376 memcpy_fromio(skb->data, xfer_start, count);
377 }
378 }
379
380 static void es_block_output(struct net_device *dev, int count,
381 const unsigned char *buf, int start_page)
382 {
383 void __iomem *shmem = ei_status.mem + ((start_page - ES_START_PG)<<8);
384
385 count = (count + 3) & ~3; /* Round up to doubleword */
386 memcpy_toio(shmem, buf, count);
387 }
388
389 static int es_open(struct net_device *dev)
390 {
391 ei_open(dev);
392 return 0;
393 }
394
395 static int es_close(struct net_device *dev)
396 {
397
398 if (ei_debug > 1)
399 printk("%s: Shutting down ethercard.\n", dev->name);
400
401 ei_close(dev);
402 return 0;
403 }
404
405 #ifdef MODULE
406 #define MAX_ES_CARDS 4 /* Max number of ES3210 cards per module */
407 #define NAMELEN 8 /* # of chars for storing dev->name */
408 static struct net_device *dev_es3210[MAX_ES_CARDS];
409 static int io[MAX_ES_CARDS];
410 static int irq[MAX_ES_CARDS];
411 static int mem[MAX_ES_CARDS];
412
413 module_param_array(io, int, NULL, 0);
414 module_param_array(irq, int, NULL, 0);
415 module_param_array(mem, int, NULL, 0);
416 MODULE_PARM_DESC(io, "I/O base address(es)");
417 MODULE_PARM_DESC(irq, "IRQ number(s)");
418 MODULE_PARM_DESC(mem, "memory base address(es)");
419 MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
420 MODULE_LICENSE("GPL");
421
422 int __init init_module(void)
423 {
424 struct net_device *dev;
425 int this_dev, found = 0;
426
427 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
428 if (io[this_dev] == 0 && this_dev != 0)
429 break;
430 dev = alloc_ei_netdev();
431 if (!dev)
432 break;
433 dev->irq = irq[this_dev];
434 dev->base_addr = io[this_dev];
435 dev->mem_start = mem[this_dev];
436 if (do_es_probe(dev) == 0) {
437 dev_es3210[found++] = dev;
438 continue;
439 }
440 free_netdev(dev);
441 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
442 break;
443 }
444 if (found)
445 return 0;
446 return -ENXIO;
447 }
448
449 static void cleanup_card(struct net_device *dev)
450 {
451 free_irq(dev->irq, dev);
452 release_region(dev->base_addr, ES_IO_EXTENT);
453 iounmap(ei_status.mem);
454 }
455
456 void __exit
457 cleanup_module(void)
458 {
459 int this_dev;
460
461 for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
462 struct net_device *dev = dev_es3210[this_dev];
463 if (dev) {
464 unregister_netdev(dev);
465 cleanup_card(dev);
466 free_netdev(dev);
467 }
468 }
469 }
470 #endif /* MODULE */
471
472
|
This page was automatically generated by the
LXR engine.
|