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#include <linux/errno.h>
39#include <linux/netdevice.h>
40#include <linux/etherdevice.h>
41#include <linux/module.h>
42#include <linux/kernel.h>
43#include <linux/types.h>
44#include <linux/fcntl.h>
45#include <linux/interrupt.h>
46#include <linux/ioport.h>
47#include <linux/in.h>
48#include <linux/skbuff.h>
49#include <linux/string.h>
50#include <linux/init.h>
51#include <linux/crc32.h>
52#include <linux/bitops.h>
53
54#include <asm/io.h>
55#include <asm/dma.h>
56
57static char version[] __initdata =
58 "at1700.c:v1.16 9/11/06 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
59
60#define DRV_NAME "at1700"
61
62
63
64
65#define MC_FILTERBREAK 64
66
67
68
69static int fmv18x_probe_list[] __initdata = {
70 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
71};
72
73
74
75
76
77static unsigned at1700_probe_list[] __initdata = {
78 0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
79};
80
81
82#ifndef NET_DEBUG
83#define NET_DEBUG 1
84#endif
85static unsigned int net_debug = NET_DEBUG;
86
87typedef unsigned char uchar;
88
89
90struct net_local {
91 spinlock_t lock;
92 unsigned char mc_filter[8];
93 uint jumpered:1;
94 uint tx_started:1;
95 uint tx_queue_ready:1;
96 uint rx_started:1;
97 uchar tx_queue;
98 ushort tx_queue_len;
99};
100
101
102
103#define STATUS 0
104#define TX_STATUS 0
105#define RX_STATUS 1
106#define TX_INTR 2
107#define RX_INTR 3
108#define TX_MODE 4
109#define RX_MODE 5
110#define CONFIG_0 6
111#define CONFIG_1 7
112
113#define DATAPORT 8
114#define TX_START 10
115#define COL16CNTL 11
116#define MODE13 13
117#define RX_CTRL 14
118
119#define EEPROM_Ctrl 16
120#define EEPROM_Data 17
121#define CARDSTATUS 16
122#define CARDSTATUS1 17
123#define IOCONFIG 18
124#define IOCONFIG1 19
125#define SAPROM 20
126#define MODE24 24
127#define RESET 31
128#define AT1700_IO_EXTENT 32
129#define PORT_OFFSET(o) (o)
130
131
132#define TX_TIMEOUT (HZ/10)
133
134
135
136
137static int at1700_probe1(struct net_device *dev, int ioaddr);
138static int read_eeprom(long ioaddr, int location);
139static int net_open(struct net_device *dev);
140static netdev_tx_t net_send_packet(struct sk_buff *skb,
141 struct net_device *dev);
142static irqreturn_t net_interrupt(int irq, void *dev_id);
143static void net_rx(struct net_device *dev);
144static int net_close(struct net_device *dev);
145static void set_rx_mode(struct net_device *dev);
146static void net_tx_timeout (struct net_device *dev);
147
148
149
150
151
152
153
154
155
156static int io = 0x260;
157
158static int irq;
159
160static void cleanup_card(struct net_device *dev)
161{
162 free_irq(dev->irq, NULL);
163 release_region(dev->base_addr, AT1700_IO_EXTENT);
164}
165
166struct net_device * __init at1700_probe(int unit)
167{
168 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
169 unsigned *port;
170 int err = 0;
171
172 if (!dev)
173 return ERR_PTR(-ENODEV);
174
175 if (unit >= 0) {
176 sprintf(dev->name, "eth%d", unit);
177 netdev_boot_setup_check(dev);
178 io = dev->base_addr;
179 irq = dev->irq;
180 } else {
181 dev->base_addr = io;
182 dev->irq = irq;
183 }
184
185 if (io > 0x1ff) {
186 err = at1700_probe1(dev, io);
187 } else if (io != 0) {
188 err = -ENXIO;
189 } else {
190 for (port = at1700_probe_list; *port; port++) {
191 if (at1700_probe1(dev, *port) == 0)
192 break;
193 dev->irq = irq;
194 }
195 if (!*port)
196 err = -ENODEV;
197 }
198 if (err)
199 goto out;
200 err = register_netdev(dev);
201 if (err)
202 goto out1;
203 return dev;
204out1:
205 cleanup_card(dev);
206out:
207 free_netdev(dev);
208 return ERR_PTR(err);
209}
210
211static const struct net_device_ops at1700_netdev_ops = {
212 .ndo_open = net_open,
213 .ndo_stop = net_close,
214 .ndo_start_xmit = net_send_packet,
215 .ndo_set_rx_mode = set_rx_mode,
216 .ndo_tx_timeout = net_tx_timeout,
217 .ndo_change_mtu = eth_change_mtu,
218 .ndo_set_mac_address = eth_mac_addr,
219 .ndo_validate_addr = eth_validate_addr,
220};
221
222
223
224
225
226
227
228
229
230static int __init at1700_probe1(struct net_device *dev, int ioaddr)
231{
232 static const char fmv_irqmap[4] = {3, 7, 10, 15};
233 static const char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
234 static const char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
235 unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
236 int ret = -ENODEV;
237 struct net_local *lp = netdev_priv(dev);
238
239 if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
240 return -EBUSY;
241
242
243
244
245
246#ifdef notdef
247 printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
248 ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
249 read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
250#endif
251
252
253 if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr &&
254 read_eeprom(ioaddr, 4) == 0x0000 &&
255 (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
256 is_at1700 = 1;
257 else if (inb(ioaddr + SAPROM ) == 0x00 &&
258 inb(ioaddr + SAPROM + 1) == 0x00 &&
259 inb(ioaddr + SAPROM + 2) == 0x0e)
260 is_fmv18x = 1;
261 else {
262 goto err_out;
263 }
264
265
266 outb(0, ioaddr + RESET);
267
268 if (is_at1700) {
269 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
270 | (read_eeprom(ioaddr, 0)>>14)];
271 } else {
272
273
274 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
275 irq = dev->irq;
276 for (i = 0; i < 8; i++) {
277 if (irq == fmv_irqmap_pnp[i])
278 break;
279 }
280 if (i == 8) {
281 goto err_out;
282 }
283 } else {
284 if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
285 goto err_out;
286 irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
287 }
288 }
289
290 printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
291 is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
292
293 dev->base_addr = ioaddr;
294 dev->irq = irq;
295
296 if (is_at1700) {
297 for(i = 0; i < 3; i++) {
298 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
299 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
300 }
301 } else {
302 for(i = 0; i < 6; i++) {
303 unsigned char val = inb(ioaddr + SAPROM + i);
304 dev->dev_addr[i] = val;
305 }
306 }
307 printk("%pM", dev->dev_addr);
308
309
310
311
312
313
314
315 {
316 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
317 if (is_at1700) {
318 ushort setup_value = read_eeprom(ioaddr, 12);
319 dev->if_port = setup_value >> 8;
320 } else {
321 ushort setup_value = inb(ioaddr + CARDSTATUS);
322 switch (setup_value & 0x07) {
323 case 0x01:
324 case 0x02:
325 dev->if_port = 0x18; break;
326 case 0x04:
327 dev->if_port = 0x08; break;
328 default:
329 dev->if_port = 0x00; break;
330 }
331 }
332 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
333 }
334
335
336
337 outb(0xda, ioaddr + CONFIG_0);
338
339
340 outb(0x00, ioaddr + CONFIG_1);
341 for (i = 0; i < 6; i++)
342 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
343
344
345 outb(0x04, ioaddr + CONFIG_1);
346 for (i = 0; i < 8; i++)
347 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
348
349
350
351
352 outb(0x08, ioaddr + CONFIG_1);
353 outb(dev->if_port, ioaddr + MODE13);
354 outb(0x00, ioaddr + COL16CNTL);
355
356 if (net_debug)
357 printk(version);
358
359 dev->netdev_ops = &at1700_netdev_ops;
360 dev->watchdog_timeo = TX_TIMEOUT;
361
362 spin_lock_init(&lp->lock);
363
364 lp->jumpered = is_fmv18x;
365
366 ret = request_irq(irq, net_interrupt, 0, DRV_NAME, dev);
367 if (ret) {
368 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
369 "conflict on IRQ %d.\n",
370 ioaddr, irq);
371 goto err_out;
372 }
373
374 return 0;
375
376err_out:
377 release_region(ioaddr, AT1700_IO_EXTENT);
378 return ret;
379}
380
381
382
383#define EE_SHIFT_CLK 0x40
384#define EE_CS 0x20
385#define EE_DATA_WRITE 0x80
386#define EE_DATA_READ 0x80
387
388
389#define EE_WRITE_CMD (5 << 6)
390#define EE_READ_CMD (6 << 6)
391#define EE_ERASE_CMD (7 << 6)
392
393static int __init read_eeprom(long ioaddr, int location)
394{
395 int i;
396 unsigned short retval = 0;
397 long ee_addr = ioaddr + EEPROM_Ctrl;
398 long ee_daddr = ioaddr + EEPROM_Data;
399 int read_cmd = location | EE_READ_CMD;
400
401
402 for (i = 9; i >= 0; i--) {
403 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
404 outb(EE_CS, ee_addr);
405 outb(dataval, ee_daddr);
406 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
407 }
408 outb(EE_DATA_WRITE, ee_daddr);
409 for (i = 16; i > 0; i--) {
410 outb(EE_CS, ee_addr);
411 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
412 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
413 }
414
415
416 outb(EE_CS, ee_addr);
417 outb(EE_SHIFT_CLK, ee_addr);
418 outb(0, ee_addr);
419 return retval;
420}
421
422
423
424static int net_open(struct net_device *dev)
425{
426 struct net_local *lp = netdev_priv(dev);
427 int ioaddr = dev->base_addr;
428
429
430
431 outb(0x5a, ioaddr + CONFIG_0);
432
433
434 outb(0xe8, ioaddr + CONFIG_1);
435
436 lp->tx_started = 0;
437 lp->tx_queue_ready = 1;
438 lp->rx_started = 0;
439 lp->tx_queue = 0;
440 lp->tx_queue_len = 0;
441
442
443 outb(0x82, ioaddr + TX_INTR);
444 outb(0x81, ioaddr + RX_INTR);
445
446
447 if (lp->jumpered) {
448 outb(0x80, ioaddr + IOCONFIG1);
449 }
450
451 netif_start_queue(dev);
452 return 0;
453}
454
455static void net_tx_timeout (struct net_device *dev)
456{
457 struct net_local *lp = netdev_priv(dev);
458 int ioaddr = dev->base_addr;
459
460 printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
461 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
462 ? "IRQ conflict" : "network cable problem");
463 printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
464 dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
465 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
466 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
467 dev->stats.tx_errors++;
468
469 outw(0xffff, ioaddr + MODE24);
470 outw (0xffff, ioaddr + TX_STATUS);
471 outb (0x5a, ioaddr + CONFIG_0);
472 outb (0xe8, ioaddr + CONFIG_1);
473 outw (0x8182, ioaddr + TX_INTR);
474 outb (0x00, ioaddr + TX_START);
475 outb (0x03, ioaddr + COL16CNTL);
476
477 dev->trans_start = jiffies;
478
479 lp->tx_started = 0;
480 lp->tx_queue_ready = 1;
481 lp->rx_started = 0;
482 lp->tx_queue = 0;
483 lp->tx_queue_len = 0;
484
485 netif_wake_queue(dev);
486}
487
488
489static netdev_tx_t net_send_packet (struct sk_buff *skb,
490 struct net_device *dev)
491{
492 struct net_local *lp = netdev_priv(dev);
493 int ioaddr = dev->base_addr;
494 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
495 short len = skb->len;
496 unsigned char *buf = skb->data;
497 static u8 pad[ETH_ZLEN];
498
499 netif_stop_queue (dev);
500
501
502
503
504
505
506 lp->tx_queue_ready = 0;
507 {
508 outw (length, ioaddr + DATAPORT);
509
510 outsw (ioaddr + DATAPORT, buf, len >> 1);
511
512 if (len & 1) {
513 outw(skb->data[skb->len-1], ioaddr + DATAPORT);
514 len++;
515 }
516
517 if (length != skb->len)
518 outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
519
520 lp->tx_queue++;
521 lp->tx_queue_len += length + 2;
522 }
523 lp->tx_queue_ready = 1;
524
525 if (lp->tx_started == 0) {
526
527 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
528 lp->tx_queue = 0;
529 lp->tx_queue_len = 0;
530 lp->tx_started = 1;
531 netif_start_queue (dev);
532 } else if (lp->tx_queue_len < 4096 - 1502)
533
534 netif_start_queue (dev);
535 dev_kfree_skb (skb);
536
537 return NETDEV_TX_OK;
538}
539
540
541
542static irqreturn_t net_interrupt(int irq, void *dev_id)
543{
544 struct net_device *dev = dev_id;
545 struct net_local *lp;
546 int ioaddr, status;
547 int handled = 0;
548
549 if (dev == NULL) {
550 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
551 return IRQ_NONE;
552 }
553
554 ioaddr = dev->base_addr;
555 lp = netdev_priv(dev);
556
557 spin_lock (&lp->lock);
558
559 status = inw(ioaddr + TX_STATUS);
560 outw(status, ioaddr + TX_STATUS);
561
562 if (net_debug > 4)
563 printk("%s: Interrupt with status %04x.\n", dev->name, status);
564 if (lp->rx_started == 0 &&
565 (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
566
567
568
569
570
571
572 handled = 1;
573 lp->rx_started = 1;
574 outb(0x00, ioaddr + RX_INTR);
575 net_rx(dev);
576 outb(0x81, ioaddr + RX_INTR);
577 lp->rx_started = 0;
578 }
579 if (status & 0x00ff) {
580 handled = 1;
581 if (status & 0x02) {
582
583 if (net_debug > 4)
584 printk("%s: 16 Collision occur during Txing.\n", dev->name);
585
586 outb(0x03, ioaddr + COL16CNTL);
587 dev->stats.collisions++;
588 }
589 if (status & 0x82) {
590 dev->stats.tx_packets++;
591
592
593
594 if (lp->tx_queue && lp->tx_queue_ready) {
595 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
596 lp->tx_queue = 0;
597 lp->tx_queue_len = 0;
598 dev->trans_start = jiffies;
599 netif_wake_queue (dev);
600 } else {
601 lp->tx_started = 0;
602 netif_wake_queue (dev);
603 }
604 }
605 }
606
607 spin_unlock (&lp->lock);
608 return IRQ_RETVAL(handled);
609}
610
611
612static void
613net_rx(struct net_device *dev)
614{
615 int ioaddr = dev->base_addr;
616 int boguscount = 5;
617
618 while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
619 ushort status = inw(ioaddr + DATAPORT);
620 ushort pkt_len = inw(ioaddr + DATAPORT);
621
622 if (net_debug > 4)
623 printk("%s: Rxing packet mode %02x status %04x.\n",
624 dev->name, inb(ioaddr + RX_MODE), status);
625#ifndef final_version
626 if (status == 0) {
627 outb(0x05, ioaddr + RX_CTRL);
628 break;
629 }
630#endif
631
632 if ((status & 0xF0) != 0x20) {
633 dev->stats.rx_errors++;
634 if (status & 0x08) dev->stats.rx_length_errors++;
635 if (status & 0x04) dev->stats.rx_frame_errors++;
636 if (status & 0x02) dev->stats.rx_crc_errors++;
637 if (status & 0x01) dev->stats.rx_over_errors++;
638 } else {
639
640 struct sk_buff *skb;
641
642 if (pkt_len > 1550) {
643 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
644 dev->name, pkt_len);
645
646 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
647 outb(0x05, ioaddr + RX_CTRL);
648 dev->stats.rx_errors++;
649 break;
650 }
651 skb = netdev_alloc_skb(dev, pkt_len + 3);
652 if (skb == NULL) {
653 printk("%s: Memory squeeze, dropping packet (len %d).\n",
654 dev->name, pkt_len);
655
656 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
657 outb(0x05, ioaddr + RX_CTRL);
658 dev->stats.rx_dropped++;
659 break;
660 }
661 skb_reserve(skb,2);
662
663 insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
664 skb->protocol=eth_type_trans(skb, dev);
665 netif_rx(skb);
666 dev->stats.rx_packets++;
667 dev->stats.rx_bytes += pkt_len;
668 }
669 if (--boguscount <= 0)
670 break;
671 }
672
673
674
675
676 {
677 int i;
678 for (i = 0; i < 20; i++) {
679 if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
680 break;
681 inw(ioaddr + DATAPORT);
682 outb(0x05, ioaddr + RX_CTRL);
683 }
684
685 if (net_debug > 5)
686 printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
687 dev->name, inb(ioaddr + RX_MODE), i);
688 }
689}
690
691
692static int net_close(struct net_device *dev)
693{
694 struct net_local *lp = netdev_priv(dev);
695 int ioaddr = dev->base_addr;
696
697 netif_stop_queue(dev);
698
699
700 outb(0xda, ioaddr + CONFIG_0);
701
702
703
704
705 if (lp->jumpered)
706 outb(0x00, ioaddr + IOCONFIG1);
707
708
709 outb(0x00, ioaddr + CONFIG_1);
710 return 0;
711}
712
713
714
715
716
717static void
718set_rx_mode(struct net_device *dev)
719{
720 int ioaddr = dev->base_addr;
721 struct net_local *lp = netdev_priv(dev);
722 unsigned char mc_filter[8];
723 unsigned long flags;
724
725 if (dev->flags & IFF_PROMISC) {
726 memset(mc_filter, 0xff, sizeof(mc_filter));
727 outb(3, ioaddr + RX_MODE);
728 } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
729 (dev->flags & IFF_ALLMULTI)) {
730
731 memset(mc_filter, 0xff, sizeof(mc_filter));
732 outb(2, ioaddr + RX_MODE);
733 } else if (netdev_mc_empty(dev)) {
734 memset(mc_filter, 0x00, sizeof(mc_filter));
735 outb(1, ioaddr + RX_MODE);
736 } else {
737 struct netdev_hw_addr *ha;
738
739 memset(mc_filter, 0, sizeof(mc_filter));
740 netdev_for_each_mc_addr(ha, dev) {
741 unsigned int bit =
742 ether_crc_le(ETH_ALEN, ha->addr) >> 26;
743 mc_filter[bit >> 3] |= (1 << bit);
744 }
745 outb(0x02, ioaddr + RX_MODE);
746 }
747
748 spin_lock_irqsave (&lp->lock, flags);
749 if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
750 int i;
751 int saved_bank = inw(ioaddr + CONFIG_0);
752
753 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
754 for (i = 0; i < 8; i++)
755 outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
756 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
757 outw(saved_bank, ioaddr + CONFIG_0);
758 }
759 spin_unlock_irqrestore (&lp->lock, flags);
760}
761
762#ifdef MODULE
763static struct net_device *dev_at1700;
764
765module_param(io, int, 0);
766module_param(irq, int, 0);
767module_param(net_debug, int, 0);
768MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
769MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
770MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
771
772static int __init at1700_module_init(void)
773{
774 if (io == 0)
775 printk("at1700: You should not use auto-probing with insmod!\n");
776 dev_at1700 = at1700_probe(-1);
777 if (IS_ERR(dev_at1700))
778 return PTR_ERR(dev_at1700);
779 return 0;
780}
781
782static void __exit at1700_module_exit(void)
783{
784 unregister_netdev(dev_at1700);
785 cleanup_card(dev_at1700);
786 free_netdev(dev_at1700);
787}
788module_init(at1700_module_init);
789module_exit(at1700_module_exit);
790#endif
791MODULE_LICENSE("GPL");
792