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