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