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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive