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