← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/net/pcmcia/fmvj18x_cs.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/pcmcia/fmvj18x_cs.c
1
 
/*======================================================================
2
 
    fmvj18x_cs.c 2.8 2002/03/23
3
 
 
4
 
    A fmvj18x (and its compatibles) PCMCIA client driver
5
 
 
6
 
    Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
7
 
 
8
 
    TDK LAK-CD021 and CONTEC C-NET(PC)C support added by 
9
 
    Nobuhiro Katayama, kata-n@po.iijnet.or.jp
10
 
 
11
 
    The PCMCIA client code is based on code written by David Hinds.
12
 
    Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
13
 
    but is actually largely Donald Becker's AT1700 driver, which
14
 
    carries the following attribution:
15
 
 
16
 
    Written 1993-94 by Donald Becker.
17
 
 
18
 
    Copyright 1993 United States Government as represented by the
19
 
    Director, National Security Agency.
20
 
    
21
 
    This software may be used and distributed according to the terms
22
 
    of the GNU General Public License, incorporated herein by reference.
23
 
    
24
 
    The author may be reached as becker@scyld.com, or C/O
25
 
    Scyld Computing Corporation
26
 
    410 Severn Ave., Suite 210
27
 
    Annapolis MD 21403
28
 
   
29
 
======================================================================*/
30
 
 
31
 
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
32
 
 
33
 
#define DRV_NAME        "fmvj18x_cs"
34
 
#define DRV_VERSION     "2.9"
35
 
 
36
 
#include <linux/module.h>
37
 
#include <linux/kernel.h>
38
 
#include <linux/init.h>
39
 
#include <linux/ptrace.h>
40
 
#include <linux/slab.h>
41
 
#include <linux/string.h>
42
 
#include <linux/timer.h>
43
 
#include <linux/interrupt.h>
44
 
#include <linux/in.h>
45
 
#include <linux/delay.h>
46
 
#include <linux/ethtool.h>
47
 
#include <linux/netdevice.h>
48
 
#include <linux/etherdevice.h>
49
 
#include <linux/skbuff.h>
50
 
#include <linux/if_arp.h>
51
 
#include <linux/ioport.h>
52
 
#include <linux/crc32.h>
53
 
 
54
 
#include <pcmcia/cistpl.h>
55
 
#include <pcmcia/ciscode.h>
56
 
#include <pcmcia/ds.h>
57
 
 
58
 
#include <asm/uaccess.h>
59
 
#include <asm/io.h>
60
 
#include <asm/system.h>
61
 
 
62
 
/*====================================================================*/
63
 
 
64
 
/* Module parameters */
65
 
 
66
 
MODULE_DESCRIPTION("fmvj18x and compatible PCMCIA ethernet driver");
67
 
MODULE_LICENSE("GPL");
68
 
 
69
 
#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
70
 
 
71
 
/* SRAM configuration */
72
 
/* 0:4KB*2 TX buffer   else:8KB*2 TX buffer */
73
 
INT_MODULE_PARM(sram_config, 0);
74
 
 
75
 
 
76
 
/*====================================================================*/
77
 
/*
78
 
    PCMCIA event handlers
79
 
 */
80
 
static int fmvj18x_config(struct pcmcia_device *link);
81
 
static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id);
82
 
static int fmvj18x_setup_mfc(struct pcmcia_device *link);
83
 
static void fmvj18x_release(struct pcmcia_device *link);
84
 
static void fmvj18x_detach(struct pcmcia_device *p_dev);
85
 
 
86
 
/*
87
 
    LAN controller(MBH86960A) specific routines
88
 
 */
89
 
static int fjn_config(struct net_device *dev, struct ifmap *map);
90
 
static int fjn_open(struct net_device *dev);
91
 
static int fjn_close(struct net_device *dev);
92
 
static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
93
 
                                        struct net_device *dev);
94
 
static irqreturn_t fjn_interrupt(int irq, void *dev_id);
95
 
static void fjn_rx(struct net_device *dev);
96
 
static void fjn_reset(struct net_device *dev);
97
 
static void set_rx_mode(struct net_device *dev);
98
 
static void fjn_tx_timeout(struct net_device *dev);
99
 
static const struct ethtool_ops netdev_ethtool_ops;
100
 
 
101
 
/*
102
 
    card type
103
 
 */
104
 
typedef enum { MBH10302, MBH10304, TDK, CONTEC, LA501, UNGERMANN, 
105
 
               XXX10304, NEC, KME
106
 
} cardtype_t;
107
 
 
108
 
/*
109
 
    driver specific data structure
110
 
*/
111
 
typedef struct local_info_t {
112
 
        struct pcmcia_device    *p_dev;
113
 
    long open_time;
114
 
    uint tx_started:1;
115
 
    uint tx_queue;
116
 
    u_short tx_queue_len;
117
 
    cardtype_t cardtype;
118
 
    u_short sent;
119
 
    u_char __iomem *base;
120
 
} local_info_t;
121
 
 
122
 
#define MC_FILTERBREAK 64
123
 
 
124
 
/*====================================================================*/
125
 
/* 
126
 
    ioport offset from the base address 
127
 
 */
128
 
#define TX_STATUS               0 /* transmit status register */
129
 
#define RX_STATUS               1 /* receive status register */
130
 
#define TX_INTR                 2 /* transmit interrupt mask register */
131
 
#define RX_INTR                 3 /* receive interrupt mask register */
132
 
#define TX_MODE                 4 /* transmit mode register */
133
 
#define RX_MODE                 5 /* receive mode register */
134
 
#define CONFIG_0                6 /* configuration register 0 */
135
 
#define CONFIG_1                7 /* configuration register 1 */
136
 
 
137
 
#define NODE_ID                 8 /* node ID register            (bank 0) */
138
 
#define MAR_ADR                 8 /* multicast address registers (bank 1) */
139
 
 
140
 
#define DATAPORT                8 /* buffer mem port registers   (bank 2) */
141
 
#define TX_START               10 /* transmit start register */
142
 
#define COL_CTRL               11 /* 16 collision control register */
143
 
#define BMPR12                 12 /* reserved */
144
 
#define BMPR13                 13 /* reserved */
145
 
#define RX_SKIP                14 /* skip received packet register */
146
 
 
147
 
#define LAN_CTRL               16 /* LAN card control register */
148
 
 
149
 
#define MAC_ID               0x1a /* hardware address */
150
 
#define UNGERMANN_MAC_ID     0x18 /* UNGERMANN-BASS hardware address */
151
 
 
152
 
/* 
153
 
    control bits 
154
 
 */
155
 
#define ENA_TMT_OK           0x80
156
 
#define ENA_TMT_REC          0x20
157
 
#define ENA_COL              0x04
158
 
#define ENA_16_COL           0x02
159
 
#define ENA_TBUS_ERR         0x01
160
 
 
161
 
#define ENA_PKT_RDY          0x80
162
 
#define ENA_BUS_ERR          0x40
163
 
#define ENA_LEN_ERR          0x08
164
 
#define ENA_ALG_ERR          0x04
165
 
#define ENA_CRC_ERR          0x02
166
 
#define ENA_OVR_FLO          0x01
167
 
 
168
 
/* flags */
169
 
#define F_TMT_RDY            0x80 /* can accept new packet */
170
 
#define F_NET_BSY            0x40 /* carrier is detected */
171
 
#define F_TMT_OK             0x20 /* send packet successfully */
172
 
#define F_SRT_PKT            0x10 /* short packet error */
173
 
#define F_COL_ERR            0x04 /* collision error */
174
 
#define F_16_COL             0x02 /* 16 collision error */
175
 
#define F_TBUS_ERR           0x01 /* bus read error */
176
 
 
177
 
#define F_PKT_RDY            0x80 /* packet(s) in buffer */
178
 
#define F_BUS_ERR            0x40 /* bus read error */
179
 
#define F_LEN_ERR            0x08 /* short packet */
180
 
#define F_ALG_ERR            0x04 /* frame error */
181
 
#define F_CRC_ERR            0x02 /* CRC error */
182
 
#define F_OVR_FLO            0x01 /* overflow error */
183
 
 
184
 
#define F_BUF_EMP            0x40 /* receive buffer is empty */
185
 
 
186
 
#define F_SKP_PKT            0x05 /* drop packet in buffer */
187
 
 
188
 
/* default bitmaps */
189
 
#define D_TX_INTR  ( ENA_TMT_OK )
190
 
#define D_RX_INTR  ( ENA_PKT_RDY | ENA_LEN_ERR \
191
 
                   | ENA_ALG_ERR | ENA_CRC_ERR | ENA_OVR_FLO )
192
 
#define TX_STAT_M  ( F_TMT_RDY )
193
 
#define RX_STAT_M  ( F_PKT_RDY | F_LEN_ERR \
194
 
                   | F_ALG_ERR | F_CRC_ERR | F_OVR_FLO )
195
 
 
196
 
/* commands */
197
 
#define D_TX_MODE            0x06 /* no tests, detect carrier */
198
 
#define ID_MATCHED           0x02 /* (RX_MODE) */
199
 
#define RECV_ALL             0x03 /* (RX_MODE) */
200
 
#define CONFIG0_DFL          0x5a /* 16bit bus, 4K x 2 Tx queues */
201
 
#define CONFIG0_DFL_1        0x5e /* 16bit bus, 8K x 2 Tx queues */
202
 
#define CONFIG0_RST          0xda /* Data Link Controller off (CONFIG_0) */
203
 
#define CONFIG0_RST_1        0xde /* Data Link Controller off (CONFIG_0) */
204
 
#define BANK_0               0xa0 /* bank 0 (CONFIG_1) */
205
 
#define BANK_1               0xa4 /* bank 1 (CONFIG_1) */
206
 
#define BANK_2               0xa8 /* bank 2 (CONFIG_1) */
207
 
#define CHIP_OFF             0x80 /* contrl chip power off (CONFIG_1) */
208
 
#define DO_TX                0x80 /* do transmit packet */
209
 
#define SEND_PKT             0x81 /* send a packet */
210
 
#define AUTO_MODE            0x07 /* Auto skip packet on 16 col detected */
211
 
#define MANU_MODE            0x03 /* Stop and skip packet on 16 col */
212
 
#define TDK_AUTO_MODE        0x47 /* Auto skip packet on 16 col detected */
213
 
#define TDK_MANU_MODE        0x43 /* Stop and skip packet on 16 col */
214
 
#define INTR_OFF             0x0d /* LAN controller ignores interrupts */
215
 
#define INTR_ON              0x1d /* LAN controller will catch interrupts */
216
 
 
217
 
#define TX_TIMEOUT              ((400*HZ)/1000)
218
 
 
219
 
#define BANK_0U              0x20 /* bank 0 (CONFIG_1) */
220
 
#define BANK_1U              0x24 /* bank 1 (CONFIG_1) */
221
 
#define BANK_2U              0x28 /* bank 2 (CONFIG_1) */
222
 
 
223
 
static const struct net_device_ops fjn_netdev_ops = {
224
 
        .ndo_open               = fjn_open,
225
 
        .ndo_stop               = fjn_close,
226
 
        .ndo_start_xmit         = fjn_start_xmit,
227
 
        .ndo_tx_timeout         = fjn_tx_timeout,
228
 
        .ndo_set_config         = fjn_config,
229
 
        .ndo_set_multicast_list = set_rx_mode,
230
 
        .ndo_change_mtu         = eth_change_mtu,
231
 
        .ndo_set_mac_address    = eth_mac_addr,
232
 
        .ndo_validate_addr      = eth_validate_addr,
233
 
};
234
 
 
235
 
static int fmvj18x_probe(struct pcmcia_device *link)
236
 
{
237
 
    local_info_t *lp;
238
 
    struct net_device *dev;
239
 
 
240
 
    dev_dbg(&link->dev, "fmvj18x_attach()\n");
241
 
 
242
 
    /* Make up a FMVJ18x specific data structure */
243
 
    dev = alloc_etherdev(sizeof(local_info_t));
244
 
    if (!dev)
245
 
        return -ENOMEM;
246
 
    lp = netdev_priv(dev);
247
 
    link->priv = dev;
248
 
    lp->p_dev = link;
249
 
    lp->base = NULL;
250
 
 
251
 
    /* The io structure describes IO port mapping */
252
 
    link->resource[0]->end = 32;
253
 
    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
254
 
 
255
 
    /* General socket configuration */
256
 
    link->config_flags |= CONF_ENABLE_IRQ;
257
 
 
258
 
    dev->netdev_ops = &fjn_netdev_ops;
259
 
    dev->watchdog_timeo = TX_TIMEOUT;
260
 
 
261
 
    SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
262
 
 
263
 
    return fmvj18x_config(link);
264
 
} /* fmvj18x_attach */
265
 
 
266
 
/*====================================================================*/
267
 
 
268
 
static void fmvj18x_detach(struct pcmcia_device *link)
269
 
{
270
 
    struct net_device *dev = link->priv;
271
 
 
272
 
    dev_dbg(&link->dev, "fmvj18x_detach\n");
273
 
 
274
 
    unregister_netdev(dev);
275
 
 
276
 
    fmvj18x_release(link);
277
 
 
278
 
    free_netdev(dev);
279
 
} /* fmvj18x_detach */
280
 
 
281
 
/*====================================================================*/
282
 
 
283
 
static int mfc_try_io_port(struct pcmcia_device *link)
284
 
{
285
 
    int i, ret;
286
 
    static const unsigned int serial_base[5] =
287
 
        { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
288
 
 
289
 
    for (i = 0; i < 5; i++) {
290
 
        link->resource[1]->start = serial_base[i];
291
 
        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
292
 
        if (link->resource[1]->start == 0) {
293
 
            link->resource[1]->end = 0;
294
 
            pr_notice("out of resource for serial\n");
295
 
        }
296
 
        ret = pcmcia_request_io(link);
297
 
        if (ret == 0)
298
 
                return ret;
299
 
    }
300
 
    return ret;
301
 
}
302
 
 
303
 
static int ungermann_try_io_port(struct pcmcia_device *link)
304
 
{
305
 
    int ret;
306
 
    unsigned int ioaddr;
307
 
    /*
308
 
        Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
309
 
        0x380,0x3c0 only for ioport.
310
 
    */
311
 
    for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
312
 
        link->resource[0]->start = ioaddr;
313
 
        ret = pcmcia_request_io(link);
314
 
        if (ret == 0) {
315
 
            /* calculate ConfigIndex value */
316
 
            link->config_index =
317
 
                ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
318
 
            return ret;
319
 
        }
320
 
    }
321
 
    return ret; /* RequestIO failed */
322
 
}
323
 
 
324
 
static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
325
 
{
326
 
        return 0; /* strange, but that's what the code did already before... */
327
 
}
328
 
 
329
 
static int fmvj18x_config(struct pcmcia_device *link)
330
 
{
331
 
    struct net_device *dev = link->priv;
332
 
    local_info_t *lp = netdev_priv(dev);
333
 
    int i, ret;
334
 
    unsigned int ioaddr;
335
 
    cardtype_t cardtype;
336
 
    char *card_name = "unknown";
337
 
    u8 *buf;
338
 
    size_t len;
339
 
    u_char buggybuf[32];
340
 
 
341
 
    dev_dbg(&link->dev, "fmvj18x_config\n");
342
 
 
343
 
    link->io_lines = 5;
344
 
 
345
 
    len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
346
 
    kfree(buf);
347
 
 
348
 
    if (len) {
349
 
        /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
350
 
        ret = pcmcia_loop_config(link, fmvj18x_ioprobe, NULL);
351
 
        if (ret != 0)
352
 
                goto failed;
353
 
 
354
 
        switch (link->manf_id) {
355
 
        case MANFID_TDK:
356
 
            cardtype = TDK;
357
 
            if (link->card_id == PRODID_TDK_GN3410 ||
358
 
                link->card_id == PRODID_TDK_NP9610 ||
359
 
                link->card_id == PRODID_TDK_MN3200) {
360
 
                /* MultiFunction Card */
361
 
                link->config_base = 0x800;
362
 
                link->config_index = 0x47;
363
 
                link->resource[1]->end = 8;
364
 
            }
365
 
            break;
366
 
        case MANFID_NEC:
367
 
            cardtype = NEC; /* MultiFunction Card */
368
 
            link->config_base = 0x800;
369
 
            link->config_index = 0x47;
370
 
            link->resource[1]->end = 8;
371
 
            break;
372
 
        case MANFID_KME:
373
 
            cardtype = KME; /* MultiFunction Card */
374
 
            link->config_base = 0x800;
375
 
            link->config_index = 0x47;
376
 
            link->resource[1]->end = 8;
377
 
            break;
378
 
        case MANFID_CONTEC:
379
 
            cardtype = CONTEC;
380
 
            break;
381
 
        case MANFID_FUJITSU:
382
 
            if (link->config_base == 0x0fe0)
383
 
                cardtype = MBH10302;
384
 
            else if (link->card_id == PRODID_FUJITSU_MBH10302) 
385
 
                /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
386
 
                   but these are MBH10304 based card. */ 
387
 
                cardtype = MBH10304;
388
 
            else if (link->card_id == PRODID_FUJITSU_MBH10304)
389
 
                cardtype = MBH10304;
390
 
            else
391
 
                cardtype = LA501;
392
 
            break;
393
 
        default:
394
 
            cardtype = MBH10304;
395
 
        }
396
 
    } else {
397
 
        /* old type card */
398
 
        switch (link->manf_id) {
399
 
        case MANFID_FUJITSU:
400
 
            if (link->card_id == PRODID_FUJITSU_MBH10304) {
401
 
                cardtype = XXX10304;    /* MBH10304 with buggy CIS */
402
 
                link->config_index = 0x20;
403
 
            } else {
404
 
                cardtype = MBH10302;    /* NextCom NC5310, etc. */
405
 
                link->config_index = 1;
406
 
            }
407
 
            break;
408
 
        case MANFID_UNGERMANN:
409
 
            cardtype = UNGERMANN;
410
 
            break;
411
 
        default:
412
 
            cardtype = MBH10302;
413
 
            link->config_index = 1;
414
 
        }
415
 
    }
416
 
 
417
 
    if (link->resource[1]->end != 0) {
418
 
        ret = mfc_try_io_port(link);
419
 
        if (ret != 0) goto failed;
420
 
    } else if (cardtype == UNGERMANN) {
421
 
        ret = ungermann_try_io_port(link);
422
 
        if (ret != 0) goto failed;
423
 
    } else { 
424
 
            ret = pcmcia_request_io(link);
425
 
            if (ret)
426
 
                    goto failed;
427
 
    }
428
 
    ret = pcmcia_request_irq(link, fjn_interrupt);
429
 
    if (ret)
430
 
            goto failed;
431
 
    ret = pcmcia_enable_device(link);
432
 
    if (ret)
433
 
            goto failed;
434
 
 
435
 
    dev->irq = link->irq;
436
 
    dev->base_addr = link->resource[0]->start;
437
 
 
438
 
    if (resource_size(link->resource[1]) != 0) {
439
 
        ret = fmvj18x_setup_mfc(link);
440
 
        if (ret != 0) goto failed;
441
 
    }
442
 
 
443
 
    ioaddr = dev->base_addr;
444
 
 
445
 
    /* Reset controller */
446
 
    if (sram_config == 0) 
447
 
        outb(CONFIG0_RST, ioaddr + CONFIG_0);
448
 
    else
449
 
        outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
450
 
 
451
 
    /* Power On chip and select bank 0 */
452
 
    if (cardtype == MBH10302)
453
 
        outb(BANK_0, ioaddr + CONFIG_1);
454
 
    else
455
 
        outb(BANK_0U, ioaddr + CONFIG_1);
456
 
    
457
 
    /* Set hardware address */
458
 
    switch (cardtype) {
459
 
    case MBH10304:
460
 
    case TDK:
461
 
    case LA501:
462
 
    case CONTEC:
463
 
    case NEC:
464
 
    case KME:
465
 
        if (cardtype == MBH10304) {
466
 
            card_name = "FMV-J182";
467
 
 
468
 
            len = pcmcia_get_tuple(link, CISTPL_FUNCE, &buf);
469
 
            if (len < 11) {
470
 
                    kfree(buf);
471
 
                    goto failed;
472
 
            }
473
 
            /* Read MACID from CIS */
474
 
            for (i = 5; i < 11; i++)
475
 
                    dev->dev_addr[i] = buf[i];
476
 
            kfree(buf);
477
 
        } else {
478
 
            if (pcmcia_get_mac_from_cis(link, dev))
479
 
                goto failed;
480
 
            if( cardtype == TDK ) {
481
 
                card_name = "TDK LAK-CD021";
482
 
            } else if( cardtype == LA501 ) {
483
 
                card_name = "LA501";
484
 
            } else if( cardtype == NEC ) {
485
 
                card_name = "PK-UG-J001";
486
 
            } else if( cardtype == KME ) {
487
 
                card_name = "Panasonic";
488
 
            } else {
489
 
                card_name = "C-NET(PC)C";
490
 
            }
491
 
        }
492
 
        break;
493
 
    case UNGERMANN:
494
 
        /* Read MACID from register */
495
 
        for (i = 0; i < 6; i++) 
496
 
            dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
497
 
        card_name = "Access/CARD";
498
 
        break;
499
 
    case XXX10304:
500
 
        /* Read MACID from Buggy CIS */
501
 
        if (fmvj18x_get_hwinfo(link, buggybuf) == -1) {
502
 
            pr_notice("unable to read hardware net address\n");
503
 
            goto failed;
504
 
        }
505
 
        for (i = 0 ; i < 6; i++) {
506
 
            dev->dev_addr[i] = buggybuf[i];
507
 
        }
508
 
        card_name = "FMV-J182";
509
 
        break;
510
 
    case MBH10302:
511
 
    default:
512
 
        /* Read MACID from register */
513
 
        for (i = 0; i < 6; i++) 
514
 
            dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
515
 
        card_name = "FMV-J181";
516
 
        break;
517
 
    }
518
 
 
519
 
    lp->cardtype = cardtype;
520
 
    SET_NETDEV_DEV(dev, &link->dev);
521
 
 
522
 
    if (register_netdev(dev) != 0) {
523
 
        pr_notice("register_netdev() failed\n");
524
 
        goto failed;
525
 
    }
526
 
 
527
 
    /* print current configuration */
528
 
    netdev_info(dev, "%s, sram %s, port %#3lx, irq %d, hw_addr %pM\n",
529
 
                card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2",
530
 
                dev->base_addr, dev->irq, dev->dev_addr);
531
 
 
532
 
    return 0;
533
 
    
534
 
failed:
535
 
    fmvj18x_release(link);
536
 
    return -ENODEV;
537
 
} /* fmvj18x_config */
538
 
/*====================================================================*/
539
 
 
540
 
static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
541
 
{
542
 
    u_char __iomem *base;
543
 
    int i, j;
544
 
 
545
 
    /* Allocate a small memory window */
546
 
    link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
547
 
    link->resource[2]->start = 0; link->resource[2]->end = 0;
548
 
    i = pcmcia_request_window(link, link->resource[2], 0);
549
 
    if (i != 0)
550
 
        return -1;
551
 
 
552
 
    base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
553
 
    pcmcia_map_mem_page(link, link->resource[2], 0);
554
 
 
555
 
    /*
556
 
     *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
557
 
     *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
558
 
     *  'xx' is garbage.
559
 
     *  'yy' is MAC address.
560
 
    */ 
561
 
    for (i = 0; i < 0x200; i++) {
562
 
        if (readb(base+i*2) == 0x22) {  
563
 
                if (readb(base+(i-1)*2) == 0xff &&
564
 
                    readb(base+(i+5)*2) == 0x04 &&
565
 
                    readb(base+(i+6)*2) == 0x06 &&
566
 
                    readb(base+(i+13)*2) == 0xff)
567
 
                        break;
568
 
        }
569
 
    }
570
 
 
571
 
    if (i != 0x200) {
572
 
        for (j = 0 ; j < 6; j++,i++) {
573
 
            node_id[j] = readb(base+(i+7)*2);
574
 
        }
575
 
    }
576
 
 
577
 
    iounmap(base);
578
 
    j = pcmcia_release_window(link, link->resource[2]);
579
 
    return (i != 0x200) ? 0 : -1;
580
 
 
581
 
} /* fmvj18x_get_hwinfo */
582
 
/*====================================================================*/
583
 
 
584
 
static int fmvj18x_setup_mfc(struct pcmcia_device *link)
585
 
{
586
 
    int i;
587
 
    struct net_device *dev = link->priv;
588
 
    unsigned int ioaddr;
589
 
    local_info_t *lp = netdev_priv(dev);
590
 
 
591
 
    /* Allocate a small memory window */
592
 
    link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
593
 
    link->resource[3]->start = link->resource[3]->end = 0;
594
 
    i = pcmcia_request_window(link, link->resource[3], 0);
595
 
    if (i != 0)
596
 
        return -1;
597
 
 
598
 
    lp->base = ioremap(link->resource[3]->start,
599
 
                       resource_size(link->resource[3]));
600
 
    if (lp->base == NULL) {
601
 
        netdev_notice(dev, "ioremap failed\n");
602
 
        return -1;
603
 
    }
604
 
 
605
 
    i = pcmcia_map_mem_page(link, link->resource[3], 0);
606
 
    if (i != 0) {
607
 
        iounmap(lp->base);
608
 
        lp->base = NULL;
609
 
        return -1;
610
 
    }
611
 
    
612
 
    ioaddr = dev->base_addr;
613
 
    writeb(0x47, lp->base+0x800);       /* Config Option Register of LAN */
614
 
    writeb(0x0,  lp->base+0x802);       /* Config and Status Register */
615
 
 
616
 
    writeb(ioaddr & 0xff, lp->base+0x80a);        /* I/O Base(Low) of LAN */
617
 
    writeb((ioaddr >> 8) & 0xff, lp->base+0x80c); /* I/O Base(High) of LAN */
618
 
   
619
 
    writeb(0x45, lp->base+0x820);       /* Config Option Register of Modem */
620
 
    writeb(0x8,  lp->base+0x822);       /* Config and Status Register */
621
 
 
622
 
    return 0;
623
 
 
624
 
}
625
 
/*====================================================================*/
626
 
 
627
 
static void fmvj18x_release(struct pcmcia_device *link)
628
 
{
629
 
 
630
 
    struct net_device *dev = link->priv;
631
 
    local_info_t *lp = netdev_priv(dev);
632
 
    u_char __iomem *tmp;
633
 
 
634
 
    dev_dbg(&link->dev, "fmvj18x_release\n");
635
 
 
636
 
    if (lp->base != NULL) {
637
 
        tmp = lp->base;
638
 
        lp->base = NULL;    /* set NULL before iounmap */
639
 
        iounmap(tmp);
640
 
    }
641
 
 
642
 
    pcmcia_disable_device(link);
643
 
 
644
 
}
645
 
 
646
 
static int fmvj18x_suspend(struct pcmcia_device *link)
647
 
{
648
 
        struct net_device *dev = link->priv;
649
 
 
650
 
        if (link->open)
651
 
                netif_device_detach(dev);
652
 
 
653
 
        return 0;
654
 
}
655
 
 
656
 
static int fmvj18x_resume(struct pcmcia_device *link)
657
 
{
658
 
        struct net_device *dev = link->priv;
659
 
 
660
 
        if (link->open) {
661
 
                fjn_reset(dev);
662
 
                netif_device_attach(dev);
663
 
        }
664
 
 
665
 
        return 0;
666
 
}
667
 
 
668
 
/*====================================================================*/
669
 
 
670
 
static const struct pcmcia_device_id fmvj18x_ids[] = {
671
 
        PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
672
 
        PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
673
 
        PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
674
 
        PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
675
 
        PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
676
 
        PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
677
 
        PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
678
 
        PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
679
 
        PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
680
 
        PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
681
 
        PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
682
 
        PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
683
 
        PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
684
 
        PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
685
 
        PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
686
 
        PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
687
 
        PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
688
 
        PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
689
 
        PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
690
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
691
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
692
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0e01),
693
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
694
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0b05),
695
 
        PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
696
 
        PCMCIA_DEVICE_NULL,
697
 
};
698
 
MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
699
 
 
700
 
static struct pcmcia_driver fmvj18x_cs_driver = {
701
 
        .owner          = THIS_MODULE,
702
 
        .name           = "fmvj18x_cs",
703
 
        .probe          = fmvj18x_probe,
704
 
        .remove         = fmvj18x_detach,
705
 
        .id_table       = fmvj18x_ids,
706
 
        .suspend        = fmvj18x_suspend,
707
 
        .resume         = fmvj18x_resume,
708
 
};
709
 
 
710
 
static int __init init_fmvj18x_cs(void)
711
 
{
712
 
        return pcmcia_register_driver(&fmvj18x_cs_driver);
713
 
}
714
 
 
715
 
static void __exit exit_fmvj18x_cs(void)
716
 
{
717
 
        pcmcia_unregister_driver(&fmvj18x_cs_driver);
718
 
}
719
 
 
720
 
module_init(init_fmvj18x_cs);
721
 
module_exit(exit_fmvj18x_cs);
722
 
 
723
 
/*====================================================================*/
724
 
 
725
 
static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
726
 
{
727
 
    struct net_device *dev = dev_id;
728
 
    local_info_t *lp = netdev_priv(dev);
729
 
    unsigned int ioaddr;
730
 
    unsigned short tx_stat, rx_stat;
731
 
 
732
 
    ioaddr = dev->base_addr;
733
 
 
734
 
    /* avoid multiple interrupts */
735
 
    outw(0x0000, ioaddr + TX_INTR);
736
 
 
737
 
    /* wait for a while */
738
 
    udelay(1);
739
 
 
740
 
    /* get status */
741
 
    tx_stat = inb(ioaddr + TX_STATUS);
742
 
    rx_stat = inb(ioaddr + RX_STATUS);
743
 
 
744
 
    /* clear status */
745
 
    outb(tx_stat, ioaddr + TX_STATUS);
746
 
    outb(rx_stat, ioaddr + RX_STATUS);
747
 
    
748
 
    pr_debug("%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
749
 
    pr_debug("               tx_status %02x.\n", tx_stat);
750
 
    
751
 
    if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
752
 
        /* there is packet(s) in rx buffer */
753
 
        fjn_rx(dev);
754
 
    }
755
 
    if (tx_stat & F_TMT_RDY) {
756
 
        dev->stats.tx_packets += lp->sent ;
757
 
        lp->sent = 0 ;
758
 
        if (lp->tx_queue) {
759
 
            outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
760
 
            lp->sent = lp->tx_queue ;
761
 
            lp->tx_queue = 0;
762
 
            lp->tx_queue_len = 0;
763
 
            dev->trans_start = jiffies;
764
 
        } else {
765
 
            lp->tx_started = 0;
766
 
        }
767
 
        netif_wake_queue(dev);
768
 
    }
769
 
    pr_debug("%s: exiting interrupt,\n", dev->name);
770
 
    pr_debug("    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
771
 
 
772
 
    outb(D_TX_INTR, ioaddr + TX_INTR);
773
 
    outb(D_RX_INTR, ioaddr + RX_INTR);
774
 
 
775
 
    if (lp->base != NULL) {
776
 
        /* Ack interrupt for multifunction card */
777
 
        writeb(0x01, lp->base+0x802);
778
 
        writeb(0x09, lp->base+0x822);
779
 
    }
780
 
 
781
 
    return IRQ_HANDLED;
782
 
 
783
 
} /* fjn_interrupt */
784
 
 
785
 
/*====================================================================*/
786
 
 
787
 
static void fjn_tx_timeout(struct net_device *dev)
788
 
{
789
 
    struct local_info_t *lp = netdev_priv(dev);
790
 
    unsigned int ioaddr = dev->base_addr;
791
 
 
792
 
    netdev_notice(dev, "transmit timed out with status %04x, %s?\n",
793
 
                  htons(inw(ioaddr + TX_STATUS)),
794
 
                  inb(ioaddr + TX_STATUS) & F_TMT_RDY
795
 
                  ? "IRQ conflict" : "network cable problem");
796
 
    netdev_notice(dev, "timeout registers: %04x %04x %04x "
797
 
                  "%04x %04x %04x %04x %04x.\n",
798
 
                  htons(inw(ioaddr + 0)), htons(inw(ioaddr + 2)),
799
 
                  htons(inw(ioaddr + 4)), htons(inw(ioaddr + 6)),
800
 
                  htons(inw(ioaddr + 8)), htons(inw(ioaddr + 10)),
801
 
                  htons(inw(ioaddr + 12)), htons(inw(ioaddr + 14)));
802
 
    dev->stats.tx_errors++;
803
 
    /* ToDo: We should try to restart the adaptor... */
804
 
    local_irq_disable();
805
 
    fjn_reset(dev);
806
 
 
807
 
    lp->tx_started = 0;
808
 
    lp->tx_queue = 0;
809
 
    lp->tx_queue_len = 0;
810
 
    lp->sent = 0;
811
 
    lp->open_time = jiffies;
812
 
    local_irq_enable();
813
 
    netif_wake_queue(dev);
814
 
}
815
 
 
816
 
static netdev_tx_t fjn_start_xmit(struct sk_buff *skb,
817
 
                                        struct net_device *dev)
818
 
{
819
 
    struct local_info_t *lp = netdev_priv(dev);
820
 
    unsigned int ioaddr = dev->base_addr;
821
 
    short length = skb->len;
822
 
    
823
 
    if (length < ETH_ZLEN)
824
 
    {
825
 
        if (skb_padto(skb, ETH_ZLEN))
826
 
                return NETDEV_TX_OK;
827
 
        length = ETH_ZLEN;
828
 
    }
829
 
 
830
 
    netif_stop_queue(dev);
831
 
 
832
 
    {
833
 
        unsigned char *buf = skb->data;
834
 
 
835
 
        if (length > ETH_FRAME_LEN) {
836
 
            netdev_notice(dev, "Attempting to send a large packet (%d bytes)\n",
837
 
                          length);
838
 
            return NETDEV_TX_BUSY;
839
 
        }
840
 
 
841
 
        netdev_dbg(dev, "Transmitting a packet of length %lu\n",
842
 
                   (unsigned long)skb->len);
843
 
        dev->stats.tx_bytes += skb->len;
844
 
 
845
 
        /* Disable both interrupts. */
846
 
        outw(0x0000, ioaddr + TX_INTR);
847
 
 
848
 
        /* wait for a while */
849
 
        udelay(1);
850
 
 
851
 
        outw(length, ioaddr + DATAPORT);
852
 
        outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
853
 
 
854
 
        lp->tx_queue++;
855
 
        lp->tx_queue_len += ((length+3) & ~1);
856
 
 
857
 
        if (lp->tx_started == 0) {
858
 
            /* If the Tx is idle, always trigger a transmit. */
859
 
            outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
860
 
            lp->sent = lp->tx_queue ;
861
 
            lp->tx_queue = 0;
862
 
            lp->tx_queue_len = 0;
863
 
            lp->tx_started = 1;
864
 
            netif_start_queue(dev);
865
 
        } else {
866
 
            if( sram_config == 0 ) {
867
 
                if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
868
 
                    /* Yes, there is room for one more packet. */
869
 
                    netif_start_queue(dev);
870
 
            } else {
871
 
                if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) && 
872
 
                                                lp->tx_queue < 127 )
873
 
                    /* Yes, there is room for one more packet. */
874
 
                    netif_start_queue(dev);
875
 
            }
876
 
        }
877
 
 
878
 
        /* Re-enable interrupts */
879
 
        outb(D_TX_INTR, ioaddr + TX_INTR);
880
 
        outb(D_RX_INTR, ioaddr + RX_INTR);
881
 
    }
882
 
    dev_kfree_skb (skb);
883
 
 
884
 
    return NETDEV_TX_OK;
885
 
} /* fjn_start_xmit */
886
 
 
887
 
/*====================================================================*/
888
 
 
889
 
static void fjn_reset(struct net_device *dev)
890
 
{
891
 
    struct local_info_t *lp = netdev_priv(dev);
892
 
    unsigned int ioaddr = dev->base_addr;
893
 
    int i;
894
 
 
895
 
    netdev_dbg(dev, "fjn_reset() called\n");
896
 
 
897
 
    /* Reset controller */
898
 
    if( sram_config == 0 ) 
899
 
        outb(CONFIG0_RST, ioaddr + CONFIG_0);
900
 
    else
901
 
        outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
902
 
 
903
 
    /* Power On chip and select bank 0 */
904
 
    if (lp->cardtype == MBH10302)
905
 
        outb(BANK_0, ioaddr + CONFIG_1);
906
 
    else
907
 
        outb(BANK_0U, ioaddr + CONFIG_1);
908
 
 
909
 
    /* Set Tx modes */
910
 
    outb(D_TX_MODE, ioaddr + TX_MODE);
911
 
    /* set Rx modes */
912
 
    outb(ID_MATCHED, ioaddr + RX_MODE);
913
 
 
914
 
    /* Set hardware address */
915
 
    for (i = 0; i < 6; i++) 
916
 
        outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
917
 
 
918
 
    /* (re)initialize the multicast table */
919
 
    set_rx_mode(dev);
920
 
 
921
 
    /* Switch to bank 2 (runtime mode) */
922
 
    if (lp->cardtype == MBH10302)
923
 
        outb(BANK_2, ioaddr + CONFIG_1);
924
 
    else
925
 
        outb(BANK_2U, ioaddr + CONFIG_1);
926
 
 
927
 
    /* set 16col ctrl bits */
928
 
    if( lp->cardtype == TDK || lp->cardtype == CONTEC) 
929
 
        outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
930
 
    else
931
 
        outb(AUTO_MODE, ioaddr + COL_CTRL);
932
 
 
933
 
    /* clear Reserved Regs */
934
 
    outb(0x00, ioaddr + BMPR12);
935
 
    outb(0x00, ioaddr + BMPR13);
936
 
 
937
 
    /* reset Skip packet reg. */
938
 
    outb(0x01, ioaddr + RX_SKIP);
939
 
 
940
 
    /* Enable Tx and Rx */
941
 
    if( sram_config == 0 )
942
 
        outb(CONFIG0_DFL, ioaddr + CONFIG_0);
943
 
    else
944
 
        outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
945
 
 
946
 
    /* Init receive pointer ? */
947
 
    inw(ioaddr + DATAPORT);
948
 
    inw(ioaddr + DATAPORT);
949
 
 
950
 
    /* Clear all status */
951
 
    outb(0xff, ioaddr + TX_STATUS);
952
 
    outb(0xff, ioaddr + RX_STATUS);
953
 
 
954
 
    if (lp->cardtype == MBH10302)
955
 
        outb(INTR_OFF, ioaddr + LAN_CTRL);
956
 
 
957
 
    /* Turn on Rx interrupts */
958
 
    outb(D_TX_INTR, ioaddr + TX_INTR);
959
 
    outb(D_RX_INTR, ioaddr + RX_INTR);
960
 
 
961
 
    /* Turn on interrupts from LAN card controller */
962
 
    if (lp->cardtype == MBH10302)
963
 
        outb(INTR_ON, ioaddr + LAN_CTRL);
964
 
} /* fjn_reset */
965
 
 
966
 
/*====================================================================*/
967
 
 
968
 
static void fjn_rx(struct net_device *dev)
969
 
{
970
 
    unsigned int ioaddr = dev->base_addr;
971
 
    int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
972
 
 
973
 
    pr_debug("%s: in rx_packet(), rx_status %02x.\n",
974
 
          dev->name, inb(ioaddr + RX_STATUS));
975
 
 
976
 
    while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
977
 
        u_short status = inw(ioaddr + DATAPORT);
978
 
 
979
 
        netdev_dbg(dev, "Rxing packet mode %02x status %04x.\n",
980
 
                   inb(ioaddr + RX_MODE), status);
981
 
#ifndef final_version
982
 
        if (status == 0) {
983
 
            outb(F_SKP_PKT, ioaddr + RX_SKIP);
984
 
            break;
985
 
        }
986
 
#endif
987
 
        if ((status & 0xF0) != 0x20) {  /* There was an error. */
988
 
            dev->stats.rx_errors++;
989
 
            if (status & F_LEN_ERR) dev->stats.rx_length_errors++;
990
 
            if (status & F_ALG_ERR) dev->stats.rx_frame_errors++;
991
 
            if (status & F_CRC_ERR) dev->stats.rx_crc_errors++;
992
 
            if (status & F_OVR_FLO) dev->stats.rx_over_errors++;
993
 
        } else {
994
 
            u_short pkt_len = inw(ioaddr + DATAPORT);
995
 
            /* Malloc up new buffer. */
996
 
            struct sk_buff *skb;
997
 
 
998
 
            if (pkt_len > 1550) {
999
 
                netdev_notice(dev, "The FMV-18x claimed a very large packet, size %d\n",
1000
 
                              pkt_len);
1001
 
                outb(F_SKP_PKT, ioaddr + RX_SKIP);
1002
 
                dev->stats.rx_errors++;
1003
 
                break;
1004
 
            }
1005
 
            skb = dev_alloc_skb(pkt_len+2);
1006
 
            if (skb == NULL) {
1007
 
                netdev_notice(dev, "Memory squeeze, dropping packet (len %d)\n",
1008
 
                              pkt_len);
1009
 
                outb(F_SKP_PKT, ioaddr + RX_SKIP);
1010
 
                dev->stats.rx_dropped++;
1011
 
                break;
1012
 
            }
1013
 
 
1014
 
            skb_reserve(skb, 2);
1015
 
            insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1016
 
                 (pkt_len + 1) >> 1);
1017
 
            skb->protocol = eth_type_trans(skb, dev);
1018
 
 
1019
 
            {
1020
 
                int i;
1021
 
                pr_debug("%s: Rxed packet of length %d: ",
1022
 
                        dev->name, pkt_len);
1023
 
                for (i = 0; i < 14; i++)
1024
 
                        pr_debug(" %02x", skb->data[i]);
1025
 
                pr_debug(".\n");
1026
 
            }
1027
 
 
1028
 
            netif_rx(skb);
1029
 
            dev->stats.rx_packets++;
1030
 
            dev->stats.rx_bytes += pkt_len;
1031
 
        }
1032
 
        if (--boguscount <= 0)
1033
 
            break;
1034
 
    }
1035
 
 
1036
 
    /* If any worth-while packets have been received, dev_rint()
1037
 
           has done a netif_wake_queue() for us and will work on them
1038
 
           when we get to the bottom-half routine. */
1039
 
/*
1040
 
    if (lp->cardtype != TDK) {
1041
 
        int i;
1042
 
        for (i = 0; i < 20; i++) {
1043
 
            if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1044
 
                break;
1045
 
            (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1046
 
            outb(F_SKP_PKT, ioaddr + RX_SKIP);
1047
 
        }
1048
 
 
1049
 
        if (i > 0)
1050
 
            pr_debug("%s: Exint Rx packet with mode %02x after "
1051
 
                  "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1052
 
    }
1053
 
*/
1054
 
} /* fjn_rx */
1055
 
 
1056
 
/*====================================================================*/
1057
 
 
1058
 
static void netdev_get_drvinfo(struct net_device *dev,
1059
 
                               struct ethtool_drvinfo *info)
1060
 
{
1061
 
        strcpy(info->driver, DRV_NAME);
1062
 
        strcpy(info->version, DRV_VERSION);
1063
 
        sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1064
 
}
1065
 
 
1066
 
static const struct ethtool_ops netdev_ethtool_ops = {
1067
 
        .get_drvinfo            = netdev_get_drvinfo,
1068
 
};
1069
 
 
1070
 
static int fjn_config(struct net_device *dev, struct ifmap *map){
1071
 
    return 0;
1072
 
}
1073
 
 
1074
 
static int fjn_open(struct net_device *dev)
1075
 
{
1076
 
    struct local_info_t *lp = netdev_priv(dev);
1077
 
    struct pcmcia_device *link = lp->p_dev;
1078
 
 
1079
 
    pr_debug("fjn_open('%s').\n", dev->name);
1080
 
 
1081
 
    if (!pcmcia_dev_present(link))
1082
 
        return -ENODEV;
1083
 
    
1084
 
    link->open++;
1085
 
    
1086
 
    fjn_reset(dev);
1087
 
    
1088
 
    lp->tx_started = 0;
1089
 
    lp->tx_queue = 0;
1090
 
    lp->tx_queue_len = 0;
1091
 
    lp->open_time = jiffies;
1092
 
    netif_start_queue(dev);
1093
 
    
1094
 
    return 0;
1095
 
} /* fjn_open */
1096
 
 
1097
 
/*====================================================================*/
1098
 
 
1099
 
static int fjn_close(struct net_device *dev)
1100
 
{
1101
 
    struct local_info_t *lp = netdev_priv(dev);
1102
 
    struct pcmcia_device *link = lp->p_dev;
1103
 
    unsigned int ioaddr = dev->base_addr;
1104
 
 
1105
 
    pr_debug("fjn_close('%s').\n", dev->name);
1106
 
 
1107
 
    lp->open_time = 0;
1108
 
    netif_stop_queue(dev);
1109
 
 
1110
 
    /* Set configuration register 0 to disable Tx and Rx. */
1111
 
    if( sram_config == 0 ) 
1112
 
        outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1113
 
    else
1114
 
        outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1115
 
 
1116
 
    /* Update the statistics -- ToDo. */
1117
 
 
1118
 
    /* Power-down the chip.  Green, green, green! */
1119
 
    outb(CHIP_OFF ,ioaddr + CONFIG_1);
1120
 
 
1121
 
    /* Set the ethernet adaptor disable IRQ */
1122
 
    if (lp->cardtype == MBH10302)
1123
 
        outb(INTR_OFF, ioaddr + LAN_CTRL);
1124
 
 
1125
 
    link->open--;
1126
 
 
1127
 
    return 0;
1128
 
} /* fjn_close */
1129
 
 
1130
 
/*====================================================================*/
1131
 
 
1132
 
/*
1133
 
  Set the multicast/promiscuous mode for this adaptor.
1134
 
*/
1135
 
 
1136
 
static void set_rx_mode(struct net_device *dev)
1137
 
{
1138
 
    unsigned int ioaddr = dev->base_addr;
1139
 
    u_char mc_filter[8];                 /* Multicast hash filter */
1140
 
    u_long flags;
1141
 
    int i;
1142
 
    
1143
 
    int saved_bank;
1144
 
    int saved_config_0 = inb(ioaddr + CONFIG_0);
1145
 
     
1146
 
    local_irq_save(flags); 
1147
 
 
1148
 
    /* Disable Tx and Rx */
1149
 
    if (sram_config == 0) 
1150
 
        outb(CONFIG0_RST, ioaddr + CONFIG_0);
1151
 
    else
1152
 
        outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1153
 
 
1154
 
    if (dev->flags & IFF_PROMISC) {
1155
 
        memset(mc_filter, 0xff, sizeof(mc_filter));
1156
 
        outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1157
 
    } else if (netdev_mc_count(dev) > MC_FILTERBREAK ||
1158
 
               (dev->flags & IFF_ALLMULTI)) {
1159
 
        /* Too many to filter perfectly -- accept all multicasts. */
1160
 
        memset(mc_filter, 0xff, sizeof(mc_filter));
1161
 
        outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1162
 
    } else if (netdev_mc_empty(dev)) {
1163
 
        memset(mc_filter, 0x00, sizeof(mc_filter));
1164
 
        outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1165
 
    } else {
1166
 
        struct netdev_hw_addr *ha;
1167
 
 
1168
 
        memset(mc_filter, 0, sizeof(mc_filter));
1169
 
        netdev_for_each_mc_addr(ha, dev) {
1170
 
            unsigned int bit = ether_crc_le(ETH_ALEN, ha->addr) >> 26;
1171
 
            mc_filter[bit >> 3] |= (1 << (bit & 7));
1172
 
        }
1173
 
        outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1174
 
    }
1175
 
 
1176
 
    /* Switch to bank 1 and set the multicast table. */
1177
 
    saved_bank = inb(ioaddr + CONFIG_1);
1178
 
    outb(0xe4, ioaddr + CONFIG_1);
1179
 
 
1180
 
    for (i = 0; i < 8; i++)
1181
 
        outb(mc_filter[i], ioaddr + MAR_ADR + i);
1182
 
    outb(saved_bank, ioaddr + CONFIG_1);
1183
 
 
1184
 
    outb(saved_config_0, ioaddr + CONFIG_0);
1185
 
 
1186
 
    local_irq_restore(flags);
1187
 
}