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