drivers/net/pcmcia/fmvj18x_cs.c

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