drivers/net/pcmcia/fmvj18x_cs.c

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