drivers/net/pcmcia/fmvj18x_cs.c

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