V4L/DVB (9391): Register definition bugs
[linux-2.6] / drivers / net / smc-ultra32.c
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
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
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
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
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
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
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
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
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
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
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
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