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