git.oblomov.eu Git - linux-2.6/blob - drivers/net/pcmcia/fmvj18x_cs.c

   1 /*======================================================================
   2     fmvj18x_cs.c 2.8 2002/03/23
   3
   4     A fmvj18x (and its compatibles) PCMCIA client driver
   5
   6     Contributed by Shingo Fujimoto, shingo@flab.fujitsu.co.jp
   7
   8     TDK LAK-CD021 and CONTEC C-NET(PC)C support added by
   9     Nobuhiro Katayama, kata-n@po.iijnet.or.jp
  10
  11     The PCMCIA client code is based on code written by David Hinds.
  12     Network code is based on the "FMV-18x driver" by Yutaka TAMIYA
  13     but is actually largely Donald Becker's AT1700 driver, which
  14     carries the following attribution:
  15
  16     Written 1993-94 by Donald Becker.
  17
  18     Copyright 1993 United States Government as represented by the
  19     Director, National Security Agency.
  20
  21     This software may be used and distributed according to the terms
  22     of the GNU General Public License, incorporated herein by reference.
  23
  24     The author may be reached as becker@scyld.com, or C/O
  25     Scyld Computing Corporation
  26     410 Severn Ave., Suite 210
  27     Annapolis MD 21403
  28
  29 ======================================================================*/
  30
  31 #define DRV_NAME        "fmvj18x_cs"
  32 #define DRV_VERSION     "2.8"
  33
  34 #include <linux/module.h>
  35 #include <linux/kernel.h>
  36 #include <linux/init.h>
  37 #include <linux/ptrace.h>
  38 #include <linux/slab.h>
  39 #include <linux/string.h>
  40 #include <linux/timer.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/in.h>
  43 #include <linux/delay.h>
  44 #include <linux/ethtool.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/skbuff.h>
  48 #include <linux/if_arp.h>
  49 #include <linux/ioport.h>
  50 #include <linux/crc32.h>
  51
  52 #include <pcmcia/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 /*====================================================================*/
 717
 718 static int fmvj18x_event(event_t event, int priority,
 719                           event_callback_args_t *args)
 720 {
 721     dev_link_t *link = args->client_data;
 722     struct net_device *dev = link->priv;
 723
 724     DEBUG(1, "fmvj18x_event(0x%06x)\n", event);
 725
 726     switch (event) {
 727     case CS_EVENT_CARD_REMOVAL:
 728         link->state &= ~DEV_PRESENT;
 729         if (link->state & DEV_CONFIG)
 730             netif_device_detach(dev);
 731         break;
 732     case CS_EVENT_CARD_INSERTION:
 733         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 734         fmvj18x_config(link);
 735         break;
 736     case CS_EVENT_PM_SUSPEND:
 737         link->state |= DEV_SUSPEND;
 738         /* Fall through... */
 739     case CS_EVENT_RESET_PHYSICAL:
 740         if (link->state & DEV_CONFIG) {
 741             if (link->open)
 742                 netif_device_detach(dev);
 743             pcmcia_release_configuration(link->handle);
 744         }
 745         break;
 746     case CS_EVENT_PM_RESUME:
 747         link->state &= ~DEV_SUSPEND;
 748         /* Fall through... */
 749     case CS_EVENT_CARD_RESET:
 750         if (link->state & DEV_CONFIG) {
 751             pcmcia_request_configuration(link->handle, &link->conf);
 752             if (link->open) {
 753                 fjn_reset(dev);
 754                 netif_device_attach(dev);
 755             }
 756         }
 757         break;
 758     }
 759     return 0;
 760 } /* fmvj18x_event */
 761
 762 static struct pcmcia_device_id fmvj18x_ids[] = {
 763         PCMCIA_DEVICE_MANF_CARD(0x0004, 0x0004),
 764         PCMCIA_DEVICE_PROD_ID12("EAGLE Technology", "NE200 ETHERNET LAN MBH10302 04", 0x528c88c4, 0x74f91e59),
 765         PCMCIA_DEVICE_PROD_ID12("Eiger Labs,Inc", "EPX-10BT PC Card Ethernet 10BT", 0x53af556e, 0x877f9922),
 766         PCMCIA_DEVICE_PROD_ID12("Eiger labs,Inc.", "EPX-10BT PC Card Ethernet 10BT", 0xf47e6c66, 0x877f9922),
 767         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "LAN Card(FMV-J182)", 0x6ee5a3d8, 0x5baf31db),
 768         PCMCIA_DEVICE_PROD_ID12("FUJITSU", "MBH10308", 0x6ee5a3d8, 0x3f04875e),
 769         PCMCIA_DEVICE_PROD_ID12("FUJITSU TOWA", "LA501", 0xb8451188, 0x12939ba2),
 770         PCMCIA_DEVICE_PROD_ID12("HITACHI", "HT-4840-11", 0xf4f43949, 0x773910f4),
 771         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310B Ver1.0       ", 0x8cef4d3a, 0x075fc7b6),
 772         PCMCIA_DEVICE_PROD_ID12("NextComK.K.", "NC5310 Ver1.0        ", 0x8cef4d3a, 0xbccf43e6),
 773         PCMCIA_DEVICE_PROD_ID12("RATOC System Inc.", "10BASE_T CARD R280", 0x85c10e17, 0xd9413666),
 774         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CD02x", 0x1eae9475, 0x8fa0ee70),
 775         PCMCIA_DEVICE_PROD_ID12("TDK", "LAC-CF010", 0x1eae9475, 0x7683bc9a),
 776         PCMCIA_DEVICE_PROD_ID1("CONTEC Co.,Ltd.", 0x58d8fee2),
 777         PCMCIA_DEVICE_PROD_ID1("PCMCIA LAN MBH10304  ES", 0x2599f454),
 778         PCMCIA_DEVICE_PROD_ID1("PCMCIA MBH10302", 0x8f4005da),
 779         PCMCIA_DEVICE_PROD_ID1("UBKK,V2.0", 0x90888080),
 780         PCMCIA_PFC_DEVICE_PROD_ID12(0, "TDK", "GlobalNetworker 3410/3412", 0x1eae9475, 0xd9a93bed),
 781         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0d0a),
 782         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0105, 0x0e0a),
 783         PCMCIA_DEVICE_NULL,
 784 };
 785 MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
 786
 787 static struct pcmcia_driver fmvj18x_cs_driver = {
 788         .owner          = THIS_MODULE,
 789         .drv            = {
 790                 .name   = "fmvj18x_cs",
 791         },
 792         .attach         = fmvj18x_attach,
 793         .event          = fmvj18x_event,
 794         .detach         = fmvj18x_detach,
 795         .id_table       = fmvj18x_ids,
 796 };
 797
 798 static int __init init_fmvj18x_cs(void)
 799 {
 800         return pcmcia_register_driver(&fmvj18x_cs_driver);
 801 }
 802
 803 static void __exit exit_fmvj18x_cs(void)
 804 {
 805         pcmcia_unregister_driver(&fmvj18x_cs_driver);
 806         BUG_ON(dev_list != NULL);
 807 }
 808
 809 module_init(init_fmvj18x_cs);
 810 module_exit(exit_fmvj18x_cs);
 811
 812 /*====================================================================*/
 813
 814 static irqreturn_t fjn_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 815 {
 816     struct net_device *dev = dev_id;
 817     local_info_t *lp = netdev_priv(dev);
 818     kio_addr_t ioaddr;
 819     unsigned short tx_stat, rx_stat;
 820
 821     if (lp == NULL) {
 822         printk(KERN_NOTICE "fjn_interrupt(): irq %d for "
 823                "unknown device.\n", irq);
 824         return IRQ_NONE;
 825     }
 826     ioaddr = dev->base_addr;
 827
 828     /* avoid multiple interrupts */
 829     outw(0x0000, ioaddr + TX_INTR);
 830
 831     /* wait for a while */
 832     udelay(1);
 833
 834     /* get status */
 835     tx_stat = inb(ioaddr + TX_STATUS);
 836     rx_stat = inb(ioaddr + RX_STATUS);
 837
 838     /* clear status */
 839     outb(tx_stat, ioaddr + TX_STATUS);
 840     outb(rx_stat, ioaddr + RX_STATUS);
 841
 842     DEBUG(4, "%s: interrupt, rx_status %02x.\n", dev->name, rx_stat);
 843     DEBUG(4, "               tx_status %02x.\n", tx_stat);
 844
 845     if (rx_stat || (inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
 846         /* there is packet(s) in rx buffer */
 847         fjn_rx(dev);
 848     }
 849     if (tx_stat & F_TMT_RDY) {
 850         lp->stats.tx_packets += lp->sent ;
 851         lp->sent = 0 ;
 852         if (lp->tx_queue) {
 853             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 854             lp->sent = lp->tx_queue ;
 855             lp->tx_queue = 0;
 856             lp->tx_queue_len = 0;
 857             dev->trans_start = jiffies;
 858         } else {
 859             lp->tx_started = 0;
 860         }
 861         netif_wake_queue(dev);
 862     }
 863     DEBUG(4, "%s: exiting interrupt,\n", dev->name);
 864     DEBUG(4, "    tx_status %02x, rx_status %02x.\n", tx_stat, rx_stat);
 865
 866     outb(D_TX_INTR, ioaddr + TX_INTR);
 867     outb(D_RX_INTR, ioaddr + RX_INTR);
 868     return IRQ_HANDLED;
 869
 870 } /* fjn_interrupt */
 871
 872 /*====================================================================*/
 873
 874 static void fjn_tx_timeout(struct net_device *dev)
 875 {
 876     struct local_info_t *lp = netdev_priv(dev);
 877     kio_addr_t ioaddr = dev->base_addr;
 878
 879     printk(KERN_NOTICE "%s: transmit timed out with status %04x, %s?\n",
 880            dev->name, htons(inw(ioaddr + TX_STATUS)),
 881            inb(ioaddr + TX_STATUS) & F_TMT_RDY
 882            ? "IRQ conflict" : "network cable problem");
 883     printk(KERN_NOTICE "%s: timeout registers: %04x %04x %04x "
 884            "%04x %04x %04x %04x %04x.\n",
 885            dev->name, htons(inw(ioaddr + 0)),
 886            htons(inw(ioaddr + 2)), htons(inw(ioaddr + 4)),
 887            htons(inw(ioaddr + 6)), htons(inw(ioaddr + 8)),
 888            htons(inw(ioaddr +10)), htons(inw(ioaddr +12)),
 889            htons(inw(ioaddr +14)));
 890     lp->stats.tx_errors++;
 891     /* ToDo: We should try to restart the adaptor... */
 892     local_irq_disable();
 893     fjn_reset(dev);
 894
 895     lp->tx_started = 0;
 896     lp->tx_queue = 0;
 897     lp->tx_queue_len = 0;
 898     lp->sent = 0;
 899     lp->open_time = jiffies;
 900     local_irq_enable();
 901     netif_wake_queue(dev);
 902 }
 903
 904 static int fjn_start_xmit(struct sk_buff *skb, struct net_device *dev)
 905 {
 906     struct local_info_t *lp = netdev_priv(dev);
 907     kio_addr_t ioaddr = dev->base_addr;
 908     short length = skb->len;
 909
 910     if (length < ETH_ZLEN)
 911     {
 912         skb = skb_padto(skb, ETH_ZLEN);
 913         if (skb == NULL)
 914                 return 0;
 915         length = ETH_ZLEN;
 916     }
 917
 918     netif_stop_queue(dev);
 919
 920     {
 921         unsigned char *buf = skb->data;
 922
 923         if (length > ETH_FRAME_LEN) {
 924             printk(KERN_NOTICE "%s: Attempting to send a large packet"
 925                    " (%d bytes).\n", dev->name, length);
 926             return 1;
 927         }
 928
 929         DEBUG(4, "%s: Transmitting a packet of length %lu.\n",
 930               dev->name, (unsigned long)skb->len);
 931         lp->stats.tx_bytes += skb->len;
 932
 933         /* Disable both interrupts. */
 934         outw(0x0000, ioaddr + TX_INTR);
 935
 936         /* wait for a while */
 937         udelay(1);
 938
 939         outw(length, ioaddr + DATAPORT);
 940         outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 941
 942         lp->tx_queue++;
 943         lp->tx_queue_len += ((length+3) & ~1);
 944
 945         if (lp->tx_started == 0) {
 946             /* If the Tx is idle, always trigger a transmit. */
 947             outb(DO_TX | lp->tx_queue, ioaddr + TX_START);
 948             lp->sent = lp->tx_queue ;
 949             lp->tx_queue = 0;
 950             lp->tx_queue_len = 0;
 951             dev->trans_start = jiffies;
 952             lp->tx_started = 1;
 953             netif_start_queue(dev);
 954         } else {
 955             if( sram_config == 0 ) {
 956                 if (lp->tx_queue_len < (4096 - (ETH_FRAME_LEN +2)) )
 957                     /* Yes, there is room for one more packet. */
 958                     netif_start_queue(dev);
 959             } else {
 960                 if (lp->tx_queue_len < (8192 - (ETH_FRAME_LEN +2)) &&
 961                                                 lp->tx_queue < 127 )
 962                     /* Yes, there is room for one more packet. */
 963                     netif_start_queue(dev);
 964             }
 965         }
 966
 967         /* Re-enable interrupts */
 968         outb(D_TX_INTR, ioaddr + TX_INTR);
 969         outb(D_RX_INTR, ioaddr + RX_INTR);
 970     }
 971     dev_kfree_skb (skb);
 972
 973     return 0;
 974 } /* fjn_start_xmit */
 975
 976 /*====================================================================*/
 977
 978 static void fjn_reset(struct net_device *dev)
 979 {
 980     struct local_info_t *lp = netdev_priv(dev);
 981     kio_addr_t ioaddr = dev->base_addr;
 982     int i;
 983
 984     DEBUG(4, "fjn_reset(%s) called.\n",dev->name);
 985
 986     /* Reset controller */
 987     if( sram_config == 0 )
 988         outb(CONFIG0_RST, ioaddr + CONFIG_0);
 989     else
 990         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
 991
 992     /* Power On chip and select bank 0 */
 993     if (lp->cardtype == MBH10302)
 994         outb(BANK_0, ioaddr + CONFIG_1);
 995     else
 996         outb(BANK_0U, ioaddr + CONFIG_1);
 997
 998     /* Set Tx modes */
 999     outb(D_TX_MODE, ioaddr + TX_MODE);
1000     /* set Rx modes */
1001     outb(ID_MATCHED, ioaddr + RX_MODE);
1002
1003     /* Set hardware address */
1004     for (i = 0; i < 6; i++)
1005         outb(dev->dev_addr[i], ioaddr + NODE_ID + i);
1006
1007     /* (re)initialize the multicast table */
1008     set_rx_mode(dev);
1009
1010     /* Switch to bank 2 (runtime mode) */
1011     if (lp->cardtype == MBH10302)
1012         outb(BANK_2, ioaddr + CONFIG_1);
1013     else
1014         outb(BANK_2U, ioaddr + CONFIG_1);
1015
1016     /* set 16col ctrl bits */
1017     if( lp->cardtype == TDK || lp->cardtype == CONTEC)
1018         outb(TDK_AUTO_MODE, ioaddr + COL_CTRL);
1019     else
1020         outb(AUTO_MODE, ioaddr + COL_CTRL);
1021
1022     /* clear Reserved Regs */
1023     outb(0x00, ioaddr + BMPR12);
1024     outb(0x00, ioaddr + BMPR13);
1025
1026     /* reset Skip packet reg. */
1027     outb(0x01, ioaddr + RX_SKIP);
1028
1029     /* Enable Tx and Rx */
1030     if( sram_config == 0 )
1031         outb(CONFIG0_DFL, ioaddr + CONFIG_0);
1032     else
1033         outb(CONFIG0_DFL_1, ioaddr + CONFIG_0);
1034
1035     /* Init receive pointer ? */
1036     inw(ioaddr + DATAPORT);
1037     inw(ioaddr + DATAPORT);
1038
1039     /* Clear all status */
1040     outb(0xff, ioaddr + TX_STATUS);
1041     outb(0xff, ioaddr + RX_STATUS);
1042
1043     if (lp->cardtype == MBH10302)
1044         outb(INTR_OFF, ioaddr + LAN_CTRL);
1045
1046     /* Turn on Rx interrupts */
1047     outb(D_TX_INTR, ioaddr + TX_INTR);
1048     outb(D_RX_INTR, ioaddr + RX_INTR);
1049
1050     /* Turn on interrupts from LAN card controller */
1051     if (lp->cardtype == MBH10302)
1052         outb(INTR_ON, ioaddr + LAN_CTRL);
1053 } /* fjn_reset */
1054
1055 /*====================================================================*/
1056
1057 static void fjn_rx(struct net_device *dev)
1058 {
1059     struct local_info_t *lp = netdev_priv(dev);
1060     kio_addr_t ioaddr = dev->base_addr;
1061     int boguscount = 10;        /* 5 -> 10: by agy 19940922 */
1062
1063     DEBUG(4, "%s: in rx_packet(), rx_status %02x.\n",
1064           dev->name, inb(ioaddr + RX_STATUS));
1065
1066     while ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == 0) {
1067         u_short status = inw(ioaddr + DATAPORT);
1068
1069         DEBUG(4, "%s: Rxing packet mode %02x status %04x.\n",
1070               dev->name, inb(ioaddr + RX_MODE), status);
1071 #ifndef final_version
1072         if (status == 0) {
1073             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1074             break;
1075         }
1076 #endif
1077         if ((status & 0xF0) != 0x20) {  /* There was an error. */
1078             lp->stats.rx_errors++;
1079             if (status & F_LEN_ERR) lp->stats.rx_length_errors++;
1080             if (status & F_ALG_ERR) lp->stats.rx_frame_errors++;
1081             if (status & F_CRC_ERR) lp->stats.rx_crc_errors++;
1082             if (status & F_OVR_FLO) lp->stats.rx_over_errors++;
1083         } else {
1084             u_short pkt_len = inw(ioaddr + DATAPORT);
1085             /* Malloc up new buffer. */
1086             struct sk_buff *skb;
1087
1088             if (pkt_len > 1550) {
1089                 printk(KERN_NOTICE "%s: The FMV-18x claimed a very "
1090                        "large packet, size %d.\n", dev->name, pkt_len);
1091                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1092                 lp->stats.rx_errors++;
1093                 break;
1094             }
1095             skb = dev_alloc_skb(pkt_len+2);
1096             if (skb == NULL) {
1097                 printk(KERN_NOTICE "%s: Memory squeeze, dropping "
1098                        "packet (len %d).\n", dev->name, pkt_len);
1099                 outb(F_SKP_PKT, ioaddr + RX_SKIP);
1100                 lp->stats.rx_dropped++;
1101                 break;
1102             }
1103             skb->dev = dev;
1104
1105             skb_reserve(skb, 2);
1106             insw(ioaddr + DATAPORT, skb_put(skb, pkt_len),
1107                  (pkt_len + 1) >> 1);
1108             skb->protocol = eth_type_trans(skb, dev);
1109
1110 #ifdef PCMCIA_DEBUG
1111             if (pc_debug > 5) {
1112                 int i;
1113                 printk(KERN_DEBUG "%s: Rxed packet of length %d: ",
1114                        dev->name, pkt_len);
1115                 for (i = 0; i < 14; i++)
1116                     printk(" %02x", skb->data[i]);
1117                 printk(".\n");
1118             }
1119 #endif
1120
1121             netif_rx(skb);
1122             dev->last_rx = jiffies;
1123             lp->stats.rx_packets++;
1124             lp->stats.rx_bytes += pkt_len;
1125         }
1126         if (--boguscount <= 0)
1127             break;
1128     }
1129
1130     /* If any worth-while packets have been received, dev_rint()
1131            has done a netif_wake_queue() for us and will work on them
1132            when we get to the bottom-half routine. */
1133 /*
1134     if (lp->cardtype != TDK) {
1135         int i;
1136         for (i = 0; i < 20; i++) {
1137             if ((inb(ioaddr + RX_MODE) & F_BUF_EMP) == F_BUF_EMP)
1138                 break;
1139             (void)inw(ioaddr + DATAPORT);  /+ dummy status read +/
1140             outb(F_SKP_PKT, ioaddr + RX_SKIP);
1141         }
1142
1143         if (i > 0)
1144             DEBUG(5, "%s: Exint Rx packet with mode %02x after "
1145                   "%d ticks.\n", dev->name, inb(ioaddr + RX_MODE), i);
1146     }
1147 */
1148
1149     return;
1150 } /* fjn_rx */
1151
1152 /*====================================================================*/
1153
1154 static void netdev_get_drvinfo(struct net_device *dev,
1155                                struct ethtool_drvinfo *info)
1156 {
1157         strcpy(info->driver, DRV_NAME);
1158         strcpy(info->version, DRV_VERSION);
1159         sprintf(info->bus_info, "PCMCIA 0x%lx", dev->base_addr);
1160 }
1161
1162 #ifdef PCMCIA_DEBUG
1163 static u32 netdev_get_msglevel(struct net_device *dev)
1164 {
1165         return pc_debug;
1166 }
1167
1168 static void netdev_set_msglevel(struct net_device *dev, u32 level)
1169 {
1170         pc_debug = level;
1171 }
1172 #endif /* PCMCIA_DEBUG */
1173
1174 static struct ethtool_ops netdev_ethtool_ops = {
1175         .get_drvinfo            = netdev_get_drvinfo,
1176 #ifdef PCMCIA_DEBUG
1177         .get_msglevel           = netdev_get_msglevel,
1178         .set_msglevel           = netdev_set_msglevel,
1179 #endif /* PCMCIA_DEBUG */
1180 };
1181
1182 static int fjn_config(struct net_device *dev, struct ifmap *map){
1183     return 0;
1184 }
1185
1186 static int fjn_open(struct net_device *dev)
1187 {
1188     struct local_info_t *lp = netdev_priv(dev);
1189     dev_link_t *link = &lp->link;
1190
1191     DEBUG(4, "fjn_open('%s').\n", dev->name);
1192
1193     if (!DEV_OK(link))
1194         return -ENODEV;
1195
1196     link->open++;
1197
1198     fjn_reset(dev);
1199
1200     lp->tx_started = 0;
1201     lp->tx_queue = 0;
1202     lp->tx_queue_len = 0;
1203     lp->open_time = jiffies;
1204     netif_start_queue(dev);
1205
1206     return 0;
1207 } /* fjn_open */
1208
1209 /*====================================================================*/
1210
1211 static int fjn_close(struct net_device *dev)
1212 {
1213     struct local_info_t *lp = netdev_priv(dev);
1214     dev_link_t *link = &lp->link;
1215     kio_addr_t ioaddr = dev->base_addr;
1216
1217     DEBUG(4, "fjn_close('%s').\n", dev->name);
1218
1219     lp->open_time = 0;
1220     netif_stop_queue(dev);
1221
1222     /* Set configuration register 0 to disable Tx and Rx. */
1223     if( sram_config == 0 )
1224         outb(CONFIG0_RST ,ioaddr + CONFIG_0);
1225     else
1226         outb(CONFIG0_RST_1 ,ioaddr + CONFIG_0);
1227
1228     /* Update the statistics -- ToDo. */
1229
1230     /* Power-down the chip.  Green, green, green! */
1231     outb(CHIP_OFF ,ioaddr + CONFIG_1);
1232
1233     /* Set the ethernet adaptor disable IRQ */
1234     if (lp->cardtype == MBH10302)
1235         outb(INTR_OFF, ioaddr + LAN_CTRL);
1236
1237     link->open--;
1238
1239     return 0;
1240 } /* fjn_close */
1241
1242 /*====================================================================*/
1243
1244 static struct net_device_stats *fjn_get_stats(struct net_device *dev)
1245 {
1246     local_info_t *lp = netdev_priv(dev);
1247     return &lp->stats;
1248 } /* fjn_get_stats */
1249
1250 /*====================================================================*/
1251
1252 /*
1253   Set the multicast/promiscuous mode for this adaptor.
1254 */
1255
1256 static void set_rx_mode(struct net_device *dev)
1257 {
1258     kio_addr_t ioaddr = dev->base_addr;
1259     u_char mc_filter[8];                 /* Multicast hash filter */
1260     u_long flags;
1261     int i;
1262
1263     int saved_bank;
1264     int saved_config_0 = inb(ioaddr + CONFIG_0);
1265
1266     local_irq_save(flags);
1267
1268     /* Disable Tx and Rx */
1269     if (sram_config == 0)
1270         outb(CONFIG0_RST, ioaddr + CONFIG_0);
1271     else
1272         outb(CONFIG0_RST_1, ioaddr + CONFIG_0);
1273
1274     if (dev->flags & IFF_PROMISC) {
1275         /* Unconditionally log net taps. */
1276         printk("%s: Promiscuous mode enabled.\n", dev->name);
1277         memset(mc_filter, 0xff, sizeof(mc_filter));
1278         outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
1279     } else if (dev->mc_count > MC_FILTERBREAK
1280                ||  (dev->flags & IFF_ALLMULTI)) {
1281         /* Too many to filter perfectly -- accept all multicasts. */
1282         memset(mc_filter, 0xff, sizeof(mc_filter));
1283         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1284     } else if (dev->mc_count == 0) {
1285         memset(mc_filter, 0x00, sizeof(mc_filter));
1286         outb(1, ioaddr + RX_MODE);      /* Ignore almost all multicasts. */
1287     } else {
1288         struct dev_mc_list *mclist;
1289         int i;
1290
1291         memset(mc_filter, 0, sizeof(mc_filter));
1292         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1293              i++, mclist = mclist->next) {
1294             unsigned int bit =
1295                 ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 26;
1296             mc_filter[bit >> 3] |= (1 << (bit & 7));
1297         }
1298         outb(2, ioaddr + RX_MODE);      /* Use normal mode. */
1299     }
1300
1301     /* Switch to bank 1 and set the multicast table. */
1302     saved_bank = inb(ioaddr + CONFIG_1);
1303     outb(0xe4, ioaddr + CONFIG_1);
1304
1305     for (i = 0; i < 8; i++)
1306         outb(mc_filter[i], ioaddr + MAR_ADR + i);
1307     outb(saved_bank, ioaddr + CONFIG_1);
1308
1309     outb(saved_config_0, ioaddr + CONFIG_0);
1310
1311     local_irq_restore(flags);
1312 }