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