err.no Git - linux-2.6/blob - drivers/net/pcmcia/fmvj18x_cs.c

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