1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57static const char version[] =
58 "smc-ultra.c:v2.02 2/3/98 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
59
60#include <linux/module.h>
61#include <linux/kernel.h>
62#include <linux/errno.h>
63#include <linux/string.h>
64#include <linux/init.h>
65#include <linux/isapnp.h>
66#include <linux/netdevice.h>
67#include <linux/etherdevice.h>
68
69#include <asm/io.h>
70#include <asm/irq.h>
71#include <asm/system.h>
72
73#include "8390.h"
74
75#define DRV_NAME "smc-ultra"
76
77
78static unsigned int ultra_portlist[] __initdata =
79{0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
80
81static int ultra_probe1(struct net_device *dev, int ioaddr);
82
83#ifdef __ISAPNP__
84static int ultra_probe_isapnp(struct net_device *dev);
85#endif
86
87static int ultra_open(struct net_device *dev);
88static void ultra_reset_8390(struct net_device *dev);
89static void ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
90 int ring_page);
91static void ultra_block_input(struct net_device *dev, int count,
92 struct sk_buff *skb, int ring_offset);
93static void ultra_block_output(struct net_device *dev, int count,
94 const unsigned char *buf, const int start_page);
95static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
96 int ring_page);
97static void ultra_pio_input(struct net_device *dev, int count,
98 struct sk_buff *skb, int ring_offset);
99static void ultra_pio_output(struct net_device *dev, int count,
100 const unsigned char *buf, const int start_page);
101static int ultra_close_card(struct net_device *dev);
102
103#ifdef __ISAPNP__
104static struct isapnp_device_id ultra_device_ids[] __initdata = {
105 { ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
106 ISAPNP_VENDOR('S','M','C'), ISAPNP_FUNCTION(0x8416),
107 (long) "SMC EtherEZ (8416)" },
108 { }
109};
110
111MODULE_DEVICE_TABLE(isapnp, ultra_device_ids);
112#endif
113
114
115#define START_PG 0x00
116
117#define ULTRA_CMDREG 0
118#define ULTRA_RESET 0x80
119#define ULTRA_MEMENB 0x40
120#define IOPD 0x02
121#define IOPA 0x07
122#define ULTRA_NIC_OFFSET 16
123#define ULTRA_IO_EXTENT 32
124#define EN0_ERWCNT 0x08
125
126#ifdef CONFIG_NET_POLL_CONTROLLER
127static void ultra_poll(struct net_device *dev)
128{
129 disable_irq(dev->irq);
130 ei_interrupt(dev->irq, dev);
131 enable_irq(dev->irq);
132}
133#endif
134
135
136
137
138
139static int __init do_ultra_probe(struct net_device *dev)
140{
141 int i;
142 int base_addr = dev->base_addr;
143 int irq = dev->irq;
144
145 if (base_addr > 0x1ff)
146 return ultra_probe1(dev, base_addr);
147 else if (base_addr != 0)
148 return -ENXIO;
149
150#ifdef __ISAPNP__
151
152 if (isapnp_present() && (ultra_probe_isapnp(dev) == 0))
153 return 0;
154#endif
155
156 for (i = 0; ultra_portlist[i]; i++) {
157 dev->irq = irq;
158 if (ultra_probe1(dev, ultra_portlist[i]) == 0)
159 return 0;
160 }
161
162 return -ENODEV;
163}
164
165#ifndef MODULE
166struct net_device * __init ultra_probe(int unit)
167{
168 struct net_device *dev = alloc_ei_netdev();
169 int err;
170
171 if (!dev)
172 return ERR_PTR(-ENOMEM);
173
174 sprintf(dev->name, "eth%d", unit);
175 netdev_boot_setup_check(dev);
176
177 err = do_ultra_probe(dev);
178 if (err)
179 goto out;
180 return dev;
181out:
182 free_netdev(dev);
183 return ERR_PTR(err);
184}
185#endif
186
187static const struct net_device_ops ultra_netdev_ops = {
188 .ndo_open = ultra_open,
189 .ndo_stop = ultra_close_card,
190
191 .ndo_start_xmit = ei_start_xmit,
192 .ndo_tx_timeout = ei_tx_timeout,
193 .ndo_get_stats = ei_get_stats,
194 .ndo_set_multicast_list = ei_set_multicast_list,
195 .ndo_validate_addr = eth_validate_addr,
196 .ndo_set_mac_address = eth_mac_addr,
197 .ndo_change_mtu = eth_change_mtu,
198#ifdef CONFIG_NET_POLL_CONTROLLER
199 .ndo_poll_controller = ultra_poll,
200#endif
201};
202
203static int __init ultra_probe1(struct net_device *dev, int ioaddr)
204{
205 int i, retval;
206 int checksum = 0;
207 const char *model_name;
208 unsigned char eeprom_irq = 0;
209 static unsigned version_printed;
210
211 unsigned char num_pages, irqreg, addr, piomode;
212 unsigned char idreg = inb(ioaddr + 7);
213 unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
214
215 if (!request_region(ioaddr, ULTRA_IO_EXTENT, DRV_NAME))
216 return -EBUSY;
217
218
219 if ((idreg & 0xF0) != 0x20
220 && (idreg & 0xF0) != 0x40) {
221 retval = -ENODEV;
222 goto out;
223 }
224
225
226 outb(reg4, ioaddr + 4);
227
228 for (i = 0; i < 8; i++)
229 checksum += inb(ioaddr + 8 + i);
230 if ((checksum & 0xff) != 0xFF) {
231 retval = -ENODEV;
232 goto out;
233 }
234
235 if (ei_debug && version_printed++ == 0)
236 printk(version);
237
238 model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
239
240 for (i = 0; i < 6; i++)
241 dev->dev_addr[i] = inb(ioaddr + 8 + i);
242
243 printk("%s: %s at %#3x, %pM", dev->name, model_name,
244 ioaddr, dev->dev_addr);
245
246
247
248 outb(0x80 | reg4, ioaddr + 4);
249
250
251 outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
252 piomode = inb(ioaddr + 0x8);
253 addr = inb(ioaddr + 0xb);
254 irqreg = inb(ioaddr + 0xd);
255
256
257
258 outb(reg4, ioaddr + 4);
259
260 if (dev->irq < 2) {
261 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
262 int irq;
263
264
265 irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
266
267 if (irq == 0) {
268 printk(", failed to detect IRQ line.\n");
269 retval = -EAGAIN;
270 goto out;
271 }
272 dev->irq = irq;
273 eeprom_irq = 1;
274 }
275
276
277 dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
278
279 {
280 int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
281 short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
282
283 dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
284 num_pages = num_pages_tbl[(addr >> 4) & 3];
285 }
286
287 ei_status.name = model_name;
288 ei_status.word16 = 1;
289 ei_status.tx_start_page = START_PG;
290 ei_status.rx_start_page = START_PG + TX_PAGES;
291 ei_status.stop_page = num_pages;
292
293 ei_status.mem = ioremap(dev->mem_start, (ei_status.stop_page - START_PG)*256);
294 if (!ei_status.mem) {
295 printk(", failed to ioremap.\n");
296 retval = -ENOMEM;
297 goto out;
298 }
299
300 dev->mem_end = dev->mem_start + (ei_status.stop_page - START_PG)*256;
301
302 if (piomode) {
303 printk(",%s IRQ %d programmed-I/O mode.\n",
304 eeprom_irq ? "EEPROM" : "assigned ", dev->irq);
305 ei_status.block_input = &ultra_pio_input;
306 ei_status.block_output = &ultra_pio_output;
307 ei_status.get_8390_hdr = &ultra_pio_get_hdr;
308 } else {
309 printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
310 dev->irq, dev->mem_start, dev->mem_end-1);
311 ei_status.block_input = &ultra_block_input;
312 ei_status.block_output = &ultra_block_output;
313 ei_status.get_8390_hdr = &ultra_get_8390_hdr;
314 }
315 ei_status.reset_8390 = &ultra_reset_8390;
316
317 dev->netdev_ops = &ultra_netdev_ops;
318 NS8390_init(dev, 0);
319
320 retval = register_netdev(dev);
321 if (retval)
322 goto out;
323 return 0;
324out:
325 release_region(ioaddr, ULTRA_IO_EXTENT);
326 return retval;
327}
328
329#ifdef __ISAPNP__
330static int __init ultra_probe_isapnp(struct net_device *dev)
331{
332 int i;
333
334 for (i = 0; ultra_device_ids[i].vendor != 0; i++) {
335 struct pnp_dev *idev = NULL;
336
337 while ((idev = pnp_find_dev(NULL,
338 ultra_device_ids[i].vendor,
339 ultra_device_ids[i].function,
340 idev))) {
341
342 if (pnp_device_attach(idev) < 0)
343 continue;
344 if (pnp_activate_dev(idev) < 0) {
345 __again:
346 pnp_device_detach(idev);
347 continue;
348 }
349
350 if (!pnp_port_valid(idev, 0) || !pnp_irq_valid(idev, 0))
351 goto __again;
352
353 dev->base_addr = pnp_port_start(idev, 0);
354 dev->irq = pnp_irq(idev, 0);
355 printk(KERN_INFO "smc-ultra.c: ISAPnP reports %s at i/o %#lx, irq %d.\n",
356 (char *) ultra_device_ids[i].driver_data,
357 dev->base_addr, dev->irq);
358 if (ultra_probe1(dev, dev->base_addr) != 0) {
359 printk(KERN_ERR "smc-ultra.c: Probe of ISAPnP card at %#lx failed.\n", dev->base_addr);
360 pnp_device_detach(idev);
361 return -ENXIO;
362 }
363 ei_status.priv = (unsigned long)idev;
364 break;
365 }
366 if (!idev)
367 continue;
368 return 0;
369 }
370
371 return -ENODEV;
372}
373#endif
374
375static int
376ultra_open(struct net_device *dev)
377{
378 int retval;
379 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
380 unsigned char irq2reg[] = {0, 0, 0x04, 0x08, 0, 0x0C, 0, 0x40,
381 0, 0x04, 0x44, 0x48, 0, 0, 0, 0x4C, };
382
383 retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev);
384 if (retval)
385 return retval;
386
387 outb(0x00, ioaddr);
388 outb(0x80, ioaddr + 5);
389
390 outb(inb(ioaddr + 4) | 0x80, ioaddr + 4);
391 outb((inb(ioaddr + 13) & ~0x4C) | irq2reg[dev->irq], ioaddr + 13);
392 outb(inb(ioaddr + 4) & 0x7f, ioaddr + 4);
393
394 if (ei_status.block_input == &ultra_pio_input) {
395 outb(0x11, ioaddr + 6);
396 outb(0x01, ioaddr + 0x19);
397 } else
398 outb(0x01, ioaddr + 6);
399
400
401 outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
402 outb(0xff, dev->base_addr + EN0_ERWCNT);
403 ei_open(dev);
404 return 0;
405}
406
407static void
408ultra_reset_8390(struct net_device *dev)
409{
410 int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET;
411
412 outb(ULTRA_RESET, cmd_port);
413 if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
414 ei_status.txing = 0;
415
416 outb(0x00, cmd_port);
417 outb(0x80, cmd_port + 5);
418 if (ei_status.block_input == &ultra_pio_input)
419 outb(0x11, cmd_port + 6);
420 else
421 outb(0x01, cmd_port + 6);
422
423 if (ei_debug > 1) printk("reset done\n");
424 return;
425}
426
427
428
429
430
431static void
432ultra_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
433{
434 void __iomem *hdr_start = ei_status.mem + ((ring_page - START_PG)<<8);
435
436 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
437#ifdef __BIG_ENDIAN
438
439
440 memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
441 hdr->count = le16_to_cpu(hdr->count);
442#else
443 ((unsigned int*)hdr)[0] = readl(hdr_start);
444#endif
445 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);
446}
447
448
449
450
451static void
452ultra_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
453{
454 void __iomem *xfer_start = ei_status.mem + ring_offset - (START_PG<<8);
455
456
457 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
458
459 if (ring_offset + count > ei_status.stop_page*256) {
460
461 int semi_count = ei_status.stop_page*256 - ring_offset;
462 memcpy_fromio(skb->data, xfer_start, semi_count);
463 count -= semi_count;
464 memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
465 } else {
466 memcpy_fromio(skb->data, xfer_start, count);
467 }
468
469 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);
470}
471
472static void
473ultra_block_output(struct net_device *dev, int count, const unsigned char *buf,
474 int start_page)
475{
476 void __iomem *shmem = ei_status.mem + ((start_page - START_PG)<<8);
477
478
479 outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
480
481 memcpy_toio(shmem, buf, count);
482
483 outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);
484}
485
486
487
488
489
490
491
492
493
494static void ultra_pio_get_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
495 int ring_page)
496{
497 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
498 outb(0x00, ioaddr + IOPA);
499 outb(ring_page, ioaddr + IOPA);
500 insw(ioaddr + IOPD, hdr, sizeof(struct e8390_pkt_hdr)>>1);
501}
502
503static void ultra_pio_input(struct net_device *dev, int count,
504 struct sk_buff *skb, int ring_offset)
505{
506 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
507 char *buf = skb->data;
508
509
510 outb(ring_offset, ioaddr + IOPA);
511 outb(ring_offset >> 8, ioaddr + IOPA);
512
513 insw(ioaddr + IOPD, buf, (count+1)>>1);
514}
515
516static void ultra_pio_output(struct net_device *dev, int count,
517 const unsigned char *buf, const int start_page)
518{
519 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
520 outb(0x00, ioaddr + IOPA);
521 outb(start_page, ioaddr + IOPA);
522
523 outsw(ioaddr + IOPD, buf, (count+1)>>1);
524}
525
526static int
527ultra_close_card(struct net_device *dev)
528{
529 int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
530
531 netif_stop_queue(dev);
532
533 if (ei_debug > 1)
534 printk("%s: Shutting down ethercard.\n", dev->name);
535
536 outb(0x00, ioaddr + 6);
537 free_irq(dev->irq, dev);
538
539 NS8390_init(dev, 0);
540
541
542
543
544 return 0;
545}
546
547
548#ifdef MODULE
549#define MAX_ULTRA_CARDS 4
550static struct net_device *dev_ultra[MAX_ULTRA_CARDS];
551static int io[MAX_ULTRA_CARDS];
552static int irq[MAX_ULTRA_CARDS];
553
554module_param_array(io, int, NULL, 0);
555module_param_array(irq, int, NULL, 0);
556MODULE_PARM_DESC(io, "I/O base address(es)");
557MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)");
558MODULE_DESCRIPTION("SMC Ultra/EtherEZ ISA/PnP Ethernet driver");
559MODULE_LICENSE("GPL");
560
561
562
563int __init
564init_module(void)
565{
566 struct net_device *dev;
567 int this_dev, found = 0;
568
569 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
570 if (io[this_dev] == 0) {
571 if (this_dev != 0) break;
572 printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
573 }
574 dev = alloc_ei_netdev();
575 if (!dev)
576 break;
577 dev->irq = irq[this_dev];
578 dev->base_addr = io[this_dev];
579 if (do_ultra_probe(dev) == 0) {
580 dev_ultra[found++] = dev;
581 continue;
582 }
583 free_netdev(dev);
584 printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
585 break;
586 }
587 if (found)
588 return 0;
589 return -ENXIO;
590}
591
592static void cleanup_card(struct net_device *dev)
593{
594
595#ifdef __ISAPNP__
596 struct pnp_dev *idev = (struct pnp_dev *)ei_status.priv;
597 if (idev)
598 pnp_device_detach(idev);
599#endif
600 release_region(dev->base_addr - ULTRA_NIC_OFFSET, ULTRA_IO_EXTENT);
601 iounmap(ei_status.mem);
602}
603
604void __exit
605cleanup_module(void)
606{
607 int this_dev;
608
609 for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
610 struct net_device *dev = dev_ultra[this_dev];
611 if (dev) {
612 unregister_netdev(dev);
613 cleanup_card(dev);
614 free_netdev(dev);
615 }
616 }
617}
618#endif
619