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