git.oblomov.eu Git - linux-2.6/blob - drivers/net/pcmcia/fmvj18x_cs.c

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