ath9k: Fix TX control flag use for no ACK and RTS/CTS
[linux-2.6] / 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         DECLARE_MAC_BUF(mac);
269
270         if (!request_region(ioaddr, AT1700_IO_EXTENT, DRV_NAME))
271                 return -EBUSY;
272
273         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
274            That means we have to be careful with the register values we probe
275            for.
276          */
277 #ifdef notdef
278         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
279                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
280                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
281 #endif
282
283 #ifdef CONFIG_MCA_LEGACY
284         /* rEnE (rene@bss.lu): got this from 3c509 driver source , adapted for AT1720 */
285
286     /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
287         modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
288         to support standard MCA probing. */
289
290         /* redone for multi-card detection by ZP Gu (zpg@castle.net) */
291         /* now works as a module */
292
293         if (MCA_bus) {
294                 int j;
295                 int l_i;
296                 u_char pos3, pos4;
297
298                 for (j = 0; at1720_mca_adapters[j].name != NULL; j ++) {
299                         slot = 0;
300                         while (slot != MCA_NOTFOUND) {
301
302                                 slot = mca_find_unused_adapter( at1720_mca_adapters[j].id, slot );
303                                 if (slot == MCA_NOTFOUND) break;
304
305                                 /* if we get this far, an adapter has been detected and is
306                                 enabled */
307
308                                 pos3 = mca_read_stored_pos( slot, 3 );
309                                 pos4 = mca_read_stored_pos( slot, 4 );
310
311                                 for (l_i = 0; l_i < 0x09; l_i++)
312                                         if (( pos3 & 0x07) == at1700_ioaddr_pattern[l_i])
313                                                 break;
314                                 ioaddr = at1700_mca_probe_list[l_i];
315
316                                 for (irq = 0; irq < 0x10; irq++)
317                                         if (((((pos4>>4) & 0x0f) | (pos3 & 0xf0)) & 0xff) == at1700_irq_pattern[irq])
318                                                 break;
319
320                                         /* probing for a card at a particular IO/IRQ */
321                                 if ((dev->irq && dev->irq != irq) ||
322                                     (dev->base_addr && dev->base_addr != ioaddr)) {
323                                         slot++;         /* probing next slot */
324                                         continue;
325                                 }
326
327                                 dev->irq = irq;
328
329                                 /* claim the slot */
330                                 mca_set_adapter_name( slot, at1720_mca_adapters[j].name );
331                                 mca_mark_as_used(slot);
332
333                                 goto found;
334                         }
335                 }
336                 /* if we get here, we didn't find an MCA adapter - try ISA */
337         }
338 #endif
339         slot = -1;
340         /* We must check for the EEPROM-config boards first, else accessing
341            IOCONFIG0 will move the board! */
342         if (at1700_probe_list[inb(ioaddr + IOCONFIG1) & 0x07] == ioaddr
343                 && read_eeprom(ioaddr, 4) == 0x0000
344                 && (read_eeprom(ioaddr, 5) & 0xff00) == 0xF400)
345                 is_at1700 = 1;
346         else if (inb(ioaddr   + SAPROM    ) == 0x00
347                 && inb(ioaddr + SAPROM + 1) == 0x00
348                 && inb(ioaddr + SAPROM + 2) == 0x0e)
349                 is_fmv18x = 1;
350         else {
351                 goto err_out;
352         }
353
354 #ifdef CONFIG_MCA_LEGACY
355 found:
356 #endif
357
358                 /* Reset the internal state machines. */
359         outb(0, ioaddr + RESET);
360
361         if (is_at1700) {
362                 irq = at1700_irqmap[(read_eeprom(ioaddr, 12)&0x04)
363                                                    | (read_eeprom(ioaddr, 0)>>14)];
364         } else {
365                 /* Check PnP mode for FMV-183/184/183A/184A. */
366                 /* This PnP routine is very poor. IO and IRQ should be known. */
367                 if (inb(ioaddr + CARDSTATUS1) & 0x20) {
368                         irq = dev->irq;
369                         for (i = 0; i < 8; i++) {
370                                 if (irq == fmv_irqmap_pnp[i])
371                                         break;
372                         }
373                         if (i == 8) {
374                                 goto err_mca;
375                         }
376                 } else {
377                         if (fmv18x_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr)
378                                 goto err_mca;
379                         irq = fmv_irqmap[(inb(ioaddr + IOCONFIG)>>6) & 0x03];
380                 }
381         }
382
383         printk("%s: %s found at %#3x, IRQ %d, address ", dev->name,
384                    is_at1700 ? "AT1700" : "FMV-18X", ioaddr, irq);
385
386         dev->base_addr = ioaddr;
387         dev->irq = irq;
388
389         if (is_at1700) {
390                 for(i = 0; i < 3; i++) {
391                         unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
392                         ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
393                 }
394         } else {
395                 for(i = 0; i < 6; i++) {
396                         unsigned char val = inb(ioaddr + SAPROM + i);
397                         dev->dev_addr[i] = val;
398                 }
399         }
400         printk("%s", print_mac(mac, dev->dev_addr));
401
402         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
403            rather than 150 ohm shielded twisted pair compensation.
404            0x0000 == auto-sense the interface
405            0x0800 == use TP interface
406            0x1800 == use coax interface
407            */
408         {
409                 const char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
410                 if (is_at1700) {
411                         ushort setup_value = read_eeprom(ioaddr, 12);
412                         dev->if_port = setup_value >> 8;
413                 } else {
414                         ushort setup_value = inb(ioaddr + CARDSTATUS);
415                         switch (setup_value & 0x07) {
416                         case 0x01: /* 10base5 */
417                         case 0x02: /* 10base2 */
418                                 dev->if_port = 0x18; break;
419                         case 0x04: /* 10baseT */
420                                 dev->if_port = 0x08; break;
421                         default:   /* auto-sense */
422                                 dev->if_port = 0x00; break;
423                         }
424                 }
425                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
426         }
427
428         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
429            bus access, two 4K Tx queues, and disabled Tx and Rx. */
430         outb(0xda, ioaddr + CONFIG_0);
431
432         /* Set the station address in bank zero. */
433         outb(0x00, ioaddr + CONFIG_1);
434         for (i = 0; i < 6; i++)
435                 outb(dev->dev_addr[i], ioaddr + PORT_OFFSET(8 + i));
436
437         /* Switch to bank 1 and set the multicast table to accept none. */
438         outb(0x04, ioaddr + CONFIG_1);
439         for (i = 0; i < 8; i++)
440                 outb(0x00, ioaddr + PORT_OFFSET(8 + i));
441
442
443         /* Switch to bank 2 */
444         /* Lock our I/O address, and set manual processing mode for 16 collisions. */
445         outb(0x08, ioaddr + CONFIG_1);
446         outb(dev->if_port, ioaddr + MODE13);
447         outb(0x00, ioaddr + COL16CNTL);
448
449         if (net_debug)
450                 printk(version);
451
452         memset(lp, 0, sizeof(struct net_local));
453
454         dev->open               = net_open;
455         dev->stop               = net_close;
456         dev->hard_start_xmit = net_send_packet;
457         dev->set_multicast_list = &set_rx_mode;
458         dev->tx_timeout = net_tx_timeout;
459         dev->watchdog_timeo = TX_TIMEOUT;
460
461         spin_lock_init(&lp->lock);
462
463         lp->jumpered = is_fmv18x;
464         lp->mca_slot = slot;
465         /* Snarf the interrupt vector now. */
466         ret = request_irq(irq, &net_interrupt, 0, DRV_NAME, dev);
467         if (ret) {
468                 printk(KERN_ERR "AT1700 at %#3x is unusable due to a "
469                        "conflict on IRQ %d.\n",
470                        ioaddr, irq);
471                 goto err_mca;
472         }
473
474         return 0;
475
476 err_mca:
477 #ifdef CONFIG_MCA_LEGACY
478         if (slot >= 0)
479                 mca_mark_as_unused(slot);
480 #endif
481 err_out:
482         release_region(ioaddr, AT1700_IO_EXTENT);
483         return ret;
484 }
485
486
487 /*  EEPROM_Ctrl bits. */
488 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
489 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
490 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
491 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
492
493 /* The EEPROM commands include the alway-set leading bit. */
494 #define EE_WRITE_CMD    (5 << 6)
495 #define EE_READ_CMD             (6 << 6)
496 #define EE_ERASE_CMD    (7 << 6)
497
498 static int __init read_eeprom(long ioaddr, int location)
499 {
500         int i;
501         unsigned short retval = 0;
502         long ee_addr = ioaddr + EEPROM_Ctrl;
503         long ee_daddr = ioaddr + EEPROM_Data;
504         int read_cmd = location | EE_READ_CMD;
505
506         /* Shift the read command bits out. */
507         for (i = 9; i >= 0; i--) {
508                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
509                 outb(EE_CS, ee_addr);
510                 outb(dataval, ee_daddr);
511                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
512         }
513         outb(EE_DATA_WRITE, ee_daddr);
514         for (i = 16; i > 0; i--) {
515                 outb(EE_CS, ee_addr);
516                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
517                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
518         }
519
520         /* Terminate the EEPROM access. */
521         outb(EE_CS, ee_addr);
522         outb(EE_SHIFT_CLK, ee_addr);
523         outb(0, ee_addr);
524         return retval;
525 }
526
527
528
529 static int net_open(struct net_device *dev)
530 {
531         struct net_local *lp = netdev_priv(dev);
532         int ioaddr = dev->base_addr;
533
534         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
535            bus access, and two 4K Tx queues. */
536         outb(0x5a, ioaddr + CONFIG_0);
537
538         /* Powerup, switch to register bank 2, and enable the Rx and Tx. */
539         outb(0xe8, ioaddr + CONFIG_1);
540
541         lp->tx_started = 0;
542         lp->tx_queue_ready = 1;
543         lp->rx_started = 0;
544         lp->tx_queue = 0;
545         lp->tx_queue_len = 0;
546
547         /* Turn on hardware Tx and Rx interrupts. */
548         outb(0x82, ioaddr + TX_INTR);
549         outb(0x81, ioaddr + RX_INTR);
550
551         /* Enable the IRQ on boards of fmv18x it is feasible. */
552         if (lp->jumpered) {
553                 outb(0x80, ioaddr + IOCONFIG1);
554         }
555
556         netif_start_queue(dev);
557         return 0;
558 }
559
560 static void net_tx_timeout (struct net_device *dev)
561 {
562         struct net_local *lp = netdev_priv(dev);
563         int ioaddr = dev->base_addr;
564
565         printk ("%s: transmit timed out with status %04x, %s?\n", dev->name,
566                 inw (ioaddr + STATUS), inb (ioaddr + TX_STATUS) & 0x80
567                 ? "IRQ conflict" : "network cable problem");
568         printk ("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
569          dev->name, inw(ioaddr + TX_STATUS), inw(ioaddr + TX_INTR), inw(ioaddr + TX_MODE),
570                 inw(ioaddr + CONFIG_0), inw(ioaddr + DATAPORT), inw(ioaddr + TX_START),
571                 inw(ioaddr + MODE13 - 1), inw(ioaddr + RX_CTRL));
572         dev->stats.tx_errors++;
573         /* ToDo: We should try to restart the adaptor... */
574         outw(0xffff, ioaddr + MODE24);
575         outw (0xffff, ioaddr + TX_STATUS);
576         outb (0x5a, ioaddr + CONFIG_0);
577         outb (0xe8, ioaddr + CONFIG_1);
578         outw (0x8182, ioaddr + TX_INTR);
579         outb (0x00, ioaddr + TX_START);
580         outb (0x03, ioaddr + COL16CNTL);
581
582         dev->trans_start = jiffies;
583
584         lp->tx_started = 0;
585         lp->tx_queue_ready = 1;
586         lp->rx_started = 0;
587         lp->tx_queue = 0;
588         lp->tx_queue_len = 0;
589
590         netif_wake_queue(dev);
591 }
592
593
594 static int net_send_packet (struct sk_buff *skb, struct net_device *dev)
595 {
596         struct net_local *lp = netdev_priv(dev);
597         int ioaddr = dev->base_addr;
598         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
599         short len = skb->len;
600         unsigned char *buf = skb->data;
601         static u8 pad[ETH_ZLEN];
602
603         netif_stop_queue (dev);
604
605         /* We may not start transmitting unless we finish transferring
606            a packet into the Tx queue. During executing the following
607            codes we possibly catch a Tx interrupt. Thus we flag off
608            tx_queue_ready, so that we prevent the interrupt routine
609            (net_interrupt) to start transmitting. */
610         lp->tx_queue_ready = 0;
611         {
612                 outw (length, ioaddr + DATAPORT);
613                 /* Packet data */
614                 outsw (ioaddr + DATAPORT, buf, len >> 1);
615                 /* Check for dribble byte */
616                 if (len & 1) {
617                         outw(skb->data[skb->len-1], ioaddr + DATAPORT);
618                         len++;
619                 }
620                 /* Check for packet padding */
621                 if (length != skb->len)
622                         outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
623
624                 lp->tx_queue++;
625                 lp->tx_queue_len += length + 2;
626         }
627         lp->tx_queue_ready = 1;
628
629         if (lp->tx_started == 0) {
630                 /* If the Tx is idle, always trigger a transmit. */
631                 outb (0x80 | lp->tx_queue, ioaddr + TX_START);
632                 lp->tx_queue = 0;
633                 lp->tx_queue_len = 0;
634                 dev->trans_start = jiffies;
635                 lp->tx_started = 1;
636                 netif_start_queue (dev);
637         } else if (lp->tx_queue_len < 4096 - 1502)
638                 /* Yes, there is room for one more packet. */
639                 netif_start_queue (dev);
640         dev_kfree_skb (skb);
641
642         return 0;
643 }
644
645 /* The typical workload of the driver:
646    Handle the network interface interrupts. */
647 static irqreturn_t net_interrupt(int irq, void *dev_id)
648 {
649         struct net_device *dev = dev_id;
650         struct net_local *lp;
651         int ioaddr, status;
652         int handled = 0;
653
654         if (dev == NULL) {
655                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
656                 return IRQ_NONE;
657         }
658
659         ioaddr = dev->base_addr;
660         lp = netdev_priv(dev);
661
662         spin_lock (&lp->lock);
663
664         status = inw(ioaddr + TX_STATUS);
665         outw(status, ioaddr + TX_STATUS);
666
667         if (net_debug > 4)
668                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
669         if (lp->rx_started == 0 &&
670             (status & 0xff00 || (inb(ioaddr + RX_MODE) & 0x40) == 0)) {
671                 /* Got a packet(s).
672                    We cannot execute net_rx more than once at the same time for
673                    the same device. During executing net_rx, we possibly catch a
674                    Tx interrupt. Thus we flag on rx_started, so that we prevent
675                    the interrupt routine (net_interrupt) to dive into net_rx
676                    again. */
677                 handled = 1;
678                 lp->rx_started = 1;
679                 outb(0x00, ioaddr + RX_INTR);   /* Disable RX intr. */
680                 net_rx(dev);
681                 outb(0x81, ioaddr + RX_INTR);   /* Enable  RX intr. */
682                 lp->rx_started = 0;
683         }
684         if (status & 0x00ff) {
685                 handled = 1;
686                 if (status & 0x02) {
687                         /* More than 16 collisions occurred */
688                         if (net_debug > 4)
689                                 printk("%s: 16 Collision occur during Txing.\n", dev->name);
690                         /* Cancel sending a packet. */
691                         outb(0x03, ioaddr + COL16CNTL);
692                         dev->stats.collisions++;
693                 }
694                 if (status & 0x82) {
695                         dev->stats.tx_packets++;
696                         /* The Tx queue has any packets and is not being
697                            transferred a packet from the host, start
698                            transmitting. */
699                         if (lp->tx_queue && lp->tx_queue_ready) {
700                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
701                                 lp->tx_queue = 0;
702                                 lp->tx_queue_len = 0;
703                                 dev->trans_start = jiffies;
704                                 netif_wake_queue (dev);
705                         } else {
706                                 lp->tx_started = 0;
707                                 netif_wake_queue (dev);
708                         }
709                 }
710         }
711
712         spin_unlock (&lp->lock);
713         return IRQ_RETVAL(handled);
714 }
715
716 /* We have a good packet(s), get it/them out of the buffers. */
717 static void
718 net_rx(struct net_device *dev)
719 {
720         int ioaddr = dev->base_addr;
721         int boguscount = 5;
722
723         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
724                 ushort status = inw(ioaddr + DATAPORT);
725                 ushort pkt_len = inw(ioaddr + DATAPORT);
726
727                 if (net_debug > 4)
728                         printk("%s: Rxing packet mode %02x status %04x.\n",
729                                    dev->name, inb(ioaddr + RX_MODE), status);
730 #ifndef final_version
731                 if (status == 0) {
732                         outb(0x05, ioaddr + RX_CTRL);
733                         break;
734                 }
735 #endif
736
737                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
738                         dev->stats.rx_errors++;
739                         if (status & 0x08) dev->stats.rx_length_errors++;
740                         if (status & 0x04) dev->stats.rx_frame_errors++;
741                         if (status & 0x02) dev->stats.rx_crc_errors++;
742                         if (status & 0x01) dev->stats.rx_over_errors++;
743                 } else {
744                         /* Malloc up new buffer. */
745                         struct sk_buff *skb;
746
747                         if (pkt_len > 1550) {
748                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
749                                            dev->name, pkt_len);
750                                 /* Prime the FIFO and then flush the packet. */
751                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
752                                 outb(0x05, ioaddr + RX_CTRL);
753                                 dev->stats.rx_errors++;
754                                 break;
755                         }
756                         skb = dev_alloc_skb(pkt_len+3);
757                         if (skb == NULL) {
758                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
759                                            dev->name, pkt_len);
760                                 /* Prime the FIFO and then flush the packet. */
761                                 inw(ioaddr + DATAPORT); inw(ioaddr + DATAPORT);
762                                 outb(0x05, ioaddr + RX_CTRL);
763                                 dev->stats.rx_dropped++;
764                                 break;
765                         }
766                         skb_reserve(skb,2);
767
768                         insw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
769                         skb->protocol=eth_type_trans(skb, dev);
770                         netif_rx(skb);
771                         dev->last_rx = jiffies;
772                         dev->stats.rx_packets++;
773                         dev->stats.rx_bytes += pkt_len;
774                 }
775                 if (--boguscount <= 0)
776                         break;
777         }
778
779         /* If any worth-while packets have been received, dev_rint()
780            has done a mark_bh(NET_BH) for us and will work on them
781            when we get to the bottom-half routine. */
782         {
783                 int i;
784                 for (i = 0; i < 20; i++) {
785                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
786                                 break;
787                         inw(ioaddr + DATAPORT);                         /* dummy status read */
788                         outb(0x05, ioaddr + RX_CTRL);
789                 }
790
791                 if (net_debug > 5)
792                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n",
793                                    dev->name, inb(ioaddr + RX_MODE), i);
794         }
795         return;
796 }
797
798 /* The inverse routine to net_open(). */
799 static int net_close(struct net_device *dev)
800 {
801         struct net_local *lp = netdev_priv(dev);
802         int ioaddr = dev->base_addr;
803
804         netif_stop_queue(dev);
805
806         /* Set configuration register 0 to disable Tx and Rx. */
807         outb(0xda, ioaddr + CONFIG_0);
808
809         /* No statistic counters on the chip to update. */
810
811         /* Disable the IRQ on boards of fmv18x where it is feasible. */
812         if (lp->jumpered) {
813                 outb(0x00, ioaddr + IOCONFIG1);
814                 free_irq(dev->irq, dev);
815         }
816
817         /* Power-down the chip.  Green, green, green! */
818         outb(0x00, ioaddr + CONFIG_1);
819         return 0;
820 }
821
822 /*
823   Set the multicast/promiscuous mode for this adaptor.
824 */
825
826 static void
827 set_rx_mode(struct net_device *dev)
828 {
829         int ioaddr = dev->base_addr;
830         struct net_local *lp = netdev_priv(dev);
831         unsigned char mc_filter[8];              /* Multicast hash filter */
832         unsigned long flags;
833         int i;
834
835         if (dev->flags & IFF_PROMISC) {
836                 memset(mc_filter, 0xff, sizeof(mc_filter));
837                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
838         } else if (dev->mc_count > MC_FILTERBREAK
839                            ||  (dev->flags & IFF_ALLMULTI)) {
840                 /* Too many to filter perfectly -- accept all multicasts. */
841                 memset(mc_filter, 0xff, sizeof(mc_filter));
842                 outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
843         } else if (dev->mc_count == 0) {
844                 memset(mc_filter, 0x00, sizeof(mc_filter));
845                 outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
846         } else {
847                 struct dev_mc_list *mclist;
848                 int i;
849
850                 memset(mc_filter, 0, sizeof(mc_filter));
851                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
852                          i++, mclist = mclist->next) {
853                         unsigned int bit =
854                                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
855                         mc_filter[bit >> 3] |= (1 << bit);
856                 }
857                 outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
858         }
859
860         spin_lock_irqsave (&lp->lock, flags);
861         if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
862                 int saved_bank = inw(ioaddr + CONFIG_0);
863                 /* Switch to bank 1 and set the multicast table. */
864                 outw((saved_bank & ~0x0C00) | 0x0480, ioaddr + CONFIG_0);
865                 for (i = 0; i < 8; i++)
866                         outb(mc_filter[i], ioaddr + PORT_OFFSET(8 + i));
867                 memcpy(lp->mc_filter, mc_filter, sizeof(mc_filter));
868                 outw(saved_bank, ioaddr + CONFIG_0);
869         }
870         spin_unlock_irqrestore (&lp->lock, flags);
871         return;
872 }
873
874 #ifdef MODULE
875 static struct net_device *dev_at1700;
876
877 module_param(io, int, 0);
878 module_param(irq, int, 0);
879 module_param(net_debug, int, 0);
880 MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
881 MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
882 MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
883
884 static int __init at1700_module_init(void)
885 {
886         if (io == 0)
887                 printk("at1700: You should not use auto-probing with insmod!\n");
888         dev_at1700 = at1700_probe(-1);
889         if (IS_ERR(dev_at1700))
890                 return PTR_ERR(dev_at1700);
891         return 0;
892 }
893
894 static void __exit at1700_module_exit(void)
895 {
896         unregister_netdev(dev_at1700);
897         cleanup_card(dev_at1700);
898         free_netdev(dev_at1700);
899 }
900 module_init(at1700_module_init);
901 module_exit(at1700_module_exit);
902 #endif /* MODULE */
903 MODULE_LICENSE("GPL");
904
905
906 /*
907  * Local variables:
908  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
909  *  alt-compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c at1700.c"
910  *  tab-width: 4
911  *  c-basic-offset: 4
912  *  c-indent-level: 4
913  * End:
914  */
915