← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/net/at1700.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/string.h>
51
 
#include <linux/init.h>
52
 
#include <linux/crc32.h>
53
 
#include <linux/bitops.h>
54
 
 
55
 
#include <asm/system.h>
56
 
#include <asm/io.h>
57
 
#include <asm/dma.h>
58
 
 
59
 
static char version[] __initdata =
60
 
        "at1700.c:v1.16 9/11/06  Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
61
 
 
62
 
#define DRV_NAME "at1700"
63
 
 
64
 
/* Tunable parameters. */
65
 
 
66
 
/* When to switch from the 64-entry multicast filter to Rx-all-multicast. */
67
 
#define MC_FILTERBREAK 64
68
 
 
69
 
/* These unusual address orders are used to verify the CONFIG register. */
70
 
 
71
 
static int fmv18x_probe_list[] __initdata = {
72
 
        0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x300, 0x340, 0
73
 
};
74
 
 
75
 
/*
76
 
 *      ISA
77
 
 */
78
 
 
79
 
static unsigned at1700_probe_list[] __initdata = {
80
 
        0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0
81
 
};
82
 
 
83
 
/*
84
 
 *      MCA
85
 
 */
86
 
#ifdef CONFIG_MCA_LEGACY
87
 
static int at1700_ioaddr_pattern[] __initdata = {
88
 
        0x00, 0x04, 0x01, 0x05, 0x02, 0x06, 0x03, 0x07
89
 
};
90
 
 
91
 
static int at1700_mca_probe_list[] __initdata = {
92
 
        0x400, 0x1400, 0x2400, 0x3400, 0x4400, 0x5400, 0x6400, 0x7400, 0
93
 
};
94
 
 
95
 
static int at1700_irq_pattern[] __initdata = {
96
 
        0x00, 0x00, 0x00, 0x30, 0x70, 0xb0, 0x00, 0x00,
97
 
        0x00, 0xf0, 0x34, 0x74, 0xb4, 0x00, 0x00, 0xf4, 0x00
98
 
};
99
 
#endif
100
 
 
101
 
/* use 0 for production, 1 for verification, >2 for debug */
102
 
#ifndef NET_DEBUG
103
 
#define NET_DEBUG 1
104
 
#endif
105
 
static unsigned int net_debug = NET_DEBUG;
106
 
 
107
 
typedef unsigned char uchar;
108
 
 
109
 
/* Information that need to be kept for each board. */
110
 
struct net_local {
111
 
        spinlock_t lock;
112
 
        unsigned char mc_filter[8];
113
 
        uint jumpered:1;                        /* Set iff the board has jumper config. */
114
 
        uint tx_started:1;                      /* Packets are on the Tx queue. */
115
 
        uint tx_queue_ready:1;                  /* Tx queue is ready to be sent. */
116
 
        uint rx_started:1;                      /* Packets are Rxing. */
117
 
        uchar tx_queue;                         /* Number of packet on the Tx queue. */
118
 
        char mca_slot;                          /* -1 means ISA */
119
 
        ushort tx_queue_len;                    /* Current length of the Tx queue. */
120
 
};
121
 
 
122
 
 
123
 
/* Offsets from the base address. */
124
 
#define STATUS                  0
125
 
#define TX_STATUS               0
126
 
#define RX_STATUS               1
127
 
#define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
128
 
#define RX_INTR                 3
129
 
#define TX_MODE                 4
130
 
#define RX_MODE                 5
131
 
#define CONFIG_0                6               /* Misc. configuration settings. */
132
 
#define CONFIG_1                7
133
 
/* Run-time register bank 2 definitions. */
134
 
#define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
135
 
#define TX_START                10
136
 
#define COL16CNTL               11              /* Control Reg for 16 collisions */
137
 
#define MODE13                  13
138
 
#define RX_CTRL                 14
139
 
/* Configuration registers only on the '865A/B chips. */
140
 
#define EEPROM_Ctrl     16
141
 
#define EEPROM_Data     17
142
 
#define CARDSTATUS      16                      /* FMV-18x Card Status */
143
 
#define CARDSTATUS1     17                      /* FMV-18x Card Status */
144
 
#define IOCONFIG                18              /* Either read the jumper, or move the I/O. */
145
 
#define IOCONFIG1               19
146
 
#define SAPROM                  20              /* The station address PROM, if no EEPROM. */
147
 
#define MODE24                  24
148
 
#define RESET                   31              /* Write to reset some parts of the chip. */
149
 
#define AT1700_IO_EXTENT        32
150
 
#define PORT_OFFSET(o) (o)
151
 
 
152
 
 
153
 
#define TX_TIMEOUT              (HZ/10)
154
 
 
155
 
 
156
 
/* Index to functions, as function prototypes. */
157
 
 
158
 
static int at1700_probe1(struct net_device *dev, int ioaddr);
159
 
static int read_eeprom(long ioaddr, int location);
160
 
static int net_open(struct net_device *dev);
161
 
static netdev_tx_t net_send_packet(struct sk_buff *skb,
162
 
                                   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
 
static 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
 
 
271
 
static int __init at1700_probe1(struct net_device *dev, int ioaddr)
272
 
{
273
 
        static const char fmv_irqmap[4] = {3, 7, 10, 15};
274
 
        static const char fmv_irqmap_pnp[8] = {3, 4, 5, 7, 9, 10, 11, 15};
275
 
        static const 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
365
 
found:
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
 
 
480
 
err_mca:
481
 
#ifdef CONFIG_MCA_LEGACY
482
 
        if (slot >= 0)
483
 
                mca_mark_as_unused(slot);
484
 
#endif
485
 
err_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
 
 
502
 
static 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
 
 
533
 
static 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
 
 
564
 
static 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; /* prevent tx timeout */
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
 
 
598
 
static netdev_tx_t net_send_packet (struct sk_buff *skb,
599
 
                                    struct net_device *dev)
600
 
{
601
 
        struct net_local *lp = netdev_priv(dev);
602
 
        int ioaddr = dev->base_addr;
603
 
        short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
604
 
        short len = skb->len;
605
 
        unsigned char *buf = skb->data;
606
 
        static u8 pad[ETH_ZLEN];
607
 
 
608
 
        netif_stop_queue (dev);
609
 
 
610
 
        /* We may not start transmitting unless we finish transferring
611
 
           a packet into the Tx queue. During executing the following
612
 
           codes we possibly catch a Tx interrupt. Thus we flag off
613
 
           tx_queue_ready, so that we prevent the interrupt routine
614
 
           (net_interrupt) to start transmitting. */
615
 
        lp->tx_queue_ready = 0;
616
 
        {
617
 
                outw (length, ioaddr + DATAPORT);
618
 
                /* Packet data */
619
 
                outsw (ioaddr + DATAPORT, buf, len >> 1);
620
 
                /* Check for dribble byte */
621
 
                if (len & 1) {
622
 
                        outw(skb->data[skb->len-1], ioaddr + DATAPORT);
623
 
                        len++;
624
 
                }
625
 
                /* Check for packet padding */
626
 
                if (length != skb->len)
627
 
                        outsw(ioaddr + DATAPORT, pad, (length - len + 1) >> 1);
628
 
 
629
 
                lp->tx_queue++;
630
 
                lp->tx_queue_len += length + 2;
631
 
        }
632
 
        lp->tx_queue_ready = 1;
633
 
 
634
 
        if (lp->tx_started == 0) {
635
 
                /* If the Tx is idle, always trigger a transmit. */
636
 
                outb (0x80 | lp->tx_queue, ioaddr + TX_START);
637
 
                lp->tx_queue = 0;
638
 
                lp->tx_queue_len = 0;
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 NETDEV_TX_OK;
647
 
}
648
 
 
649
 
/* The typical workload of the driver:
650
 
   Handle the network interface interrupts. */
651
 
static 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. */
721
 
static void
722
 
net_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
 
}
799
 
 
800
 
/* The inverse routine to net_open(). */
801
 
static int net_close(struct net_device *dev)
802
 
{
803
 
        struct net_local *lp = netdev_priv(dev);
804
 
        int ioaddr = dev->base_addr;
805
 
 
806
 
        netif_stop_queue(dev);
807
 
 
808
 
        /* Set configuration register 0 to disable Tx and Rx. */
809
 
        outb(0xda, ioaddr + CONFIG_0);
810
 
 
811
 
        /* No statistic counters on the chip to update. */
812
 
 
813
 
        /* Disable the IRQ on boards of fmv18x where it is feasible. */
814
 
        if (lp->jumpered)
815
 
                outb(0x00, ioaddr + IOCONFIG1);
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
 
 
834
 
        if (dev->flags & IFF_PROMISC) {
835
 
                memset(mc_filter, 0xff, sizeof(mc_filter));
836
 
                outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
837
 
        } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
838
 
                           (dev->flags & IFF_ALLMULTI)) {
839
 
                /* Too many to filter perfectly -- accept all multicasts. */
840
 
                memset(mc_filter, 0xff, sizeof(mc_filter));
841
 
                outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
842
 
        } else if (netdev_mc_empty(dev)) {
843
 
                memset(mc_filter, 0x00, sizeof(mc_filter));
844
 
                outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
845
 
        } else {
846
 
                struct netdev_hw_addr *ha;
847
 
 
848
 
                memset(mc_filter, 0, sizeof(mc_filter));
849
 
                netdev_for_each_mc_addr(ha, dev) {
850
 
                        unsigned int bit =
851
 
                                ether_crc_le(ETH_ALEN, ha->addr) >> 26;
852
 
                        mc_filter[bit >> 3] |= (1 << bit);
853
 
                }
854
 
                outb(0x02, ioaddr + RX_MODE);   /* Use normal mode. */
855
 
        }
856
 
 
857
 
        spin_lock_irqsave (&lp->lock, flags);
858
 
        if (memcmp(mc_filter, lp->mc_filter, sizeof(mc_filter))) {
859
 
                int i;
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
 
}
870
 
 
871
 
#ifdef MODULE
872
 
static struct net_device *dev_at1700;
873
 
 
874
 
module_param(io, int, 0);
875
 
module_param(irq, int, 0);
876
 
module_param(net_debug, int, 0);
877
 
MODULE_PARM_DESC(io, "AT1700/FMV18X I/O base address");
878
 
MODULE_PARM_DESC(irq, "AT1700/FMV18X IRQ number");
879
 
MODULE_PARM_DESC(net_debug, "AT1700/FMV18X debug level (0-6)");
880
 
 
881
 
static int __init at1700_module_init(void)
882
 
{
883
 
        if (io == 0)
884
 
                printk("at1700: You should not use auto-probing with insmod!\n");
885
 
        dev_at1700 = at1700_probe(-1);
886
 
        if (IS_ERR(dev_at1700))
887
 
                return PTR_ERR(dev_at1700);
888
 
        return 0;
889
 
}
890
 
 
891
 
static void __exit at1700_module_exit(void)
892
 
{
893
 
        unregister_netdev(dev_at1700);
894
 
        cleanup_card(dev_at1700);
895
 
        free_netdev(dev_at1700);
896
 
}
897
 
module_init(at1700_module_init);
898
 
module_exit(at1700_module_exit);
899
 
#endif /* MODULE */
900
 
MODULE_LICENSE("GPL");