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