69d916daa7bbb313440dbd4c2827a6779a715376
[linux-2.6.git] / 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 == 0)
313                 return ret;
314     }
315     return ret;
316 }
317
318 static int ungermann_try_io_port(struct pcmcia_device *link)
319 {
320     int ret;
321     unsigned int ioaddr;
322     /*
323         Ungermann-Bass Access/CARD accepts 0x300,0x320,0x340,0x360
324         0x380,0x3c0 only for ioport.
325     */
326     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
327         link->io.BasePort1 = ioaddr;
328         ret = pcmcia_request_io(link, &link->io);
329         if (ret == 0) {
330             /* calculate ConfigIndex value */
331             link->conf.ConfigIndex = 
332                 ((link->io.BasePort1 & 0x0f0) >> 3) | 0x22;
333             return ret;
334         }
335     }
336     return ret; /* RequestIO failed */
337 }
338
339 static int fmvj18x_config(struct pcmcia_device *link)
340 {
341     struct net_device *dev = link->priv;
342     local_info_t *lp = netdev_priv(dev);
343     tuple_t tuple;
344     cisparse_t parse;
345     u_short buf[32];
346     int i, last_fn = 0, last_ret = 0, ret;
347     unsigned int ioaddr;
348     cardtype_t cardtype;
349     char *card_name = "unknown";
350     u_char *node_id;
351     DECLARE_MAC_BUF(mac);
352
353     DEBUG(0, "fmvj18x_config(0x%p)\n", link);
354
355     tuple.TupleData = (u_char *)buf;
356     tuple.TupleDataMax = 64;
357     tuple.TupleOffset = 0;
358     tuple.DesiredTuple = CISTPL_FUNCE;
359     tuple.TupleOffset = 0;
360     if (pcmcia_get_first_tuple(link, &tuple) == 0) {
361         /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
362         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
363         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
364         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
365         CS_CHECK(ParseTuple, pcmcia_parse_tuple(&tuple, &parse));
366         link->conf.ConfigIndex = parse.cftable_entry.index;
367         switch (link->manf_id) {
368         case MANFID_TDK:
369             cardtype = TDK;
370             if (link->card_id == PRODID_TDK_GN3410
371                         || link->card_id == PRODID_TDK_NP9610
372                         || link->card_id == PRODID_TDK_MN3200) {
373                 /* MultiFunction Card */
374                 link->conf.ConfigBase = 0x800;
375                 link->conf.ConfigIndex = 0x47;
376                 link->io.NumPorts2 = 8;
377             }
378             break;
379         case MANFID_NEC:
380             cardtype = NEC; /* MultiFunction Card */
381             link->conf.ConfigBase = 0x800;
382             link->conf.ConfigIndex = 0x47;
383             link->io.NumPorts2 = 8;
384             break;
385         case MANFID_KME:
386             cardtype = KME; /* MultiFunction Card */
387             link->conf.ConfigBase = 0x800;
388             link->conf.ConfigIndex = 0x47;
389             link->io.NumPorts2 = 8;
390             break;
391         case MANFID_CONTEC:
392             cardtype = CONTEC;
393             break;
394         case MANFID_FUJITSU:
395             if (link->conf.ConfigBase == 0x0fe0)
396                 cardtype = MBH10302;
397             else if (link->card_id == PRODID_FUJITSU_MBH10302) 
398                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
399                    but these are MBH10304 based card. */ 
400                 cardtype = MBH10304;
401             else if (link->card_id == PRODID_FUJITSU_MBH10304)
402                 cardtype = MBH10304;
403             else
404                 cardtype = LA501;
405             break;
406         default:
407             cardtype = MBH10304;
408         }
409     } else {
410         /* old type card */
411         switch (link->manf_id) {
412         case MANFID_FUJITSU:
413             if (link->card_id == PRODID_FUJITSU_MBH10304) {
414                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
415                 link->conf.ConfigIndex = 0x20;
416             } else {
417                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
418                 link->conf.ConfigIndex = 1;
419             }
420             break;
421         case MANFID_UNGERMANN:
422             cardtype = UNGERMANN;
423             break;
424         default:
425             cardtype = MBH10302;
426             link->conf.ConfigIndex = 1;
427         }
428     }
429
430     if (link->io.NumPorts2 != 0) {
431         link->irq.Attributes =
432                 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
433         ret = mfc_try_io_port(link);
434         if (ret != 0) goto cs_failed;
435     } else if (cardtype == UNGERMANN) {
436         ret = ungermann_try_io_port(link);
437         if (ret != 0) goto cs_failed;
438     } else { 
439         CS_CHECK(RequestIO, pcmcia_request_io(link, &link->io));
440     }
441     CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
442     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
443     dev->irq = link->irq.AssignedIRQ;
444     dev->base_addr = link->io.BasePort1;
445
446     if (link->io.BasePort2 != 0)
447         fmvj18x_setup_mfc(link);
448
449     ioaddr = dev->base_addr;
450
451     /* Reset controller */
452     if (sram_config == 0) 
453         outb(CONFIG0_RST, ioaddr + CONFIG_0);
454     else
455         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
456
457     /* Power On chip and select bank 0 */
458     if (cardtype == MBH10302)
459         outb(BANK_0, ioaddr + CONFIG_1);
460     else
461         outb(BANK_0U, ioaddr + CONFIG_1);
462     
463     /* Set hardware address */
464     switch (cardtype) {
465     case MBH10304:
466     case TDK:
467     case LA501:
468     case CONTEC:
469     case NEC:
470     case KME:
471         tuple.DesiredTuple = CISTPL_FUNCE;
472         tuple.TupleOffset = 0;
473         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
474         tuple.TupleOffset = 0;
475         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
476         if (cardtype == MBH10304) {
477             /* MBH10304's CIS_FUNCE is corrupted */
478             node_id = &(tuple.TupleData[5]);
479             card_name = "FMV-J182";
480         } else {
481             while (tuple.TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID ) {
482                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
483                 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
484             }
485             node_id = &(tuple.TupleData[2]);
486             if( cardtype == TDK ) {
487                 card_name = "TDK LAK-CD021";
488             } else if( cardtype == LA501 ) {
489                 card_name = "LA501";
490             } else if( cardtype == NEC ) {
491                 card_name = "PK-UG-J001";
492             } else if( cardtype == KME ) {
493                 card_name = "Panasonic";
494             } else {
495                 card_name = "C-NET(PC)C";
496             }
497         }
498         /* Read MACID from CIS */
499         for (i = 0; i < 6; i++)
500             dev->dev_addr[i] = node_id[i];
501         break;
502     case UNGERMANN:
503         /* Read MACID from register */
504         for (i = 0; i < 6; i++) 
505             dev->dev_addr[i] = inb(ioaddr + UNGERMANN_MAC_ID + i);
506         card_name = "Access/CARD";
507         break;
508     case XXX10304:
509         /* Read MACID from Buggy CIS */
510         if (fmvj18x_get_hwinfo(link, tuple.TupleData) == -1) {
511             printk(KERN_NOTICE "fmvj18x_cs: unable to read hardware net address.\n");
512             goto failed;
513         }
514         for (i = 0 ; i < 6; i++) {
515             dev->dev_addr[i] = tuple.TupleData[i];
516         }
517         card_name = "FMV-J182";
518         break;
519     case MBH10302:
520     default:
521         /* Read MACID from register */
522         for (i = 0; i < 6; i++) 
523             dev->dev_addr[i] = inb(ioaddr + MAC_ID + i);
524         card_name = "FMV-J181";
525         break;
526     }
527
528     lp->cardtype = cardtype;
529     link->dev_node = &lp->node;
530     SET_NETDEV_DEV(dev, &handle_to_dev(link));
531
532     if (register_netdev(dev) != 0) {
533         printk(KERN_NOTICE "fmvj18x_cs: register_netdev() failed\n");
534         link->dev_node = NULL;
535         goto failed;
536     }
537
538     strcpy(lp->node.dev_name, dev->name);
539
540     /* print current configuration */
541     printk(KERN_INFO "%s: %s, sram %s, port %#3lx, irq %d, "
542            "hw_addr %s\n",
543            dev->name, card_name, sram_config == 0 ? "4K TX*2" : "8K TX*2", 
544            dev->base_addr, dev->irq, print_mac(mac, dev->dev_addr));
545
546     return 0;
547     
548 cs_failed:
549     /* All Card Services errors end up here */
550     cs_error(link, last_fn, last_ret);
551 failed:
552     fmvj18x_release(link);
553     return -ENODEV;
554 } /* fmvj18x_config */
555 /*====================================================================*/
556
557 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
558 {
559     win_req_t req;
560     memreq_t mem;
561     u_char __iomem *base;
562     int i, j;
563
564     /* Allocate a small memory window */
565     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
566     req.Base = 0; req.Size = 0;
567     req.AccessSpeed = 0;
568     i = pcmcia_request_window(&link, &req, &link->win);
569     if (i != 0) {
570         cs_error(link, RequestWindow, i);
571         return -1;
572     }
573
574     base = ioremap(req.Base, req.Size);
575     mem.Page = 0;
576     mem.CardOffset = 0;
577     pcmcia_map_mem_page(link->win, &mem);
578
579     /*
580      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
581      *  22 0d xx xx xx 04 06 yy yy yy yy yy yy ff
582      *  'xx' is garbage.
583      *  'yy' is MAC address.
584     */ 
585     for (i = 0; i < 0x200; i++) {
586         if (readb(base+i*2) == 0x22) {  
587             if (readb(base+(i-1)*2) == 0xff
588              && readb(base+(i+5)*2) == 0x04
589              && readb(base+(i+6)*2) == 0x06
590              && readb(base+(i+13)*2) == 0xff) 
591                 break;
592         }
593     }
594
595     if (i != 0x200) {
596         for (j = 0 ; j < 6; j++,i++) {
597             node_id[j] = readb(base+(i+7)*2);
598         }
599     }
600
601     iounmap(base);
602     j = pcmcia_release_window(link->win);
603     if (j != 0)
604         cs_error(link, ReleaseWindow, j);
605     return (i != 0x200) ? 0 : -1;
606
607 } /* fmvj18x_get_hwinfo */
608 /*====================================================================*/
609
610 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
611 {
612     win_req_t req;
613     memreq_t mem;
614     u_char __iomem *base;
615     int i, j;
616     struct net_device *dev = link->priv;
617     unsigned int ioaddr;
618
619     /* Allocate a small memory window */
620     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
621     req.Base = 0; req.Size = 0;
622     req.AccessSpeed = 0;
623     i = pcmcia_request_window(&link, &req, &link->win);
624     if (i != 0) {
625         cs_error(link, RequestWindow, i);
626         return -1;
627     }
628
629     base = ioremap(req.Base, req.Size);
630     mem.Page = 0;
631     mem.CardOffset = 0;
632     pcmcia_map_mem_page(link->win, &mem);
633
634     ioaddr = dev->base_addr;
635     writeb(0x47, base+0x800);   /* Config Option Register of LAN */
636     writeb(0x0, base+0x802);    /* Config and Status Register */
637
638     writeb(ioaddr & 0xff, base+0x80a);          /* I/O Base(Low) of LAN */
639     writeb((ioaddr >> 8) & 0xff, base+0x80c);   /* I/O Base(High) of LAN */
640    
641     writeb(0x45, base+0x820);   /* Config Option Register of Modem */
642     writeb(0x8, base+0x822);    /* Config and Status Register */
643
644     iounmap(base);
645     j = pcmcia_release_window(link->win);
646     if (j != 0)
647         cs_error(link, ReleaseWindow, j);
648     return 0;
649
650 }
651 /*====================================================================*/
652
653 static void fmvj18x_release(struct pcmcia_device *link)
654 {
655         DEBUG(0, "fmvj18x_release(0x%p)\n", link);
656         pcmcia_disable_device(link);
657 }
658
659 static int fmvj18x_suspend(struct pcmcia_device *link)
660 {
661         struct net_device *dev = link->priv;
662
663         if (link->open)
664                 netif_device_detach(dev);
665
666         return 0;
667 }
668
669 static int fmvj18x_resume(struct pcmcia_device *link)
670 {
671         struct net_device *dev = link->priv;
672
673         if (link->open) {
674                 fjn_reset(dev);
675                 netif_device_attach(dev);
676         }
677
678         return 0;
679 }
680
681 /*====================================================================*/
682
683 static struct pcmcia_device_id fmvj18x_ids[] = {
684         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
685         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
686         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
687         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
688         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
689         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
690         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
691         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
692         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
693         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
694         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
695         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
696         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
697         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
698         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
699         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
700         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
701         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
702         PCMCIA_PFC_DEVICE_PROD_ID12(0, "NEC", "PK-UG-J001" ,0x18df0ba0 ,0x831b1064),
703         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
704         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
705         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x0a05),
706         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0032, 0x1101),
707         PCMCIA_DEVICE_NULL,
708 };
709 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
710
711 static struct pcmcia_driver fmvj18x_cs_driver = {
712         .owner          = THIS_MODULE,
713         .drv            = {
714                 .name   = "fmvj18x_cs",
715         },
716         .probe          = fmvj18x_probe,
717         .remove         = fmvj18x_detach,
718         .id_table       = fmvj18x_ids,
719         .suspend        = fmvj18x_suspend,
720         .resume         = fmvj18x_resume,
721 };
722
723 static int __init init_fmvj18x_cs(void)
724 {
725         return pcmcia_register_driver(&fmvj18x_cs_driver);
726 }
727
728 static void __exit exit_fmvj18x_cs(void)
729 {
730         pcmcia_unregister_driver(&fmvj18x_cs_driver);
731 }
732
733 module_init(init_fmvj18x_cs);
734 module_exit(exit_fmvj18x_cs);
735
736 /*====================================================================*/
737
738 static irqreturn_t fjn_interrupt(int dummy, void *dev_id)
739 {
740     struct net_device *dev = dev_id;
741     local_info_t *lp = netdev_priv(dev);
742     unsigned int ioaddr;
743     unsigned short tx_stat, rx_stat;
744
745     ioaddr = dev->base_addr;
746
747     /* avoid multiple interrupts */
748     outw(0x0000, ioaddr + TX_INTR);
749
750     /* wait for a while */
751     udelay(1);
752
753     /* get status */
754     tx_stat = inb(ioaddr + TX_STATUS);
755     rx_stat = inb(ioaddr + RX_STATUS);
756
757     /* clear status */
758     outb(tx_stat, ioaddr + TX_STATUS);
759     outb(rx_stat, ioaddr + RX_STATUS);
760     
761     DEBUG(4, "%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
762     DEBUG(4, "               tx_status %02x.\n", tx_stat);
763     
764     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
765         /* there is packet(s) in rx buffer */
766         fjn_rx(dev);
767     }
768     if (tx_stat & F_TMT_RDY) {
769         lp->stats.tx_packets += lp->sent ;
770         lp->sent = 0 ;
771         if (lp->tx_queue) {
772             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
773             lp->sent = lp->tx_queue ;
774             lp->tx_queue = 0;
775             lp->tx_queue_len = 0;
776             dev->trans_start = jiffies;
777         } else {
778             lp->tx_started = 0;
779         }
780         netif_wake_queue(dev);
781     }
782     DEBUG(4, "%s: exiting interrupt,\n", dev->name);
783     DEBUG(4, "    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
784
785     outb(D_TX_INTR, ioaddr + TX_INTR);
786     outb(D_RX_INTR, ioaddr + RX_INTR);
787     return IRQ_HANDLED;
788
789 } /* fjn_interrupt */
790
791 /*====================================================================*/
792
793 static void fjn_tx_timeout(struct net_device *dev)
794 {
795     struct local_info_t *lp = netdev_priv(dev);
796     unsigned int ioaddr = dev->base_addr;
797
798     printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?\n",
799            dev->name, htons(inw(ioaddr + TX_STATUS)),
800            inb(ioaddr + TX_STATUS) & F_TMT_RDY
801            ? "IRQ conflict" : "network cable problem");
802     printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
803            "%04x %04x %04x %04x %04x.\n",
804            dev->name, htons(inw(ioaddr + 0)),
805            htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
806            htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
807            htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
808            htons(inw(ioaddr +14)));
809     lp->stats.tx_errors++;
810     /* ToDo: We should try to restart the adaptor... */
811     local_irq_disable();
812     fjn_reset(dev);
813
814     lp->tx_started = 0;
815     lp->tx_queue = 0;
816     lp->tx_queue_len = 0;
817     lp->sent = 0;
818     lp->open_time = jiffies;
819     local_irq_enable();
820     netif_wake_queue(dev);
821 }
822
823 static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev)
824 {
825     struct local_info_t *lp = netdev_priv(dev);
826     unsigned int ioaddr = dev->base_addr;
827     short length = skb->len;
828     
829     if (length < ETH_ZLEN)
830     {
831         if (skb_padto(skb, ETH_ZLEN))
832                 return 0;
833         length = ETH_ZLEN;
834     }
835
836     netif_stop_queue(dev);
837
838     {
839         unsigned char *buf = skb->data;
840
841         if (length > ETH_FRAME_LEN) {
842             printk(KERN_NOTICE "%s: Attempting to send a large packet"
843                    " (%d bytes).\n", dev->name, length);
844             return 1;
845         }
846
847         DEBUG(4, "%s: Transmitting a packet of length %lu.\n",
848               dev->name, (unsigned long)skb->len);
849         lp->stats.tx_bytes += skb->len;
850
851         /* Disable both interrupts. */
852         outw(0x0000, ioaddr + TX_INTR);
853
854         /* wait for a while */
855         udelay(1);
856
857         outw(length, ioaddr + DATAPORT);
858         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
859
860         lp->tx_queue++;
861         lp->tx_queue_len += ((length+3) & ~1);
862
863         if (lp->tx_started == 0) {
864             /* If the Tx is idle, always trigger a transmit. */
865             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
866             lp->sent = lp->tx_queue ;
867             lp->tx_queue = 0;
868             lp->tx_queue_len = 0;
869             dev->trans_start = jiffies;
870             lp->tx_started = 1;
871             netif_start_queue(dev);
872         } else {
873             if( sram_config == 0 ) {
874                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
875                     /* Yes, there is room for one more packet. */
876                     netif_start_queue(dev);
877             } else {
878                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) && 
879                                                 lp->tx_queue < 127 )
880                     /* Yes, there is room for one more packet. */
881                     netif_start_queue(dev);
882             }
883         }
884
885         /* Re-enable interrupts */
886         outb(D_TX_INTR, ioaddr + TX_INTR);
887         outb(D_RX_INTR, ioaddr + RX_INTR);
888     }
889     dev_kfree_skb (skb);
890
891     return 0;
892 } /* fjn_start_xmit */
893
894 /*====================================================================*/
895
896 static void fjn_reset(struct net_device *dev)
897 {
898     struct local_info_t *lp = netdev_priv(dev);
899     unsigned int ioaddr = dev->base_addr;
900     int i;
901
902     DEBUG(4, "fjn_reset(%s) called.\n",dev->name);
903
904     /* Reset controller */
905     if( sram_config == 0 ) 
906         outb(CONFIG0_RST, ioaddr + CONFIG_0);
907     else
908         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
909
910     /* Power On chip and select bank 0 */
911     if (lp->cardtype == MBH10302)
912         outb(BANK_0, ioaddr + CONFIG_1);
913     else
914         outb(BANK_0U, ioaddr + CONFIG_1);
915
916     /* Set Tx modes */
917     outb(D_TX_MODE, ioaddr + TX_MODE);
918     /* set Rx modes */
919     outb(ID_MATCHED, ioaddr + RX_MODE);
920
921     /* Set hardware address */
922     for (i = 0; i < 6; i++) 
923         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
924
925     /* (re)initialize the multicast table */
926     set_rx_mode(dev);
927
928     /* Switch to bank 2 (runtime mode) */
929     if (lp->cardtype == MBH10302)
930         outb(BANK_2, ioaddr + CONFIG_1);
931     else
932         outb(BANK_2U, ioaddr + CONFIG_1);
933
934     /* set 16col ctrl bits */
935     if( lp->cardtype == TDK || lp->cardtype == CONTEC) 
936         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
937     else
938         outb(AUTO_MODE, ioaddr + COL_CTRL);
939
940     /* clear Reserved Regs */
941     outb(0x00, ioaddr + BMPR12);
942     outb(0x00, ioaddr + BMPR13);
943
944     /* reset Skip packet reg. */
945     outb(0x01, ioaddr + RX_SKIP);
946
947     /* Enable Tx and Rx */
948     if( sram_config == 0 )
949         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
950     else
951         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
952
953     /* Init receive pointer ? */
954     inw(ioaddr + DATAPORT);
955     inw(ioaddr + DATAPORT);
956
957     /* Clear all status */
958     outb(0xff, ioaddr + TX_STATUS);
959     outb(0xff, ioaddr + RX_STATUS);
960
961     if (lp->cardtype == MBH10302)
962         outb(INTR_OFF, ioaddr + LAN_CTRL);
963
964     /* Turn on Rx interrupts */
965     outb(D_TX_INTR, ioaddr + TX_INTR);
966     outb(D_RX_INTR, ioaddr + RX_INTR);
967
968     /* Turn on interrupts from LAN card controller */
969     if (lp->cardtype == MBH10302)
970         outb(INTR_ON, ioaddr + LAN_CTRL);
971 } /* fjn_reset */
972
973 /*====================================================================*/
974
975 static void fjn_rx(struct net_device *dev)
976 {
977     struct local_info_t *lp = netdev_priv(dev);
978     unsigned int ioaddr = dev->base_addr;
979     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
980
981     DEBUG(4, "%s: in rx_packet(), rx_status %02x.\n",
982           dev->name, inb(ioaddr + RX_STATUS));
983
984     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
985         u_short status = inw(ioaddr + DATAPORT);
986
987         DEBUG(4, "%s: Rxing packet mode %02x status %04x.\n",
988               dev->name, inb(ioaddr + RX_MODE), status);
989 #ifndef final_version
990         if (status == 0) {
991             outb(F_SKP_PKT, ioaddr + RX_SKIP);
992             break;
993         }
994 #endif
995         if ((status & 0xF0) != 0x20) {  /* There was an error. */
996             lp->stats.rx_errors++;
997             if (status & F_LEN_ERR) lp->stats.rx_length_errors++;
998             if (status & F_ALG_ERR) lp->stats.rx_frame_errors++;
999             if (status & F_CRC_ERR) lp->stats.rx_crc_errors++;
1000             if (status & F_OVR_FLO) lp->stats.rx_over_errors++;
1001         } else {
1002             u_short pkt_len = inw(ioaddr + DATAPORT);
1003             /* Malloc up new buffer. */
1004             struct sk_buff *skb;
1005
1006             if (pkt_len > 1550) {
1007                 printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
1008                        "large packet, size %d.\n", dev->name, pkt_len);
1009                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1010                 lp->stats.rx_errors++;
1011                 break;
1012             }
1013             skb = dev_alloc_skb(pkt_len+2);
1014             if (skb == NULL) {
1015                 printk(KERN_NOTICE "%s: Memory squeeze, dropping "
1016                        "packet (len %d).\n", dev->name, pkt_len);
1017                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1018                 lp->stats.rx_dropped++;
1019                 break;
1020             }
1021
1022             skb_reserve(skb, 2);
1023             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1024                  (pkt_len + 1) >> 1);
1025             skb->protocol = eth_type_trans(skb, dev);
1026
1027 #ifdef PCMCIA_DEBUG
1028             if (pc_debug > 5) {
1029                 int i;
1030                 printk(KERN_DEBUG "%s: Rxed packet of length %d: ",
1031                        dev->name, pkt_len);
1032                 for (i = 0; i < 14; i++)
1033                     printk(" %02x", skb->data[i]);
1034                 printk(".\n");
1035             }
1036 #endif
1037
1038             netif_rx(skb);
1039             dev->last_rx = jiffies;
1040             lp->stats.rx_packets++;
1041             lp->stats.rx_bytes += pkt_len;
1042         }
1043         if (--boguscount <= 0)
1044             break;
1045     }
1046
1047     /* If any worth-while packets have been received, dev_rint()
1048            has done a netif_wake_queue() for us and will work on them
1049            when we get to the bottom-half routine. */
1050 /*
1051     if (lp->cardtype != TDK) {
1052         int i;
1053         for (i = 0; i < 20; i++) {
1054             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1055                 break;
1056             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1057             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1058         }
1059
1060         if (i > 0)
1061             DEBUG(5, "%s: Exint Rx packet with mode %02x after "
1062                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1063     }
1064 */
1065
1066     return;
1067 } /* fjn_rx */
1068
1069 /*====================================================================*/
1070
1071 static void netdev_get_drvinfo(struct net_device *dev,
1072                                struct ethtool_drvinfo *info)
1073 {
1074         strcpy(info->driver, DRV_NAME);
1075         strcpy(info->version, DRV_VERSION);
1076         sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1077 }
1078
1079 #ifdef PCMCIA_DEBUG
1080 static u32 netdev_get_msglevel(struct net_device *dev)
1081 {
1082         return pc_debug;
1083 }
1084
1085 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1086 {
1087         pc_debug = level;
1088 }
1089 #endif /* PCMCIA_DEBUG */
1090
1091 static const struct ethtool_ops netdev_ethtool_ops = {
1092         .get_drvinfo            = netdev_get_drvinfo,
1093 #ifdef PCMCIA_DEBUG
1094         .get_msglevel           = netdev_get_msglevel,
1095         .set_msglevel           = netdev_set_msglevel,
1096 #endif /* PCMCIA_DEBUG */
1097 };
1098
1099 static int fjn_config(struct net_device *dev, struct ifmap *map){
1100     return 0;
1101 }
1102
1103 static int fjn_open(struct net_device *dev)
1104 {
1105     struct local_info_t *lp = netdev_priv(dev);
1106     struct pcmcia_device *link = lp->p_dev;
1107
1108     DEBUG(4, "fjn_open('%s').\n", dev->name);
1109
1110     if (!pcmcia_dev_present(link))
1111         return -ENODEV;
1112     
1113     link->open++;
1114     
1115     fjn_reset(dev);
1116     
1117     lp->tx_started = 0;
1118     lp->tx_queue = 0;
1119     lp->tx_queue_len = 0;
1120     lp->open_time = jiffies;
1121     netif_start_queue(dev);
1122     
1123     return 0;
1124 } /* fjn_open */
1125
1126 /*====================================================================*/
1127
1128 static int fjn_close(struct net_device *dev)
1129 {
1130     struct local_info_t *lp = netdev_priv(dev);
1131     struct pcmcia_device *link = lp->p_dev;
1132     unsigned int ioaddr = dev->base_addr;
1133
1134     DEBUG(4, "fjn_close('%s').\n", dev->name);
1135
1136     lp->open_time = 0;
1137     netif_stop_queue(dev);
1138
1139     /* Set configuration register 0 to disable Tx and Rx. */
1140     if( sram_config == 0 ) 
1141         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1142     else
1143         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1144
1145     /* Update the statistics -- ToDo. */
1146
1147     /* Power-down the chip.  Green, green, green! */
1148     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1149
1150     /* Set the ethernet adaptor disable IRQ */
1151     if (lp->cardtype == MBH10302)
1152         outb(INTR_OFF, ioaddr + LAN_CTRL);
1153
1154     link->open--;
1155
1156     return 0;
1157 } /* fjn_close */
1158
1159 /*====================================================================*/
1160
1161 static struct net_device_stats *fjn_get_stats(struct net_device *dev)
1162 {
1163     local_info_t *lp = netdev_priv(dev);
1164     return &lp->stats;
1165 } /* fjn_get_stats */
1166
1167 /*====================================================================*/
1168
1169 /*
1170   Set the multicast/promiscuous mode for this adaptor.
1171 */
1172
1173 static void set_rx_mode(struct net_device *dev)
1174 {
1175     unsigned int ioaddr = dev->base_addr;
1176     u_char mc_filter[8];                 /* Multicast hash filter */
1177     u_long flags;
1178     int i;
1179     
1180     int saved_bank;
1181     int saved_config_0 = inb(ioaddr + CONFIG_0);
1182      
1183     local_irq_save(flags); 
1184
1185     /* Disable Tx and Rx */
1186     if (sram_config == 0) 
1187         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1188     else
1189         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1190
1191     if (dev->flags & IFF_PROMISC) {
1192         memset(mc_filter, 0xff, sizeof(mc_filter));
1193         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1194     } else if (dev->mc_count > MC_FILTERBREAK
1195                ||  (dev->flags & IFF_ALLMULTI)) {
1196         /* Too many to filter perfectly -- accept all multicasts. */
1197         memset(mc_filter, 0xff, sizeof(mc_filter));
1198         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1199     } else if (dev->mc_count == 0) {
1200         memset(mc_filter, 0x00, sizeof(mc_filter));
1201         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1202     } else {
1203         struct dev_mc_list *mclist;
1204
1205         memset(mc_filter, 0, sizeof(mc_filter));
1206         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1207              i++, mclist = mclist->next) {
1208             unsigned int bit =
1209                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
1210             mc_filter[bit >> 3] |= (1 << (bit & 7));
1211         }
1212         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1213     }
1214
1215     /* Switch to bank 1 and set the multicast table. */
1216     saved_bank = inb(ioaddr + CONFIG_1);
1217     outb(0xe4, ioaddr + CONFIG_1);
1218
1219     for (i = 0; i < 8; i++)
1220         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1221     outb(saved_bank, ioaddr + CONFIG_1);
1222
1223     outb(saved_config_0, ioaddr + CONFIG_0);
1224
1225     local_irq_restore(flags);
1226 }