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