netdev: remove pathetic compile-command lines
[linux-2.6.git] / drivers / net / at1700.c
1 /* at1700.c: A network device driver for  the Allied Telesis AT1700.
2
3         Written 1993-98 by Donald Becker.
4
5         Copyright 1993 United States Government as represented by the
6         Director, National Security Agency.
7
8         This software may be used and distributed according to the terms
9         of the GNU General Public License, incorporated herein by reference.
10
11         The author may be reached as becker@scyld.com, or C/O
12         Scyld Computing Corporation
13         410 Severn Ave., Suite 210
14         Annapolis MD 21403
15
16         This is a device driver for the Allied Telesis AT1700, and
17         Fujitsu FMV-181/182/181A/182A/183/184/183A/184A, which are
18         straight-forward Fujitsu MB86965 implementations.
19
20         Modification for Fujitsu FMV-18X cards is done by Yutaka Tamiya
21         (tamy@flab.fujitsu.co.jp).
22
23   Sources:
24     The Fujitsu MB86965 datasheet.
25
26         After the initial version of this driver was written Gerry Sawkins of
27         ATI provided their EEPROM configuration code header file.
28     Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes.
29
30     MCA bus (AT1720) support by Rene Schmit <rene@bss.lu>
31
32   Bugs:
33         The MB86965 has a design flaw that makes all probes unreliable.  Not
34         only is it difficult to detect, it also moves around in I/O space in
35         response to inb()s from other device probes!
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
60 static 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 /* Tunable parameters. */
66
67 /* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
68 #define MC_FILTERBREAK 64
69
70 /* These unusual address orders are used to verify the CONFIG register. */
71
72 static int fmv18x_probe_list[] __initdata = {
73         0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
74 };
75
76 /*
77  *      ISA
78  */
79
80 static unsigned at1700_probe_list[] __initdata = {
81         0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
82 };
83
84 /*
85  *      MCA
86  */
87 #ifdef CONFIG_MCA_LEGACY
88 static int at1700_ioaddr_pattern[] __initdata = {
89         0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
90 };
91
92 static int at1700_mca_probe_list[] __initdata = {
93         0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
94 };
95
96 static 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 /* use 0 for production, 1 for verification, >2 for debug */
103 #ifndef NET_DEBUG
104 #define NET_DEBUG 1
105 #endif
106 static unsigned int net_debug = NET_DEBUG;
107
108 typedef unsigned char uchar;
109
110 /* Information that need to be kept for each board. */
111 struct net_local {
112         spinlock_t lock;
113         unsigned char mc_filter[8];
114         uint jumpered:1;                        /* Set iff the board has jumper config. */
115         uint tx_started:1;                      /* Packets are on the Tx queue. */
116         uint tx_queue_ready:1;                  /* Tx queue is ready to be sent. */
117         uint rx_started:1;                      /* Packets are Rxing. */
118         uchar tx_queue;                         /* Number of packet on the Tx queue. */
119         char mca_slot;                          /* -1 means ISA */
120         ushort tx_queue_len;                    /* Current length of the Tx queue. */
121 };
122
123
124 /* Offsets from the base address. */
125 #define STATUS                  0
126 #define TX_STATUS               0
127 #define RX_STATUS               1
128 #define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
129 #define RX_INTR                 3
130 #define TX_MODE                 4
131 #define RX_MODE                 5
132 #define CONFIG_0                6               /* Misc. configuration settings. */
133 #define CONFIG_1                7
134 /* Run-time register bank 2 definitions. */
135 #define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
136 #define TX_START                10
137 #define COL16CNTL               11              /* Controll Reg for 16 collisions */
138 #define MODE13                  13
139 #define RX_CTRL                 14
140 /* Configuration registers only on the '865A/B chips. */
141 #define EEPROM_Ctrl     16
142 #define EEPROM_Data     17
143 #define CARDSTATUS      16                      /* FMV-18x Card Status */
144 #define CARDSTATUS1     17                      /* FMV-18x Card Status */
145 #define IOCONFIG                18              /* Either read the jumper, or move the I/O. */
146 #define IOCONFIG1               19
147 #define SAPROM                  20              /* The station address PROM, if no EEPROM. */
148 #define MODE24                  24
149 #define RESET                   31              /* Write to reset some parts of the chip. */
150 #define AT1700_IO_EXTENT        32
151 #define PORT_OFFSET(o) (o)
152
153
154 #define TX_TIMEOUT              10
155
156
157 /* Index to functions, as function prototypes. */
158
159 static int at1700_probe1(struct net_device *dev, int ioaddr);
160 static int read_eeprom(long ioaddr, int location);
161 static int net_open(struct net_device *dev);
162 static int      net_send_packet(struct sk_buff *skb, struct net_device *dev);
163 static irqreturn_t net_interrupt(int irq, void *dev_id);
164 static void net_rx(struct net_device *dev);
165 static int net_close(struct net_device *dev);
166 static void set_rx_mode(struct net_device *dev);
167 static void net_tx_timeout (struct net_device *dev);
168
169
170 #ifdef CONFIG_MCA_LEGACY
171 struct at1720_mca_adapters_struct {
172         char* name;
173         int id;
174 };
175 /* rEnE : maybe there are others I don't know off... */
176
177 static struct at1720_mca_adapters_struct at1720_mca_adapters[] __initdata = {
178         { "Allied Telesys AT1720AT",    0x6410 },
179         { "Allied Telesys AT1720BT",    0x6413 },
180         { "Allied Telesys AT1720T",     0x6416 },
181         { NULL, 0 },
182 };
183 #endif
184
185 /* Check for a network adaptor of this type, and return '0' iff one exists.
186    If dev->base_addr == 0, probe all likely locations.
187    If dev->base_addr == 1, always return failure.
188    If dev->base_addr == 2, allocate space for the device and return success
189    (detachable devices only).
190    */
191
192 static int io = 0x260;
193
194 static int irq;
195
196 static void cleanup_card(struct net_device *dev)
197 {
198 #ifdef CONFIG_MCA_LEGACY
199         struct net_local *lp = netdev_priv(dev);
200         if (lp->mca_slot >= 0)
201                 mca_mark_as_unused(lp->mca_slot);
202 #endif
203         free_irq(dev->irq, NULL);
204         release_region(dev->base_addr, AT1700_IO_EXTENT);
205 }
206
207 struct net_device * __init at1700_probe(int unit)
208 {
209         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
210         unsigned *port;
211         int err = 0;
212
213         if (!dev)
214                 return ERR_PTR(-ENODEV);
215
216         if (unit >= 0) {
217                 sprintf(dev->name, "eth%d", unit);
218                 netdev_boot_setup_check(dev);
219                 io = dev->base_addr;
220                 irq = dev->irq;
221         } else {
222                 dev->base_addr = io;
223                 dev->irq = irq;
224         }
225
226         if (io > 0x1ff) {       /* Check a single specified location. */
227                 err = at1700_probe1(dev, io);
228         } else if (io != 0) {   /* Don't probe at all. */
229                 err = -ENXIO;
230         } else {
231                 for (port = at1700_probe_list; *port; port++) {
232                         if (at1700_probe1(dev, *port) == 0)
233                                 break;
234                         dev->irq = irq;
235                 }
236                 if (!*port)
237                         err = -ENODEV;
238         }
239         if (err)
240                 goto out;
241         err = register_netdev(dev);
242         if (err)
243                 goto out1;
244         return dev;
245 out1:
246         cleanup_card(dev);
247 out:
248         free_netdev(dev);
249         return ERR_PTR(err);
250 }
251
252 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
253    "signature", the default bit pattern after a reset.  This *doesn't* work --
254    there is no way to reset the bus interface without a complete power-cycle!
255
256    It turns out that ATI came to the same conclusion I did: the only thing
257    that can be done is checking a few bits and then diving right into an
258    EEPROM read. */
259
260 static int __init at1700_probe1(struct net_device *dev, int ioaddr)
261 {
262         char fmv_irqmap[4] = {3, 7, 10, 15};
263         char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
264         char at1700_irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
265         unsigned int i, irq, is_fmv18x = 0, is_at1700 = 0;
266         int slot, ret = -ENODEV;
267         struct net_local *lp = netdev_priv(dev);
268
269         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
270                 return -EBUSY;
271
272         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
273            That means we have to be careful with the register values we probe
274            for.
275          */
276 #ifdef notdef
277         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
278                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
279                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
280 #endif
281
282 #ifdef CONFIG_MCA_LEGACY
283         /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
284
285     /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
286         modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
287         to support standard MCA probing. */
288
289         /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
290         /* now works as a module */
291
292         if (MCA_bus) {
293                 int j;
294                 int l_i;
295                 u_char pos3, pos4;
296
297                 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
298                         slot = 0;
299                         while (slot != MCA_NOTFOUND) {
300
301                                 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
302                                 if (slot == MCA_NOTFOUND) break;
303
304                                 /* if we get this far, an adapter has been detected and is
305                                 enabled */
306
307                                 pos3 = mca_read_stored_pos( slot, 3 );
308                                 pos4 = mca_read_stored_pos( slot, 4 );
309
310                                 for (l_i = 0; l_i < 0x09; l_i++)
311                                         if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
312                                                 break;
313                                 ioaddr = at1700_mca_probe_list[l_i];
314
315                                 for (irq = 0; irq < 0x10; irq++)
316                                         if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
317                                                 break;
318
319                                         /* probing for a card at a particular IO/IRQ */
320                                 if ((dev->irq && dev->irq != irq) ||
321                                     (dev->base_addr && dev->base_addr != ioaddr)) {
322                                         slot++;         /* probing next slot */
323                                         continue;
324                                 }
325
326                                 dev->irq = irq;
327
328                                 /* claim the slot */
329                                 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
330                                 mca_mark_as_used(slot);
331
332                                 goto found;
333                         }
334                 }
335                 /* if we get here, we didn't find an MCA adapter - try ISA */
336         }
337 #endif
338         slot = -1;
339         /* We must check for the EEPROM-config boards first, else accessing
340            IOCONFIG0 will move the board! */
341         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
342                 && read_eeprom(ioaddr, 4) == 0x0000
343                 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
344                 is_at1700 = 1;
345         else if (inb(ioaddr   + SAPROM    ) == 0x00
346                 && inb(ioaddr + SAPROM + 1) == 0x00
347                 && inb(ioaddr + SAPROM + 2) == 0x0e)
348                 is_fmv18x = 1;
349         else {
350                 goto err_out;
351         }
352
353 #ifdef CONFIG_MCA_LEGACY
354 found:
355 #endif
356
357                 /* Reset the internal state machines. */
358         outb(0, ioaddr + RESET);
359
360         if (is_at1700) {
361                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
362                                                    | (read_eeprom(ioaddr, 0)>>14)];
363         } else {
364                 /* Check PnP mode for FMV-183/184/183A/184A. */
365                 /* This PnP routine is very poor. IO and IRQ should be known. */
366                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
367                         irq = dev->irq;
368                         for (i = 0; i < 8; i++) {
369                                 if (irq == fmv_irqmap_pnp[i])
370                                         break;
371                         }
372                         if (i == 8) {
373                                 goto err_mca;
374                         }
375                 } else {
376                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
377                                 goto err_mca;
378                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
379                 }
380         }
381
382         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
383                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
384
385         dev->base_addr = ioaddr;
386         dev->irq = irq;
387
388         if (is_at1700) {
389                 for(i = 0; i < 3; i++) {
390                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
391                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
392                 }
393         } else {
394                 for(i = 0; i < 6; i++) {
395                         unsigned char val = inb(ioaddr + SAPROM + i);
396                         dev->dev_addr[i] = val;
397                 }
398         }
399         printk("%pM", dev->dev_addr);
400
401         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
402            rather than 150 ohm shielded twisted pair compensation.
403            0x0000 == auto-sense the interface
404            0x0800 == use TP interface
405            0x1800 == use coax interface
406            */
407         {
408                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
409                 if (is_at1700) {
410                         ushort setup_value = read_eeprom(ioaddr, 12);
411                         dev->if_port = setup_value >> 8;
412                 } else {
413                         ushort setup_value = inb(ioaddr + CARDSTATUS);
414                         switch (setup_value & 0x07) {
415                         case 0x01: /* 10base5 */
416                         case 0x02: /* 10base2 */
417                                 dev->if_port = 0x18; break;
418                         case 0x04: /* 10baseT */
419                                 dev->if_port = 0x08; break;
420                         default:   /* auto-sense */
421                                 dev->if_port = 0x00; break;
422                         }
423                 }
424                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
425         }
426
427         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
428            bus access, two 4K Tx queues, and disabled Tx and Rx. */
429         outb(0xda, ioaddr + CONFIG_0);
430
431         /* Set the station address in bank zero. */
432         outb(0x00, ioaddr + CONFIG_1);
433         for (i = 0; i < 6; i++)
434                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
435
436         /* Switch to bank 1 and set the multicast table to accept none. */
437         outb(0x04, ioaddr + CONFIG_1);
438         for (i = 0; i < 8; i++)
439                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
440
441
442         /* Switch to bank 2 */
443         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
444         outb(0x08, ioaddr + CONFIG_1);
445         outb(dev->if_port, ioaddr + MODE13);
446         outb(0x00, ioaddr + COL16CNTL);
447
448         if (net_debug)
449                 printk(version);
450
451         memset(lp, 0, sizeof(struct net_local));
452
453         dev->open               = net_open;
454         dev->stop               = net_close;
455         dev->hard_start_xmit = net_send_packet;
456         dev->set_multicast_list = &set_rx_mode;
457         dev->tx_timeout = net_tx_timeout;
458         dev->watchdog_timeo = TX_TIMEOUT;
459
460         spin_lock_init(&lp->lock);
461
462         lp->jumpered = is_fmv18x;
463         lp->mca_slot = slot;
464         /* Snarf the interrupt vector now. */
465         ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
466         if (ret) {
467                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
468                        "conflict on IRQ %d.\n",
469                        ioaddr, irq);
470                 goto err_mca;
471         }
472
473         return 0;
474
475 err_mca:
476 #ifdef CONFIG_MCA_LEGACY
477         if (slot >= 0)
478                 mca_mark_as_unused(slot);
479 #endif
480 err_out:
481         release_region(ioaddr, AT1700_IO_EXTENT);
482         return ret;
483 }
484
485
486 /*  EEPROM_Ctrl bits. */
487 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
488 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
489 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
490 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
491
492 /* The EEPROM commands include the alway-set leading bit. */
493 #define EE_WRITE_CMD    (5 << 6)
494 #define EE_READ_CMD             (6 << 6)
495 #define EE_ERASE_CMD    (7 << 6)
496
497 static int __init read_eeprom(long ioaddr, int location)
498 {
499         int i;
500         unsigned short retval = 0;
501         long ee_addr = ioaddr + EEPROM_Ctrl;
502         long ee_daddr = ioaddr + EEPROM_Data;
503         int read_cmd = location | EE_READ_CMD;
504
505         /* Shift the read command bits out. */
506         for (i = 9; i >= 0; i--) {
507                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
508                 outb(EE_CS, ee_addr);
509                 outb(dataval, ee_daddr);
510                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
511         }
512         outb(EE_DATA_WRITE, ee_daddr);
513         for (i = 16; i > 0; i--) {
514                 outb(EE_CS, ee_addr);
515                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
516                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
517         }
518
519         /* Terminate the EEPROM access. */
520         outb(EE_CS, ee_addr);
521         outb(EE_SHIFT_CLK, ee_addr);
522         outb(0, ee_addr);
523         return retval;
524 }
525
526
527
528 static int net_open(struct net_device *dev)
529 {
530         struct net_local *lp = netdev_priv(dev);
531         int ioaddr = dev->base_addr;
532
533         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
534            bus access, and two 4K Tx queues. */
535         outb(0x5a, ioaddr + CONFIG_0);
536
537         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
538         outb(0xe8, ioaddr + CONFIG_1);
539
540         lp->tx_started = 0;
541         lp->tx_queue_ready = 1;
542         lp->rx_started = 0;
543         lp->tx_queue = 0;
544         lp->tx_queue_len = 0;
545
546         /* Turn on hardware Tx and Rx interrupts. */
547         outb(0x82, ioaddr + TX_INTR);
548         outb(0x81, ioaddr + RX_INTR);
549
550         /* Enable the IRQ on boards of fmv18x it is feasible. */
551         if (lp->jumpered) {
552                 outb(0x80, ioaddr + IOCONFIG1);
553         }
554
555         netif_start_queue(dev);
556         return 0;
557 }
558
559 static void net_tx_timeout (struct net_device *dev)
560 {
561         struct net_local *lp = netdev_priv(dev);
562         int ioaddr = dev->base_addr;
563
564         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
565                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
566                 ? "IRQ conflict" : "network cable problem");
567         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
568          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
569                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
570                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
571         dev->stats.tx_errors++;
572         /* ToDo: We should try to restart the adaptor... */
573         outw(0xffff, ioaddr + MODE24);
574         outw (0xffff, ioaddr + TX_STATUS);
575         outb (0x5a, ioaddr + CONFIG_0);
576         outb (0xe8, ioaddr + CONFIG_1);
577         outw (0x8182, ioaddr + TX_INTR);
578         outb (0x00, ioaddr + TX_START);
579         outb (0x03, ioaddr + COL16CNTL);
580
581         dev->trans_start = jiffies;
582
583         lp->tx_started = 0;
584         lp->tx_queue_ready = 1;
585         lp->rx_started = 0;
586         lp->tx_queue = 0;
587         lp->tx_queue_len = 0;
588
589         netif_wake_queue(dev);
590 }
591
592
593 static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
594 {
595         struct net_local *lp = netdev_priv(dev);
596         int ioaddr = dev->base_addr;
597         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
598         short len = skb->len;
599         unsigned char *buf = skb->data;
600         static u8 pad[ETH_ZLEN];
601
602         netif_stop_queue (dev);
603
604         /* We may not start transmitting unless we finish transferring
605            a packet into the Tx queue. During executing the following
606            codes we possibly catch a Tx interrupt. Thus we flag off
607            tx_queue_ready, so that we prevent the interrupt routine
608            (net_interrupt) to start transmitting. */
609         lp->tx_queue_ready = 0;
610         {
611                 outw (length, ioaddr + DATAPORT);
612                 /* Packet data */
613                 outsw (ioaddr + DATAPORT, buf, len >> 1);
614                 /* Check for dribble byte */
615                 if (len & 1) {
616                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
617                         len++;
618                 }
619                 /* Check for packet padding */
620                 if (length != skb->len)
621                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
622
623                 lp->tx_queue++;
624                 lp->tx_queue_len += length + 2;
625         }
626         lp->tx_queue_ready = 1;
627
628         if (lp->tx_started == 0) {
629                 /* If the Tx is idle, always trigger a transmit. */
630                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
631                 lp->tx_queue = 0;
632                 lp->tx_queue_len = 0;
633                 dev->trans_start = jiffies;
634                 lp->tx_started = 1;
635                 netif_start_queue (dev);
636         } else if (lp->tx_queue_len < 4096 - 1502)
637                 /* Yes, there is room for one more packet. */
638                 netif_start_queue (dev);
639         dev_kfree_skb (skb);
640
641         return 0;
642 }
643
644 /* The typical workload of the driver:
645    Handle the network interface interrupts. */
646 static irqreturn_t net_interrupt(int irq, void *dev_id)
647 {
648         struct net_device *dev = dev_id;
649         struct net_local *lp;
650         int ioaddr, status;
651         int handled = 0;
652
653         if (dev == NULL) {
654                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
655                 return IRQ_NONE;
656         }
657
658         ioaddr = dev->base_addr;
659         lp = netdev_priv(dev);
660
661         spin_lock (&lp->lock);
662
663         status = inw(ioaddr + TX_STATUS);
664         outw(status, ioaddr + TX_STATUS);
665
666         if (net_debug > 4)
667                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
668         if (lp->rx_started == 0 &&
669             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
670                 /* Got a packet(s).
671                    We cannot execute net_rx more than once at the same time for
672                    the same device. During executing net_rx, we possibly catch a
673                    Tx interrupt. Thus we flag on rx_started, so that we prevent
674                    the interrupt routine (net_interrupt) to dive into net_rx
675                    again. */
676                 handled = 1;
677                 lp->rx_started = 1;
678                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
679                 net_rx(dev);
680                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
681                 lp->rx_started = 0;
682         }
683         if (status & 0x00ff) {
684                 handled = 1;
685                 if (status & 0x02) {
686                         /* More than 16 collisions occurred */
687                         if (net_debug > 4)
688                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
689                         /* Cancel sending a packet. */
690                         outb(0x03, ioaddr + COL16CNTL);
691                         dev->stats.collisions++;
692                 }
693                 if (status & 0x82) {
694                         dev->stats.tx_packets++;
695                         /* The Tx queue has any packets and is not being
696                            transferred a packet from the host, start
697                            transmitting. */
698                         if (lp->tx_queue && lp->tx_queue_ready) {
699                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
700                                 lp->tx_queue = 0;
701                                 lp->tx_queue_len = 0;
702                                 dev->trans_start = jiffies;
703                                 netif_wake_queue (dev);
704                         } else {
705                                 lp->tx_started = 0;
706                                 netif_wake_queue (dev);
707                         }
708                 }
709         }
710
711         spin_unlock (&lp->lock);
712         return IRQ_RETVAL(handled);
713 }
714
715 /* We have a good packet(s), get it/them out of the buffers. */
716 static void
717 net_rx(struct net_device *dev)
718 {
719         int ioaddr = dev->base_addr;
720         int boguscount = 5;
721
722         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
723                 ushort status = inw(ioaddr + DATAPORT);
724                 ushort pkt_len = inw(ioaddr + DATAPORT);
725
726                 if (net_debug > 4)
727                         printk("%s: Rxing packet mode %02x status %04x.\n",
728                                    dev->name, inb(ioaddr + RX_MODE), status);
729 #ifndef final_version
730                 if (status == 0) {
731                         outb(0x05, ioaddr + RX_CTRL);
732                         break;
733                 }
734 #endif
735
736                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
737                         dev->stats.rx_errors++;
738                         if (status & 0x08) dev->stats.rx_length_errors++;
739                         if (status & 0x04) dev->stats.rx_frame_errors++;
740                         if (status & 0x02) dev->stats.rx_crc_errors++;
741                         if (status & 0x01) dev->stats.rx_over_errors++;
742                 } else {
743                         /* Malloc up new buffer. */
744                         struct sk_buff *skb;
745
746                         if (pkt_len > 1550) {
747                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
748                                            dev->name, pkt_len);
749                                 /* Prime the FIFO and then flush the packet. */
750                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
751                                 outb(0x05, ioaddr + RX_CTRL);
752                                 dev->stats.rx_errors++;
753                                 break;
754                         }
755                         skb = dev_alloc_skb(pkt_len+3);
756                         if (skb == NULL) {
757                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
758                                            dev->name, pkt_len);
759                                 /* Prime the FIFO and then flush the packet. */
760                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
761                                 outb(0x05, ioaddr + RX_CTRL);
762                                 dev->stats.rx_dropped++;
763                                 break;
764                         }
765                         skb_reserve(skb,2);
766
767                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
768                         skb->protocol=eth_type_trans(skb, dev);
769                         netif_rx(skb);
770                         dev->stats.rx_packets++;
771                         dev->stats.rx_bytes += pkt_len;
772                 }
773                 if (--boguscount <= 0)
774                         break;
775         }
776
777         /* If any worth-while packets have been received, dev_rint()
778            has done a mark_bh(NET_BH) for us and will work on them
779            when we get to the bottom-half routine. */
780         {
781                 int i;
782                 for (i = 0; i < 20; i++) {
783                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
784                                 break;
785                         inw(ioaddr + DATAPORT);                         /* dummy status read */
786                         outb(0x05, ioaddr + RX_CTRL);
787                 }
788
789                 if (net_debug > 5)
790                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
791                                    dev->name, inb(ioaddr + RX_MODE), i);
792         }
793         return;
794 }
795
796 /* The inverse routine to net_open(). */
797 static int net_close(struct net_device *dev)
798 {
799         struct net_local *lp = netdev_priv(dev);
800         int ioaddr = dev->base_addr;
801
802         netif_stop_queue(dev);
803
804         /* Set configuration register 0 to disable Tx and Rx. */
805         outb(0xda, ioaddr + CONFIG_0);
806
807         /* No statistic counters on the chip to update. */
808
809         /* Disable the IRQ on boards of fmv18x where it is feasible. */
810         if (lp->jumpered) {
811                 outb(0x00, ioaddr + IOCONFIG1);
812                 free_irq(dev->irq, dev);
813         }
814
815         /* Power-down the chip.  Green, green, green! */
816         outb(0x00, ioaddr + CONFIG_1);
817         return 0;
818 }
819
820 /*
821   Set the multicast/promiscuous mode for this adaptor.
822 */
823
824 static void
825 set_rx_mode(struct net_device *dev)
826 {
827         int ioaddr = dev->base_addr;
828         struct net_local *lp = netdev_priv(dev);
829         unsigned char mc_filter[8];              /* Multicast hash filter */
830         unsigned long flags;
831         int i;
832
833         if (dev->flags & IFF_PROMISC) {
834                 memset(mc_filter, 0xff, sizeof(mc_filter));
835                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
836         } else if (dev->mc_count > MC_FILTERBREAK
837                            ||  (dev->flags & IFF_ALLMULTI)) {
838                 /* Too many to filter perfectly -- accept all multicasts. */
839                 memset(mc_filter, 0xff, sizeof(mc_filter));
840                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
841         } else if (dev->mc_count == 0) {
842                 memset(mc_filter, 0x00, sizeof(mc_filter));
843                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
844         } else {
845                 struct dev_mc_list *mclist;
846                 int i;
847
848                 memset(mc_filter, 0, sizeof(mc_filter));
849                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
850                          i++, mclist = mclist->next) {
851                         unsigned int bit =
852                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
853                         mc_filter[bit >> 3] |= (1 << bit);
854                 }
855                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
856         }
857
858         spin_lock_irqsave (&lp->lock, flags);
859         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
860                 int saved_bank = inw(ioaddr + CONFIG_0);
861                 /* Switch to bank 1 and set the multicast table. */
862                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
863                 for (i = 0; i < 8; i++)
864                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
865                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
866                 outw(saved_bank, ioaddr + CONFIG_0);
867         }
868         spin_unlock_irqrestore (&lp->lock, flags);
869         return;
870 }
871
872 #ifdef MODULE
873 static struct net_device *dev_at1700;
874
875 module_param(io, int, 0);
876 module_param(irq, int, 0);
877 module_param(net_debug, int, 0);
878 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
879 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
880 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
881
882 static int __init at1700_module_init(void)
883 {
884         if (io == 0)
885                 printk("at1700: You should not use auto-probing with insmod!\n");
886         dev_at1700 = at1700_probe(-1);
887         if (IS_ERR(dev_at1700))
888                 return PTR_ERR(dev_at1700);
889         return 0;
890 }
891
892 static void __exit at1700_module_exit(void)
893 {
894         unregister_netdev(dev_at1700);
895         cleanup_card(dev_at1700);
896         free_netdev(dev_at1700);
897 }
898 module_init(at1700_module_init);
899 module_exit(at1700_module_exit);
900 #endif /* MODULE */
901 MODULE_LICENSE("GPL");