← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/fujitsu/at1700.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/ethernet/fujitsu/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_rx_mode        = 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");