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