1 /* smc-ultra32.c: An SMC Ultra32 EISA ethernet driver for linux.
2
3 Sources:
4
5 This driver is based on (cloned from) the ISA SMC Ultra driver
6 written by Donald Becker. Modifications to support the EISA
7 version of the card by Paul Gortmaker and Leonard N. Zubkoff.
8
9 This software may be used and distributed according to the terms
10 of the GNU General Public License, incorporated herein by reference.
11
12 Theory of Operation:
13
14 The SMC Ultra32C card uses the SMC 83c790 chip which is also
15 found on the ISA SMC Ultra cards. It has a shared memory mode of
16 operation that makes it similar to the ISA version of the card.
17 The main difference is that the EISA card has 32KB of RAM, but
18 only an 8KB window into that memory. The EISA card also can be
19 set for a bus-mastering mode of operation via the ECU, but that
20 is not (and probably will never be) supported by this driver.
21 The ECU should be run to enable shared memory and to disable the
22 bus-mastering feature for use with linux.
23
24 By programming the 8390 to use only 8KB RAM, the modifications
25 to the ISA driver can be limited to the probe and initialization
26 code. This allows easy integration of EISA support into the ISA
27 driver. However, the driver development kit from SMC provided the
28 register information for sliding the 8KB window, and hence the 8390
29 is programmed to use the full 32KB RAM.
30
31 Unfortunately this required code changes outside the probe/init
32 routines, and thus we decided to separate the EISA driver from
33 the ISA one. In this way, ISA users don't end up with a larger
34 driver due to the EISA code, and EISA users don't end up with a
35 larger driver due to the ISA EtherEZ PIO code. The driver is
36 similar to the 3c503/16 driver, in that the window must be set
37 back to the 1st 8KB of space for access to the two 8390 Tx slots.
38
39 In testing, using only 8KB RAM (3 Tx / 5 Rx) didn't appear to
40 be a limiting factor, since the EISA bus could get packets off
41 the card fast enough, but having the use of lots of RAM as Rx
42 space is extra insurance if interrupt latencies become excessive.
43
44 */
45
46 static const char *version = "smc-ultra32.c: 06/97 v1.00\n";
47
48
49 #include <linux/module.h>
50 #include <linux/eisa.h>
51 #include <linux/kernel.h>
52 #include <linux/errno.h>
53 #include <linux/string.h>
54 #include <linux/init.h>
55 #include <linux/interrupt.h>
56 #include <linux/netdevice.h>
57 #include <linux/etherdevice.h>
58
59 #include <asm/io.h>
60 #include <asm/system.h>
61
62 #include "8390.h"
63
64 #define DRV_NAME "smc-ultra32"
65
66 static int ultra32_probe1(struct net_device *dev, int ioaddr);
67 static int ultra32_open(struct net_device *dev);
68 static void ultra32_reset_8390(struct net_device *dev);
69 static void ultra32_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
70 int ring_page);
71 static void ultra32_block_input(struct net_device *dev, int count,
72 struct sk_buff *skb, int ring_offset);
73 static void ultra32_block_output(struct net_device *dev, int count,
74 const unsigned char *buf,
75 const int start_page);
76 static int ultra32_close(struct net_device *dev);
77
78 #define ULTRA32_CMDREG 0 /* Offset to ASIC command register. */
79 #define ULTRA32_RESET 0x80 /* Board reset, in ULTRA32_CMDREG. */
80 #define ULTRA32_MEMENB 0x40 /* Enable the shared memory. */
81 #define ULTRA32_NIC_OFFSET 16 /* NIC register offset from the base_addr. */
82 #define ULTRA32_IO_EXTENT 32
83 #define EN0_ERWCNT 0x08 /* Early receive warning count. */
84
85 /*
86 * Defines that apply only to the Ultra32 EISA card. Note that
87 * "smc" = 10011 01101 00011 = 0x4da3, and hence !smc8010.cfg translates
88 * into an EISA ID of 0x1080A34D
89 */
90 #define ULTRA32_BASE 0xca0
91 #define ULTRA32_ID 0x1080a34d
92 #define ULTRA32_IDPORT (-0x20) /* 0xc80 */
93 /* Config regs 1->7 from the EISA !SMC8010.CFG file. */
94 #define ULTRA32_CFG1 0x04 /* 0xca4 */
95 #define ULTRA32_CFG2 0x05 /* 0xca5 */
96 #define ULTRA32_CFG3 (-0x18) /* 0xc88 */
97 #define ULTRA32_CFG4 (-0x17) /* 0xc89 */
98 #define ULTRA32_CFG5 (-0x16) /* 0xc8a */
99 #define ULTRA32_CFG6 (-0x15) /* 0xc8b */
100 #define ULTRA32_CFG7 0x0d /* 0xcad */
101
cleanup_card(struct net_device * dev)102 static void cleanup_card(struct net_device *dev)
103 {
104 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET;
105 /* NB: ultra32_close_card() does free_irq */
106 release_region(ioaddr, ULTRA32_IO_EXTENT);
107 iounmap(ei_status.mem);
108 }
109
110 /* Probe for the Ultra32. This looks like a 8013 with the station
111 address PROM at I/O ports <base>+8 to <base>+13, with a checksum
112 following.
113 */
114
ultra32_probe(int unit)115 struct net_device * __init ultra32_probe(int unit)
116 {
117 struct net_device *dev;
118 int base;
119 int irq;
120 int err = -ENODEV;
121
122 if (!EISA_bus)
123 return ERR_PTR(-ENODEV);
124
125 dev = alloc_ei_netdev();
126
127 if (!dev)
128 return ERR_PTR(-ENOMEM);
129
130 if (unit >= 0) {
131 sprintf(dev->name, "eth%d", unit);
132 netdev_boot_setup_check(dev);
133 }
134
135 irq = dev->irq;
136
137 /* EISA spec allows for up to 16 slots, but 8 is typical. */
138 for (base = 0x1000 + ULTRA32_BASE; base < 0x9000; base += 0x1000) {
139 if (ultra32_probe1(dev, base) == 0)
140 break;
141 dev->irq = irq;
142 }
143 if (base >= 0x9000)
144 goto out;
145 err = register_netdev(dev);
146 if (err)
147 goto out1;
148 return dev;
149 out1:
150 cleanup_card(dev);
151 out:
152 free_netdev(dev);
153 return ERR_PTR(err);
154 }
155
ultra32_probe1(struct net_device * dev,int ioaddr)156 static int __init ultra32_probe1(struct net_device *dev, int ioaddr)
157 {
158 int i, edge, media, retval;
159 int checksum = 0;
160 const char *model_name;
161 static unsigned version_printed;
162 /* Values from various config regs. */
163 unsigned char idreg;
164 unsigned char reg4;
165 const char *ifmap[] = {"UTP No Link", "", "UTP/AUI", "UTP/BNC"};
166
167 if (!request_region(ioaddr, ULTRA32_IO_EXTENT, DRV_NAME))
168 return -EBUSY;
169
170 if (inb(ioaddr + ULTRA32_IDPORT) == 0xff ||
171 inl(ioaddr + ULTRA32_IDPORT) != ULTRA32_ID) {
172 retval = -ENODEV;
173 goto out;
174 }
175
176 media = inb(ioaddr + ULTRA32_CFG7) & 0x03;
177 edge = inb(ioaddr + ULTRA32_CFG5) & 0x08;
178 printk("SMC Ultra32 in EISA Slot %d, Media: %s, %s IRQs.\n",
179 ioaddr >> 12, ifmap[media],
180 (edge ? "Edge Triggered" : "Level Sensitive"));
181
182 idreg = inb(ioaddr + 7);
183 reg4 = inb(ioaddr + 4) & 0x7f;
184
185 /* Check the ID nibble. */
186 if ((idreg & 0xf0) != 0x20) { /* SMC Ultra */
187 retval = -ENODEV;
188 goto out;
189 }
190
191 /* Select the station address register set. */
192 outb(reg4, ioaddr + 4);
193
194 for (i = 0; i < 8; i++)
195 checksum += inb(ioaddr + 8 + i);
196 if ((checksum & 0xff) != 0xff) {
197 retval = -ENODEV;
198 goto out;
199 }
200
201 if (ei_debug && version_printed++ == 0)
202 printk(version);
203
204 model_name = "SMC Ultra32";
205
206 for (i = 0; i < 6; i++)
207 dev->dev_addr[i] = inb(ioaddr + 8 + i);
208
209 printk("%s: %s at 0x%X, %pM",
210 dev->name, model_name, ioaddr, dev->dev_addr);
211
212 /* Switch from the station address to the alternate register set and
213 read the useful registers there. */
214 outb(0x80 | reg4, ioaddr + 4);
215
216 /* Enable FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
217 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
218
219 /* Reset RAM addr. */
220 outb(0x00, ioaddr + 0x0b);
221
222 /* Switch back to the station address register set so that the
223 MS-DOS driver can find the card after a warm boot. */
224 outb(reg4, ioaddr + 4);
225
226 if ((inb(ioaddr + ULTRA32_CFG5) & 0x40) == 0) {
227 printk("\nsmc-ultra32: Card RAM is disabled! "
228 "Run EISA config utility.\n");
229 retval = -ENODEV;
230 goto out;
231 }
232 if ((inb(ioaddr + ULTRA32_CFG2) & 0x04) == 0)
233 printk("\nsmc-ultra32: Ignoring Bus-Master enable bit. "
234 "Run EISA config utility.\n");
235
236 if (dev->irq < 2) {
237 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
238 int irq = irqmap[inb(ioaddr + ULTRA32_CFG5) & 0x07];
239 if (irq == 0) {
240 printk(", failed to detect IRQ line.\n");
241 retval = -EAGAIN;
242 goto out;
243 }
244 dev->irq = irq;
245 }
246
247 /* The 8390 isn't at the base address, so fake the offset */
248 dev->base_addr = ioaddr + ULTRA32_NIC_OFFSET;
249
250 /* Save RAM address in the unused reg0 to avoid excess inb's. */
251 ei_status.reg0 = inb(ioaddr + ULTRA32_CFG3) & 0xfc;
252
253 dev->mem_start = 0xc0000 + ((ei_status.reg0 & 0x7c) << 11);
254
255 ei_status.name = model_name;
256 ei_status.word16 = 1;
257 ei_status.tx_start_page = 0;
258 ei_status.rx_start_page = TX_PAGES;
259 /* All Ultra32 cards have 32KB memory with an 8KB window. */
260 ei_status.stop_page = 128;
261
262 ei_status.mem = ioremap(dev->mem_start, 0x2000);
263 if (!ei_status.mem) {
264 printk(", failed to ioremap.\n");
265 retval = -ENOMEM;
266 goto out;
267 }
268 dev->mem_end = dev->mem_start + 0x1fff;
269
270 printk(", IRQ %d, 32KB memory, 8KB window at 0x%lx-0x%lx.\n",
271 dev->irq, dev->mem_start, dev->mem_end);
272 ei_status.block_input = &ultra32_block_input;
273 ei_status.block_output = &ultra32_block_output;
274 ei_status.get_8390_hdr = &ultra32_get_8390_hdr;
275 ei_status.reset_8390 = &ultra32_reset_8390;
276 dev->open = &ultra32_open;
277 dev->stop = &ultra32_close;
278 #ifdef CONFIG_NET_POLL_CONTROLLER
279 dev->poll_controller = ei_poll;
280 #endif
281 NS8390_init(dev, 0);
282
283 return 0;
284 out:
285 release_region(ioaddr, ULTRA32_IO_EXTENT);
286 return retval;
287 }
288
ultra32_open(struct net_device * dev)289 static int ultra32_open(struct net_device *dev)
290 {
291 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC addr */
292 int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : IRQF_SHARED;
293 int retval;
294
295 retval = request_irq(dev->irq, ei_interrupt, irq_flags, dev->name, dev);
296 if (retval)
297 return retval;
298
299 outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
300 outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
301 outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
302 outb(0x01, ioaddr + 6); /* Enable Interrupts. */
303 /* Set the early receive warning level in window 0 high enough not
304 to receive ERW interrupts. */
305 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
306 outb(0xff, dev->base_addr + EN0_ERWCNT);
307 ei_open(dev);
308 return 0;
309 }
310
ultra32_close(struct net_device * dev)311 static int ultra32_close(struct net_device *dev)
312 {
313 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* CMDREG */
314
315 netif_stop_queue(dev);
316
317 if (ei_debug > 1)
318 printk("%s: Shutting down ethercard.\n", dev->name);
319
320 outb(0x00, ioaddr + ULTRA32_CFG6); /* Disable Interrupts. */
321 outb(0x00, ioaddr + 6); /* Disable interrupts. */
322 free_irq(dev->irq, dev);
323
324 NS8390_init(dev, 0);
325
326 return 0;
327 }
328
ultra32_reset_8390(struct net_device * dev)329 static void ultra32_reset_8390(struct net_device *dev)
330 {
331 int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC base addr */
332
333 outb(ULTRA32_RESET, ioaddr);
334 if (ei_debug > 1) printk("resetting Ultra32, t=%ld...", jiffies);
335 ei_status.txing = 0;
336
337 outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
338 outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
339 outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
340 outb(0x01, ioaddr + 6); /* Enable Interrupts. */
341 if (ei_debug > 1) printk("reset done\n");
342 return;
343 }
344
345 /* Grab the 8390 specific header. Similar to the block_input routine, but
346 we don't need to be concerned with ring wrap as the header will be at
347 the start of a page, so we optimize accordingly. */
348
ultra32_get_8390_hdr(struct net_device * dev,struct e8390_pkt_hdr * hdr,int ring_page)349 static void ultra32_get_8390_hdr(struct net_device *dev,
350 struct e8390_pkt_hdr *hdr,
351 int ring_page)
352 {
353 void __iomem *hdr_start = ei_status.mem + ((ring_page & 0x1f) << 8);
354 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
355
356 /* Select correct 8KB Window. */
357 outb(ei_status.reg0 | ((ring_page & 0x60) >> 5), RamReg);
358
359 #ifdef __BIG_ENDIAN
360 /* Officially this is what we are doing, but the readl() is faster */
361 /* unfortunately it isn't endian aware of the struct */
362 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
363 hdr->count = le16_to_cpu(hdr->count);
364 #else
365 ((unsigned int*)hdr)[0] = readl(hdr_start);
366 #endif
367 }
368
369 /* Block input and output are easy on shared memory ethercards, the only
370 complication is when the ring buffer wraps, or in this case, when a
371 packet spans an 8KB boundary. Note that the current 8KB segment is
372 already set by the get_8390_hdr routine. */
373
ultra32_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)374 static void ultra32_block_input(struct net_device *dev,
375 int count,
376 struct sk_buff *skb,
377 int ring_offset)
378 {
379 void __iomem *xfer_start = ei_status.mem + (ring_offset & 0x1fff);
380 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
381
382 if ((ring_offset & ~0x1fff) != ((ring_offset + count - 1) & ~0x1fff)) {
383 int semi_count = 8192 - (ring_offset & 0x1FFF);
384 memcpy_fromio(skb->data, xfer_start, semi_count);
385 count -= semi_count;
386 if (ring_offset < 96*256) {
387 /* Select next 8KB Window. */
388 ring_offset += semi_count;
389 outb(ei_status.reg0 | ((ring_offset & 0x6000) >> 13), RamReg);
390 memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
391 } else {
392 /* Select first 8KB Window. */
393 outb(ei_status.reg0, RamReg);
394 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
395 }
396 } else {
397 memcpy_fromio(skb->data, xfer_start, count);
398 }
399 }
400
ultra32_block_output(struct net_device * dev,int count,const unsigned char * buf,int start_page)401 static void ultra32_block_output(struct net_device *dev,
402 int count,
403 const unsigned char *buf,
404 int start_page)
405 {
406 void __iomem *xfer_start = ei_status.mem + (start_page<<8);
407 unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
408
409 /* Select first 8KB Window. */
410 outb(ei_status.reg0, RamReg);
411
412 memcpy_toio(xfer_start, buf, count);
413 }
414
415 #ifdef MODULE
416 #define MAX_ULTRA32_CARDS 4 /* Max number of Ultra cards per module */
417 static struct net_device *dev_ultra[MAX_ULTRA32_CARDS];
418
419 MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver");
420 MODULE_LICENSE("GPL");
421
init_module(void)422 int __init init_module(void)
423 {
424 int this_dev, found = 0;
425
426 for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
427 struct net_device *dev = ultra32_probe(-1);
428 if (IS_ERR(dev))
429 break;
430 dev_ultra[found++] = dev;
431 }
432 if (found)
433 return 0;
434 printk(KERN_WARNING "smc-ultra32.c: No SMC Ultra32 found.\n");
435 return -ENXIO;
436 }
437
cleanup_module(void)438 void __exit cleanup_module(void)
439 {
440 int this_dev;
441
442 for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
443 struct net_device *dev = dev_ultra[this_dev];
444 if (dev) {
445 unregister_netdev(dev);
446 cleanup_card(dev);
447 free_netdev(dev);
448 }
449 }
450 }
451 #endif /* MODULE */
452
453