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