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

   1 /*======================================================================
   2
   3     A PCMCIA ethernet driver for SMC91c92-based cards.
   4
   5     This driver supports Megahertz PCMCIA ethernet cards; and
   6     Megahertz, Motorola, Ositech, and Psion Dacom ethernet/modem
   7     multifunction cards.
   8
   9     Copyright (C) 1999 David A. Hinds -- dahinds@users.sourceforge.net
  10
  11     smc91c92_cs.c 1.122 2002/10/25 06:26:39
  12
  13     This driver contains code written by Donald Becker
  14     (becker@scyld.com), Rowan Hughes (x-csrdh@jcu.edu.au),
  15     David Hinds (dahinds@users.sourceforge.net), and Erik Stahlman
  16     (erik@vt.edu).  Donald wrote the SMC 91c92 code using parts of
  17     Erik's SMC 91c94 driver.  Rowan wrote a similar driver, and I've
  18     incorporated some parts of his driver here.  I (Dave) wrote most
  19     of the PCMCIA glue code, and the Ositech support code.  Kelly
  20     Stephens (kstephen@holli.com) added support for the Motorola
  21     Mariner, with help from Allen Brost.
  22
  23     This software may be used and distributed according to the terms of
  24     the GNU General Public License, incorporated herein by reference.
  25
  26 ======================================================================*/
  27
  28 #include <linux/module.h>
  29 #include <linux/kernel.h>
  30 #include <linux/init.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/timer.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/delay.h>
  36 #include <linux/crc32.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/etherdevice.h>
  39 #include <linux/skbuff.h>
  40 #include <linux/if_arp.h>
  41 #include <linux/ioport.h>
  42 #include <linux/ethtool.h>
  43 #include <linux/mii.h>
  44 #include <linux/jiffies.h>
  45
  46 #include <pcmcia/cs_types.h>
  47 #include <pcmcia/cs.h>
  48 #include <pcmcia/cistpl.h>
  49 #include <pcmcia/cisreg.h>
  50 #include <pcmcia/ciscode.h>
  51 #include <pcmcia/ds.h>
  52
  53 #include <asm/io.h>
  54 #include <asm/system.h>
  55 #include <asm/uaccess.h>
  56
  57 /* Ositech Seven of Diamonds firmware */
  58 #include "ositech.h"
  59
  60 /*====================================================================*/
  61
  62 static char *if_names[] = { "auto", "10baseT", "10base2"};
  63
  64 /* Module parameters */
  65
  66 MODULE_DESCRIPTION("SMC 91c92 series PCMCIA ethernet driver");
  67 MODULE_LICENSE("GPL");
  68
  69 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
  70
  71 /*
  72   Transceiver/media type.
  73    0 = auto
  74    1 = 10baseT (and autoselect if #define AUTOSELECT),
  75    2 = AUI/10base2,
  76 */
  77 INT_MODULE_PARM(if_port, 0);
  78
  79 #ifdef PCMCIA_DEBUG
  80 INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
  81 static const char *version =
  82 "smc91c92_cs.c 0.09 1996/8/4 Donald Becker, becker@scyld.com.\n";
  83 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  84 #else
  85 #define DEBUG(n, args...)
  86 #endif
  87
  88 #define DRV_NAME        "smc91c92_cs"
  89 #define DRV_VERSION     "1.122"
  90
  91 /*====================================================================*/
  92
  93 /* Operational parameter that usually are not changed. */
  94
  95 /* Time in jiffies before concluding Tx hung */
  96 #define TX_TIMEOUT              ((400*HZ)/1000)
  97
  98 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  99 #define INTR_WORK               4
 100
 101 /* Times to check the check the chip before concluding that it doesn't
 102    currently have room for another Tx packet. */
 103 #define MEMORY_WAIT_TIME        8
 104
 105 static dev_info_t dev_info = "smc91c92_cs";
 106
 107 struct smc_private {
 108     dev_link_t                  link;
 109     spinlock_t                  lock;
 110     u_short                     manfid;
 111     u_short                     cardid;
 112     struct net_device_stats     stats;
 113     dev_node_t                  node;
 114     struct sk_buff              *saved_skb;
 115     int                         packets_waiting;
 116     void                        __iomem *base;
 117     u_short                     cfg;
 118     struct timer_list           media;
 119     int                         watchdog, tx_err;
 120     u_short                     media_status;
 121     u_short                     fast_poll;
 122     u_short                     link_status;
 123     struct mii_if_info          mii_if;
 124     int                         duplex;
 125     int                         rx_ovrn;
 126 };
 127
 128 struct smc_cfg_mem {
 129     tuple_t tuple;
 130     cisparse_t parse;
 131     u_char buf[255];
 132 };
 133
 134 /* Special definitions for Megahertz multifunction cards */
 135 #define MEGAHERTZ_ISR           0x0380
 136
 137 /* Special function registers for Motorola Mariner */
 138 #define MOT_LAN                 0x0000
 139 #define MOT_UART                0x0020
 140 #define MOT_EEPROM              0x20
 141
 142 #define MOT_NORMAL \
 143 (COR_LEVEL_REQ | COR_FUNC_ENA | COR_ADDR_DECODE | COR_IREQ_ENA)
 144
 145 /* Special function registers for Ositech cards */
 146 #define OSITECH_AUI_CTL         0x0c
 147 #define OSITECH_PWRDOWN         0x0d
 148 #define OSITECH_RESET           0x0e
 149 #define OSITECH_ISR             0x0f
 150 #define OSITECH_AUI_PWR         0x0c
 151 #define OSITECH_RESET_ISR       0x0e
 152
 153 #define OSI_AUI_PWR             0x40
 154 #define OSI_LAN_PWRDOWN         0x02
 155 #define OSI_MODEM_PWRDOWN       0x01
 156 #define OSI_LAN_RESET           0x02
 157 #define OSI_MODEM_RESET         0x01
 158
 159 /* Symbolic constants for the SMC91c9* series chips, from Erik Stahlman. */
 160 #define BANK_SELECT             14              /* Window select register. */
 161 #define SMC_SELECT_BANK(x)  { outw(x, ioaddr + BANK_SELECT); }
 162
 163 /* Bank 0 registers. */
 164 #define TCR             0       /* transmit control register */
 165 #define  TCR_CLEAR      0       /* do NOTHING */
 166 #define  TCR_ENABLE     0x0001  /* if this is 1, we can transmit */
 167 #define  TCR_PAD_EN     0x0080  /* pads short packets to 64 bytes */
 168 #define  TCR_MONCSN     0x0400  /* Monitor Carrier. */
 169 #define  TCR_FDUPLX     0x0800  /* Full duplex mode. */
 170 #define  TCR_NORMAL TCR_ENABLE | TCR_PAD_EN
 171
 172 #define EPH             2       /* Ethernet Protocol Handler report. */
 173 #define  EPH_TX_SUC     0x0001
 174 #define  EPH_SNGLCOL    0x0002
 175 #define  EPH_MULCOL     0x0004
 176 #define  EPH_LTX_MULT   0x0008
 177 #define  EPH_16COL      0x0010
 178 #define  EPH_SQET       0x0020
 179 #define  EPH_LTX_BRD    0x0040
 180 #define  EPH_TX_DEFR    0x0080
 181 #define  EPH_LAT_COL    0x0200
 182 #define  EPH_LOST_CAR   0x0400
 183 #define  EPH_EXC_DEF    0x0800
 184 #define  EPH_CTR_ROL    0x1000
 185 #define  EPH_RX_OVRN    0x2000
 186 #define  EPH_LINK_OK    0x4000
 187 #define  EPH_TX_UNRN    0x8000
 188 #define MEMINFO         8       /* Memory Information Register */
 189 #define MEMCFG          10      /* Memory Configuration Register */
 190
 191 /* Bank 1 registers. */
 192 #define CONFIG                  0
 193 #define  CFG_MII_SELECT         0x8000  /* 91C100 only */
 194 #define  CFG_NO_WAIT            0x1000
 195 #define  CFG_FULL_STEP          0x0400
 196 #define  CFG_SET_SQLCH          0x0200
 197 #define  CFG_AUI_SELECT         0x0100
 198 #define  CFG_16BIT              0x0080
 199 #define  CFG_DIS_LINK           0x0040
 200 #define  CFG_STATIC             0x0030
 201 #define  CFG_IRQ_SEL_1          0x0004
 202 #define  CFG_IRQ_SEL_0          0x0002
 203 #define BASE_ADDR               2
 204 #define ADDR0                   4
 205 #define GENERAL                 10
 206 #define CONTROL                 12
 207 #define  CTL_STORE              0x0001
 208 #define  CTL_RELOAD             0x0002
 209 #define  CTL_EE_SELECT          0x0004
 210 #define  CTL_TE_ENABLE          0x0020
 211 #define  CTL_CR_ENABLE          0x0040
 212 #define  CTL_LE_ENABLE          0x0080
 213 #define  CTL_AUTO_RELEASE       0x0800
 214 #define  CTL_POWERDOWN          0x2000
 215
 216 /* Bank 2 registers. */
 217 #define MMU_CMD         0
 218 #define  MC_ALLOC       0x20    /* or with number of 256 byte packets */
 219 #define  MC_RESET       0x40
 220 #define  MC_RELEASE     0x80    /* remove and release the current rx packet */
 221 #define  MC_FREEPKT     0xA0    /* Release packet in PNR register */
 222 #define  MC_ENQUEUE     0xC0    /* Enqueue the packet for transmit */
 223 #define PNR_ARR         2
 224 #define FIFO_PORTS      4
 225 #define  FP_RXEMPTY     0x8000
 226 #define POINTER         6
 227 #define  PTR_AUTO_INC   0x0040
 228 #define  PTR_READ       0x2000
 229 #define  PTR_AUTOINC    0x4000
 230 #define  PTR_RCV        0x8000
 231 #define DATA_1          8
 232 #define INTERRUPT       12
 233 #define  IM_RCV_INT             0x1
 234 #define  IM_TX_INT              0x2
 235 #define  IM_TX_EMPTY_INT        0x4
 236 #define  IM_ALLOC_INT           0x8
 237 #define  IM_RX_OVRN_INT         0x10
 238 #define  IM_EPH_INT             0x20
 239
 240 #define RCR             4
 241 enum RxCfg { RxAllMulti = 0x0004, RxPromisc = 0x0002,
 242              RxEnable = 0x0100, RxStripCRC = 0x0200};
 243 #define  RCR_SOFTRESET  0x8000  /* resets the chip */
 244 #define  RCR_STRIP_CRC  0x200   /* strips CRC */
 245 #define  RCR_ENABLE     0x100   /* IFF this is set, we can receive packets */
 246 #define  RCR_ALMUL      0x4     /* receive all multicast packets */
 247 #define  RCR_PROMISC    0x2     /* enable promiscuous mode */
 248
 249 /* the normal settings for the RCR register : */
 250 #define  RCR_NORMAL     (RCR_STRIP_CRC | RCR_ENABLE)
 251 #define  RCR_CLEAR      0x0             /* set it to a base state */
 252 #define COUNTER         6
 253
 254 /* BANK 3 -- not the same values as in smc9194! */
 255 #define MULTICAST0      0
 256 #define MULTICAST2      2
 257 #define MULTICAST4      4
 258 #define MULTICAST6      6
 259 #define MGMT            8
 260 #define REVISION        0x0a
 261
 262 /* Transmit status bits. */
 263 #define TS_SUCCESS 0x0001
 264 #define TS_16COL   0x0010
 265 #define TS_LATCOL  0x0200
 266 #define TS_LOSTCAR 0x0400
 267
 268 /* Receive status bits. */
 269 #define RS_ALGNERR      0x8000
 270 #define RS_BADCRC       0x2000
 271 #define RS_ODDFRAME     0x1000
 272 #define RS_TOOLONG      0x0800
 273 #define RS_TOOSHORT     0x0400
 274 #define RS_MULTICAST    0x0001
 275 #define RS_ERRORS       (RS_ALGNERR | RS_BADCRC | RS_TOOLONG | RS_TOOSHORT)
 276
 277 #define set_bits(v, p) outw(inw(p)|(v), (p))
 278 #define mask_bits(v, p) outw(inw(p)&(v), (p))
 279
 280 /*====================================================================*/
 281
 282 static dev_link_t *smc91c92_attach(void);
 283 static void smc91c92_detach(struct pcmcia_device *p_dev);
 284 static void smc91c92_config(dev_link_t *link);
 285 static void smc91c92_release(dev_link_t *link);
 286 static int smc91c92_event(event_t event, int priority,
 287                           event_callback_args_t *args);
 288
 289 static int smc_open(struct net_device *dev);
 290 static int smc_close(struct net_device *dev);
 291 static int smc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 292 static void smc_tx_timeout(struct net_device *dev);
 293 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev);
 294 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 295 static void smc_rx(struct net_device *dev);
 296 static struct net_device_stats *smc_get_stats(struct net_device *dev);
 297 static void set_rx_mode(struct net_device *dev);
 298 static int s9k_config(struct net_device *dev, struct ifmap *map);
 299 static void smc_set_xcvr(struct net_device *dev, int if_port);
 300 static void smc_reset(struct net_device *dev);
 301 static void media_check(u_long arg);
 302 static void mdio_sync(kio_addr_t addr);
 303 static int mdio_read(struct net_device *dev, int phy_id, int loc);
 304 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value);
 305 static int smc_link_ok(struct net_device *dev);
 306 static struct ethtool_ops ethtool_ops;
 307
 308 /*======================================================================
 309
 310   smc91c92_attach() creates an "instance" of the driver, allocating
 311   local data structures for one device.  The device is registered
 312   with Card Services.
 313
 314 ======================================================================*/
 315
 316 static dev_link_t *smc91c92_attach(void)
 317 {
 318     client_reg_t client_reg;
 319     struct smc_private *smc;
 320     dev_link_t *link;
 321     struct net_device *dev;
 322     int ret;
 323
 324     DEBUG(0, "smc91c92_attach()\n");
 325
 326     /* Create new ethernet device */
 327     dev = alloc_etherdev(sizeof(struct smc_private));
 328     if (!dev)
 329         return NULL;
 330     smc = netdev_priv(dev);
 331     link = &smc->link;
 332     link->priv = dev;
 333
 334     spin_lock_init(&smc->lock);
 335     link->io.NumPorts1 = 16;
 336     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 337     link->io.IOAddrLines = 4;
 338     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 339     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 340     link->irq.Handler = &smc_interrupt;
 341     link->irq.Instance = dev;
 342     link->conf.Attributes = CONF_ENABLE_IRQ;
 343     link->conf.Vcc = 50;
 344     link->conf.IntType = INT_MEMORY_AND_IO;
 345
 346     /* The SMC91c92-specific entries in the device structure. */
 347     SET_MODULE_OWNER(dev);
 348     dev->hard_start_xmit = &smc_start_xmit;
 349     dev->get_stats = &smc_get_stats;
 350     dev->set_config = &s9k_config;
 351     dev->set_multicast_list = &set_rx_mode;
 352     dev->open = &smc_open;
 353     dev->stop = &smc_close;
 354     dev->do_ioctl = &smc_ioctl;
 355     SET_ETHTOOL_OPS(dev, &ethtool_ops);
 356 #ifdef HAVE_TX_TIMEOUT
 357     dev->tx_timeout = smc_tx_timeout;
 358     dev->watchdog_timeo = TX_TIMEOUT;
 359 #endif
 360
 361     smc->mii_if.dev = dev;
 362     smc->mii_if.mdio_read = mdio_read;
 363     smc->mii_if.mdio_write = mdio_write;
 364     smc->mii_if.phy_id_mask = 0x1f;
 365     smc->mii_if.reg_num_mask = 0x1f;
 366
 367     /* Register with Card Services */
 368     link->next = NULL;
 369     client_reg.dev_info = &dev_info;
 370     client_reg.Version = 0x0210;
 371     client_reg.event_callback_args.client_data = link;
 372     ret = pcmcia_register_client(&link->handle, &client_reg);
 373     if (ret != 0) {
 374         cs_error(link->handle, RegisterClient, ret);
 375         smc91c92_detach(link->handle);
 376         return NULL;
 377     }
 378
 379     return link;
 380 } /* smc91c92_attach */
 381
 382 /*======================================================================
 383
 384     This deletes a driver "instance".  The device is de-registered
 385     with Card Services.  If it has been released, all local data
 386     structures are freed.  Otherwise, the structures will be freed
 387     when the device is released.
 388
 389 ======================================================================*/
 390
 391 static void smc91c92_detach(struct pcmcia_device *p_dev)
 392 {
 393     dev_link_t *link = dev_to_instance(p_dev);
 394     struct net_device *dev = link->priv;
 395
 396     DEBUG(0, "smc91c92_detach(0x%p)\n", link);
 397
 398     if (link->dev)
 399         unregister_netdev(dev);
 400
 401     if (link->state & DEV_CONFIG)
 402         smc91c92_release(link);
 403
 404     free_netdev(dev);
 405 } /* smc91c92_detach */
 406
 407 /*====================================================================*/
 408
 409 static int cvt_ascii_address(struct net_device *dev, char *s)
 410 {
 411     int i, j, da, c;
 412
 413     if (strlen(s) != 12)
 414         return -1;
 415     for (i = 0; i < 6; i++) {
 416         da = 0;
 417         for (j = 0; j < 2; j++) {
 418             c = *s++;
 419             da <<= 4;
 420             da += ((c >= '0') && (c <= '9')) ?
 421                 (c - '0') : ((c & 0x0f) + 9);
 422         }
 423         dev->dev_addr[i] = da;
 424     }
 425     return 0;
 426 }
 427
 428 /*====================================================================*/
 429
 430 static int first_tuple(client_handle_t handle, tuple_t *tuple,
 431                 cisparse_t *parse)
 432 {
 433         int i;
 434
 435         if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
 436                         (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
 437                 return i;
 438         return pcmcia_parse_tuple(handle, tuple, parse);
 439 }
 440
 441 static int next_tuple(client_handle_t handle, tuple_t *tuple,
 442                 cisparse_t *parse)
 443 {
 444         int i;
 445
 446         if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
 447                         (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
 448                 return i;
 449         return pcmcia_parse_tuple(handle, tuple, parse);
 450 }
 451
 452 /*======================================================================
 453
 454     Configuration stuff for Megahertz cards
 455
 456     mhz_3288_power() is used to power up a 3288's ethernet chip.
 457     mhz_mfc_config() handles socket setup for multifunction (1144
 458     and 3288) cards.  mhz_setup() gets a card's hardware ethernet
 459     address.
 460
 461 ======================================================================*/
 462
 463 static int mhz_3288_power(dev_link_t *link)
 464 {
 465     struct net_device *dev = link->priv;
 466     struct smc_private *smc = netdev_priv(dev);
 467     u_char tmp;
 468
 469     /* Read the ISR twice... */
 470     readb(smc->base+MEGAHERTZ_ISR);
 471     udelay(5);
 472     readb(smc->base+MEGAHERTZ_ISR);
 473
 474     /* Pause 200ms... */
 475     mdelay(200);
 476
 477     /* Now read and write the COR... */
 478     tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
 479     udelay(5);
 480     writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
 481
 482     return 0;
 483 }
 484
 485 static int mhz_mfc_config(dev_link_t *link)
 486 {
 487     struct net_device *dev = link->priv;
 488     struct smc_private *smc = netdev_priv(dev);
 489     struct smc_cfg_mem *cfg_mem;
 490     tuple_t *tuple;
 491     cisparse_t *parse;
 492     cistpl_cftable_entry_t *cf;
 493     u_char *buf;
 494     win_req_t req;
 495     memreq_t mem;
 496     int i, k;
 497
 498     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
 499     if (!cfg_mem)
 500         return CS_OUT_OF_RESOURCE;
 501
 502     tuple = &cfg_mem->tuple;
 503     parse = &cfg_mem->parse;
 504     cf = &parse->cftable_entry;
 505     buf = cfg_mem->buf;
 506
 507     link->conf.Attributes |= CONF_ENABLE_SPKR;
 508     link->conf.Status = CCSR_AUDIO_ENA;
 509     link->irq.Attributes =
 510         IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
 511     link->io.IOAddrLines = 16;
 512     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 513     link->io.NumPorts2 = 8;
 514
 515     tuple->Attributes = tuple->TupleOffset = 0;
 516     tuple->TupleData = (cisdata_t *)buf;
 517     tuple->TupleDataMax = 255;
 518     tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 519
 520     i = first_tuple(link->handle, tuple, parse);
 521     /* The Megahertz combo cards have modem-like CIS entries, so
 522        we have to explicitly try a bunch of port combinations. */
 523     while (i == CS_SUCCESS) {
 524         link->conf.ConfigIndex = cf->index;
 525         link->io.BasePort2 = cf->io.win[0].base;
 526         for (k = 0; k < 0x400; k += 0x10) {
 527             if (k & 0x80) continue;
 528             link->io.BasePort1 = k ^ 0x300;
 529             i = pcmcia_request_io(link->handle, &link->io);
 530             if (i == CS_SUCCESS) break;
 531         }
 532         if (i == CS_SUCCESS) break;
 533         i = next_tuple(link->handle, tuple, parse);
 534     }
 535     if (i != CS_SUCCESS)
 536         goto free_cfg_mem;
 537     dev->base_addr = link->io.BasePort1;
 538
 539     /* Allocate a memory window, for accessing the ISR */
 540     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
 541     req.Base = req.Size = 0;
 542     req.AccessSpeed = 0;
 543     i = pcmcia_request_window(&link->handle, &req, &link->win);
 544     if (i != CS_SUCCESS)
 545         goto free_cfg_mem;
 546     smc->base = ioremap(req.Base, req.Size);
 547     mem.CardOffset = mem.Page = 0;
 548     if (smc->manfid == MANFID_MOTOROLA)
 549         mem.CardOffset = link->conf.ConfigBase;
 550     i = pcmcia_map_mem_page(link->win, &mem);
 551
 552     if ((i == CS_SUCCESS)
 553         && (smc->manfid == MANFID_MEGAHERTZ)
 554         && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
 555         mhz_3288_power(link);
 556
 557 free_cfg_mem:
 558     kfree(cfg_mem);
 559     return i;
 560 }
 561
 562 static int mhz_setup(dev_link_t *link)
 563 {
 564     client_handle_t handle = link->handle;
 565     struct net_device *dev = link->priv;
 566     struct smc_cfg_mem *cfg_mem;
 567     tuple_t *tuple;
 568     cisparse_t *parse;
 569     u_char *buf, *station_addr;
 570     int rc;
 571
 572     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
 573     if (!cfg_mem)
 574         return -1;
 575
 576     tuple = &cfg_mem->tuple;
 577     parse = &cfg_mem->parse;
 578     buf = cfg_mem->buf;
 579
 580     tuple->Attributes = tuple->TupleOffset = 0;
 581     tuple->TupleData = (cisdata_t *)buf;
 582     tuple->TupleDataMax = 255;
 583
 584     /* Read the station address from the CIS.  It is stored as the last
 585        (fourth) string in the Version 1 Version/ID tuple. */
 586     tuple->DesiredTuple = CISTPL_VERS_1;
 587     if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
 588         rc = -1;
 589         goto free_cfg_mem;
 590     }
 591     /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
 592     if (next_tuple(handle, tuple, parse) != CS_SUCCESS)
 593         first_tuple(handle, tuple, parse);
 594     if (parse->version_1.ns > 3) {
 595         station_addr = parse->version_1.str + parse->version_1.ofs[3];
 596         if (cvt_ascii_address(dev, station_addr) == 0) {
 597                 rc = 0;
 598                 goto free_cfg_mem;
 599         }
 600     }
 601
 602     /* Another possibility: for the EM3288, in a special tuple */
 603     tuple->DesiredTuple = 0x81;
 604     if (pcmcia_get_first_tuple(handle, tuple) != CS_SUCCESS) {
 605         rc = -1;
 606         goto free_cfg_mem;
 607     }
 608     if (pcmcia_get_tuple_data(handle, tuple) != CS_SUCCESS) {
 609         rc = -1;
 610         goto free_cfg_mem;
 611     }
 612     buf[12] = '\0';
 613     if (cvt_ascii_address(dev, buf) == 0) {
 614         rc = 0;
 615         goto free_cfg_mem;
 616    }
 617     rc = -1;
 618 free_cfg_mem:
 619    kfree(cfg_mem);
 620    return rc;
 621 }
 622
 623 /*======================================================================
 624
 625     Configuration stuff for the Motorola Mariner
 626
 627     mot_config() writes directly to the Mariner configuration
 628     registers because the CIS is just bogus.
 629
 630 ======================================================================*/
 631
 632 static void mot_config(dev_link_t *link)
 633 {
 634     struct net_device *dev = link->priv;
 635     struct smc_private *smc = netdev_priv(dev);
 636     kio_addr_t ioaddr = dev->base_addr;
 637     kio_addr_t iouart = link->io.BasePort2;
 638
 639     /* Set UART base address and force map with COR bit 1 */
 640     writeb(iouart & 0xff,        smc->base + MOT_UART + CISREG_IOBASE_0);
 641     writeb((iouart >> 8) & 0xff, smc->base + MOT_UART + CISREG_IOBASE_1);
 642     writeb(MOT_NORMAL,           smc->base + MOT_UART + CISREG_COR);
 643
 644     /* Set SMC base address and force map with COR bit 1 */
 645     writeb(ioaddr & 0xff,        smc->base + MOT_LAN + CISREG_IOBASE_0);
 646     writeb((ioaddr >> 8) & 0xff, smc->base + MOT_LAN + CISREG_IOBASE_1);
 647     writeb(MOT_NORMAL,           smc->base + MOT_LAN + CISREG_COR);
 648
 649     /* Wait for things to settle down */
 650     mdelay(100);
 651 }
 652
 653 static int mot_setup(dev_link_t *link)
 654 {
 655     struct net_device *dev = link->priv;
 656     kio_addr_t ioaddr = dev->base_addr;
 657     int i, wait, loop;
 658     u_int addr;
 659
 660     /* Read Ethernet address from Serial EEPROM */
 661
 662     for (i = 0; i < 3; i++) {
 663         SMC_SELECT_BANK(2);
 664         outw(MOT_EEPROM + i, ioaddr + POINTER);
 665         SMC_SELECT_BANK(1);
 666         outw((CTL_RELOAD | CTL_EE_SELECT), ioaddr + CONTROL);
 667
 668         for (loop = wait = 0; loop < 200; loop++) {
 669             udelay(10);
 670             wait = ((CTL_RELOAD | CTL_STORE) & inw(ioaddr + CONTROL));
 671             if (wait == 0) break;
 672         }
 673
 674         if (wait)
 675             return -1;
 676
 677         addr = inw(ioaddr + GENERAL);
 678         dev->dev_addr[2*i]   = addr & 0xff;
 679         dev->dev_addr[2*i+1] = (addr >> 8) & 0xff;
 680     }
 681
 682     return 0;
 683 }
 684
 685 /*====================================================================*/
 686
 687 static int smc_config(dev_link_t *link)
 688 {
 689     struct net_device *dev = link->priv;
 690     struct smc_cfg_mem *cfg_mem;
 691     tuple_t *tuple;
 692     cisparse_t *parse;
 693     cistpl_cftable_entry_t *cf;
 694     u_char *buf;
 695     int i;
 696
 697     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
 698     if (!cfg_mem)
 699         return CS_OUT_OF_RESOURCE;
 700
 701     tuple = &cfg_mem->tuple;
 702     parse = &cfg_mem->parse;
 703     cf = &parse->cftable_entry;
 704     buf = cfg_mem->buf;
 705
 706     tuple->Attributes = tuple->TupleOffset = 0;
 707     tuple->TupleData = (cisdata_t *)buf;
 708     tuple->TupleDataMax = 255;
 709     tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
 710
 711     link->io.NumPorts1 = 16;
 712     i = first_tuple(link->handle, tuple, parse);
 713     while (i != CS_NO_MORE_ITEMS) {
 714         if (i == CS_SUCCESS) {
 715             link->conf.ConfigIndex = cf->index;
 716             link->io.BasePort1 = cf->io.win[0].base;
 717             link->io.IOAddrLines = cf->io.flags & CISTPL_IO_LINES_MASK;
 718             i = pcmcia_request_io(link->handle, &link->io);
 719             if (i == CS_SUCCESS) break;
 720         }
 721         i = next_tuple(link->handle, tuple, parse);
 722     }
 723     if (i == CS_SUCCESS)
 724         dev->base_addr = link->io.BasePort1;
 725
 726     kfree(cfg_mem);
 727     return i;
 728 }
 729
 730 static int smc_setup(dev_link_t *link)
 731 {
 732     client_handle_t handle = link->handle;
 733     struct net_device *dev = link->priv;
 734     struct smc_cfg_mem *cfg_mem;
 735     tuple_t *tuple;
 736     cisparse_t *parse;
 737     cistpl_lan_node_id_t *node_id;
 738     u_char *buf, *station_addr;
 739     int i, rc;
 740
 741     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
 742     if (!cfg_mem)
 743         return CS_OUT_OF_RESOURCE;
 744
 745     tuple = &cfg_mem->tuple;
 746     parse = &cfg_mem->parse;
 747     buf = cfg_mem->buf;
 748
 749     tuple->Attributes = tuple->TupleOffset = 0;
 750     tuple->TupleData = (cisdata_t *)buf;
 751     tuple->TupleDataMax = 255;
 752
 753     /* Check for a LAN function extension tuple */
 754     tuple->DesiredTuple = CISTPL_FUNCE;
 755     i = first_tuple(handle, tuple, parse);
 756     while (i == CS_SUCCESS) {
 757         if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
 758             break;
 759         i = next_tuple(handle, tuple, parse);
 760     }
 761     if (i == CS_SUCCESS) {
 762         node_id = (cistpl_lan_node_id_t *)parse->funce.data;
 763         if (node_id->nb == 6) {
 764             for (i = 0; i < 6; i++)
 765                 dev->dev_addr[i] = node_id->id[i];
 766             rc = 0;
 767             goto free_cfg_mem;
 768         }
 769     }
 770     /* Try the third string in the Version 1 Version/ID tuple. */
 771     tuple->DesiredTuple = CISTPL_VERS_1;
 772     if (first_tuple(handle, tuple, parse) != CS_SUCCESS) {
 773         rc = -1;
 774         goto free_cfg_mem;
 775     }
 776     station_addr = parse->version_1.str + parse->version_1.ofs[2];
 777     if (cvt_ascii_address(dev, station_addr) == 0) {
 778         rc = 0;
 779         goto free_cfg_mem;
 780     }
 781
 782     rc = -1;
 783 free_cfg_mem:
 784     kfree(cfg_mem);
 785     return rc;
 786 }
 787
 788 /*====================================================================*/
 789
 790 static int osi_config(dev_link_t *link)
 791 {
 792     struct net_device *dev = link->priv;
 793     static kio_addr_t com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
 794     int i, j;
 795
 796     link->conf.Attributes |= CONF_ENABLE_SPKR;
 797     link->conf.Status = CCSR_AUDIO_ENA;
 798     link->irq.Attributes =
 799         IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
 800     link->io.NumPorts1 = 64;
 801     link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
 802     link->io.NumPorts2 = 8;
 803     link->io.IOAddrLines = 16;
 804
 805     /* Enable Hard Decode, LAN, Modem */
 806     link->conf.ConfigIndex = 0x23;
 807
 808     for (i = j = 0; j < 4; j++) {
 809         link->io.BasePort2 = com[j];
 810         i = pcmcia_request_io(link->handle, &link->io);
 811         if (i == CS_SUCCESS) break;
 812     }
 813     if (i != CS_SUCCESS) {
 814         /* Fallback: turn off hard decode */
 815         link->conf.ConfigIndex = 0x03;
 816         link->io.NumPorts2 = 0;
 817         i = pcmcia_request_io(link->handle, &link->io);
 818     }
 819     dev->base_addr = link->io.BasePort1 + 0x10;
 820     return i;
 821 }
 822
 823 static int osi_setup(dev_link_t *link, u_short manfid, u_short cardid)
 824 {
 825     client_handle_t handle = link->handle;
 826     struct net_device *dev = link->priv;
 827     struct smc_cfg_mem *cfg_mem;
 828     tuple_t *tuple;
 829     u_char *buf;
 830     int i, rc;
 831
 832     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
 833     if (!cfg_mem)
 834         return -1;
 835
 836     tuple = &cfg_mem->tuple;
 837     buf = cfg_mem->buf;
 838
 839     tuple->Attributes = TUPLE_RETURN_COMMON;
 840     tuple->TupleData = (cisdata_t *)buf;
 841     tuple->TupleDataMax = 255;
 842     tuple->TupleOffset = 0;
 843
 844     /* Read the station address from tuple 0x90, subtuple 0x04 */
 845     tuple->DesiredTuple = 0x90;
 846     i = pcmcia_get_first_tuple(handle, tuple);
 847     while (i == CS_SUCCESS) {
 848         i = pcmcia_get_tuple_data(handle, tuple);
 849         if ((i != CS_SUCCESS) || (buf[0] == 0x04))
 850             break;
 851         i = pcmcia_get_next_tuple(handle, tuple);
 852     }
 853     if (i != CS_SUCCESS) {
 854         rc = -1;
 855         goto free_cfg_mem;
 856     }
 857     for (i = 0; i < 6; i++)
 858         dev->dev_addr[i] = buf[i+2];
 859
 860     if (((manfid == MANFID_OSITECH) &&
 861          (cardid == PRODID_OSITECH_SEVEN)) ||
 862         ((manfid == MANFID_PSION) &&
 863          (cardid == PRODID_PSION_NET100))) {
 864         /* Download the Seven of Diamonds firmware */
 865         for (i = 0; i < sizeof(__Xilinx7OD); i++) {
 866             outb(__Xilinx7OD[i], link->io.BasePort1+2);
 867             udelay(50);
 868         }
 869     } else if (manfid == MANFID_OSITECH) {
 870         /* Make sure both functions are powered up */
 871         set_bits(0x300, link->io.BasePort1 + OSITECH_AUI_PWR);
 872         /* Now, turn on the interrupt for both card functions */
 873         set_bits(0x300, link->io.BasePort1 + OSITECH_RESET_ISR);
 874         DEBUG(2, "AUI/PWR: %4.4x RESET/ISR: %4.4x\n",
 875               inw(link->io.BasePort1 + OSITECH_AUI_PWR),
 876               inw(link->io.BasePort1 + OSITECH_RESET_ISR));
 877     }
 878     rc = 0;
 879 free_cfg_mem:
 880    kfree(cfg_mem);
 881    return rc;
 882 }
 883
 884 static int smc91c92_suspend(struct pcmcia_device *p_dev)
 885 {
 886         dev_link_t *link = dev_to_instance(p_dev);
 887         struct net_device *dev = link->priv;
 888
 889         link->state |= DEV_SUSPEND;
 890         if (link->state & DEV_CONFIG) {
 891                 if (link->open)
 892                         netif_device_detach(dev);
 893                 pcmcia_release_configuration(link->handle);
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int smc91c92_resume(struct pcmcia_device *p_dev)
 900 {
 901         dev_link_t *link = dev_to_instance(p_dev);
 902         struct net_device *dev = link->priv;
 903         struct smc_private *smc = netdev_priv(dev);
 904         int i;
 905
 906         link->state &= ~DEV_SUSPEND;
 907         if (link->state & DEV_CONFIG) {
 908                 if ((smc->manfid == MANFID_MEGAHERTZ) &&
 909                     (smc->cardid == PRODID_MEGAHERTZ_EM3288))
 910                         mhz_3288_power(link);
 911                 pcmcia_request_configuration(link->handle, &link->conf);
 912                 if (smc->manfid == MANFID_MOTOROLA)
 913                         mot_config(link);
 914                 if ((smc->manfid == MANFID_OSITECH) &&
 915                     (smc->cardid != PRODID_OSITECH_SEVEN)) {
 916                         /* Power up the card and enable interrupts */
 917                         set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
 918                         set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
 919                 }
 920                 if (((smc->manfid == MANFID_OSITECH) &&
 921                      (smc->cardid == PRODID_OSITECH_SEVEN)) ||
 922                     ((smc->manfid == MANFID_PSION) &&
 923                      (smc->cardid == PRODID_PSION_NET100))) {
 924                         /* Download the Seven of Diamonds firmware */
 925                         for (i = 0; i < sizeof(__Xilinx7OD); i++) {
 926                                 outb(__Xilinx7OD[i], link->io.BasePort1+2);
 927                                 udelay(50);
 928                         }
 929                 }
 930                 if (link->open) {
 931                         smc_reset(dev);
 932                         netif_device_attach(dev);
 933                 }
 934         }
 935
 936         return 0;
 937 }
 938
 939
 940 /*======================================================================
 941
 942     This verifies that the chip is some SMC91cXX variant, and returns
 943     the revision code if successful.  Otherwise, it returns -ENODEV.
 944
 945 ======================================================================*/
 946
 947 static int check_sig(dev_link_t *link)
 948 {
 949     struct net_device *dev = link->priv;
 950     kio_addr_t ioaddr = dev->base_addr;
 951     int width;
 952     u_short s;
 953
 954     SMC_SELECT_BANK(1);
 955     if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
 956         /* Try powering up the chip */
 957         outw(0, ioaddr + CONTROL);
 958         mdelay(55);
 959     }
 960
 961     /* Try setting bus width */
 962     width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
 963     s = inb(ioaddr + CONFIG);
 964     if (width)
 965         s |= CFG_16BIT;
 966     else
 967         s &= ~CFG_16BIT;
 968     outb(s, ioaddr + CONFIG);
 969
 970     /* Check Base Address Register to make sure bus width is OK */
 971     s = inw(ioaddr + BASE_ADDR);
 972     if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
 973         ((s >> 8) != (s & 0xff))) {
 974         SMC_SELECT_BANK(3);
 975         s = inw(ioaddr + REVISION);
 976         return (s & 0xff);
 977     }
 978
 979     if (width) {
 980         printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
 981         smc91c92_suspend(link->handle);
 982         pcmcia_release_io(link->handle, &link->io);
 983         link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 984         pcmcia_request_io(link->handle, &link->io);
 985         smc91c92_resume(link->handle);
 986         return check_sig(link);
 987     }
 988     return -ENODEV;
 989 }
 990
 991 /*======================================================================
 992
 993     smc91c92_config() is scheduled to run after a CARD_INSERTION event
 994     is received, to configure the PCMCIA socket, and to make the
 995     ethernet device available to the system.
 996
 997 ======================================================================*/
 998
 999 #define CS_EXIT_TEST(ret, svc, label) \
1000 if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
1001
1002 static void smc91c92_config(dev_link_t *link)
1003 {
1004     client_handle_t handle = link->handle;
1005     struct net_device *dev = link->priv;
1006     struct smc_private *smc = netdev_priv(dev);
1007     struct smc_cfg_mem *cfg_mem;
1008     tuple_t *tuple;
1009     cisparse_t *parse;
1010     u_char *buf;
1011     char *name;
1012     int i, j, rev;
1013     kio_addr_t ioaddr;
1014     u_long mir;
1015
1016     DEBUG(0, "smc91c92_config(0x%p)\n", link);
1017
1018     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
1019     if (!cfg_mem)
1020         goto config_failed;
1021
1022     tuple = &cfg_mem->tuple;
1023     parse = &cfg_mem->parse;
1024     buf = cfg_mem->buf;
1025
1026     tuple->Attributes = tuple->TupleOffset = 0;
1027     tuple->TupleData = (cisdata_t *)buf;
1028     tuple->TupleDataMax = 64;
1029
1030     tuple->DesiredTuple = CISTPL_CONFIG;
1031     i = first_tuple(handle, tuple, parse);
1032     CS_EXIT_TEST(i, ParseTuple, config_failed);
1033     link->conf.ConfigBase = parse->config.base;
1034     link->conf.Present = parse->config.rmask[0];
1035
1036     tuple->DesiredTuple = CISTPL_MANFID;
1037     tuple->Attributes = TUPLE_RETURN_COMMON;
1038     if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
1039         smc->manfid = parse->manfid.manf;
1040         smc->cardid = parse->manfid.card;
1041     }
1042
1043     /* Configure card */
1044     link->state |= DEV_CONFIG;
1045
1046     if ((smc->manfid == MANFID_OSITECH) &&
1047         (smc->cardid != PRODID_OSITECH_SEVEN)) {
1048         i = osi_config(link);
1049     } else if ((smc->manfid == MANFID_MOTOROLA) ||
1050                ((smc->manfid == MANFID_MEGAHERTZ) &&
1051                 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
1052                  (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
1053         i = mhz_mfc_config(link);
1054     } else {
1055         i = smc_config(link);
1056     }
1057     CS_EXIT_TEST(i, RequestIO, config_failed);
1058
1059     i = pcmcia_request_irq(link->handle, &link->irq);
1060     CS_EXIT_TEST(i, RequestIRQ, config_failed);
1061     i = pcmcia_request_configuration(link->handle, &link->conf);
1062     CS_EXIT_TEST(i, RequestConfiguration, config_failed);
1063
1064     if (smc->manfid == MANFID_MOTOROLA)
1065         mot_config(link);
1066
1067     dev->irq = link->irq.AssignedIRQ;
1068
1069     if ((if_port >= 0) && (if_port <= 2))
1070         dev->if_port = if_port;
1071     else
1072         printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
1073
1074     switch (smc->manfid) {
1075     case MANFID_OSITECH:
1076     case MANFID_PSION:
1077         i = osi_setup(link, smc->manfid, smc->cardid); break;
1078     case MANFID_SMC:
1079     case MANFID_NEW_MEDIA:
1080         i = smc_setup(link); break;
1081     case 0x128: /* For broken Megahertz cards */
1082     case MANFID_MEGAHERTZ:
1083         i = mhz_setup(link); break;
1084     case MANFID_MOTOROLA:
1085     default: /* get the hw address from EEPROM */
1086         i = mot_setup(link); break;
1087     }
1088
1089     if (i != 0) {
1090         printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1091         goto config_undo;
1092     }
1093
1094     smc->duplex = 0;
1095     smc->rx_ovrn = 0;
1096
1097     rev = check_sig(link);
1098     name = "???";
1099     if (rev > 0)
1100         switch (rev >> 4) {
1101         case 3: name = "92"; break;
1102         case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1103         case 5: name = "95"; break;
1104         case 7: name = "100"; break;
1105         case 8: name = "100-FD"; break;
1106         case 9: name = "110"; break;
1107         }
1108
1109     ioaddr = dev->base_addr;
1110     if (rev > 0) {
1111         u_long mcr;
1112         SMC_SELECT_BANK(0);
1113         mir = inw(ioaddr + MEMINFO) & 0xff;
1114         if (mir == 0xff) mir++;
1115         /* Get scale factor for memory size */
1116         mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1117         mir *= 128 * (1<<((mcr >> 9) & 7));
1118         SMC_SELECT_BANK(1);
1119         smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1120         smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1121         if (smc->manfid == MANFID_OSITECH)
1122             smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1123         if ((rev >> 4) >= 7)
1124             smc->cfg |= CFG_MII_SELECT;
1125     } else
1126         mir = 0;
1127
1128     if (smc->cfg & CFG_MII_SELECT) {
1129         SMC_SELECT_BANK(3);
1130
1131         for (i = 0; i < 32; i++) {
1132             j = mdio_read(dev, i, 1);
1133             if ((j != 0) && (j != 0xffff)) break;
1134         }
1135         smc->mii_if.phy_id = (i < 32) ? i : -1;
1136
1137         SMC_SELECT_BANK(0);
1138     }
1139
1140     link->dev = &smc->node;
1141     link->state &= ~DEV_CONFIG_PENDING;
1142     SET_NETDEV_DEV(dev, &handle_to_dev(handle));
1143
1144     if (register_netdev(dev) != 0) {
1145         printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1146         link->dev = NULL;
1147         goto config_undo;
1148     }
1149
1150     strcpy(smc->node.dev_name, dev->name);
1151
1152     printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1153            "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
1154            dev->irq);
1155     for (i = 0; i < 6; i++)
1156         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
1157
1158     if (rev > 0) {
1159         if (mir & 0x3ff)
1160             printk(KERN_INFO "  %lu byte", mir);
1161         else
1162             printk(KERN_INFO "  %lu kb", mir>>10);
1163         printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1164                "MII" : if_names[dev->if_port]);
1165     }
1166
1167     if (smc->cfg & CFG_MII_SELECT) {
1168         if (smc->mii_if.phy_id != -1) {
1169             DEBUG(0, "  MII transceiver at index %d, status %x.\n",
1170                   smc->mii_if.phy_id, j);
1171         } else {
1172             printk(KERN_NOTICE "  No MII transceivers found!\n");
1173         }
1174     }
1175     kfree(cfg_mem);
1176     return;
1177
1178 config_undo:
1179     unregister_netdev(dev);
1180 config_failed:                  /* CS_EXIT_TEST() calls jump to here... */
1181     smc91c92_release(link);
1182     link->state &= ~DEV_CONFIG_PENDING;
1183     kfree(cfg_mem);
1184
1185 } /* smc91c92_config */
1186
1187 /*======================================================================
1188
1189     After a card is removed, smc91c92_release() will unregister the net
1190     device, and release the PCMCIA configuration.  If the device is
1191     still open, this will be postponed until it is closed.
1192
1193 ======================================================================*/
1194
1195 static void smc91c92_release(dev_link_t *link)
1196 {
1197
1198     DEBUG(0, "smc91c92_release(0x%p)\n", link);
1199
1200     pcmcia_release_configuration(link->handle);
1201     pcmcia_release_io(link->handle, &link->io);
1202     pcmcia_release_irq(link->handle, &link->irq);
1203     if (link->win) {
1204         struct net_device *dev = link->priv;
1205         struct smc_private *smc = netdev_priv(dev);
1206         iounmap(smc->base);
1207         pcmcia_release_window(link->win);
1208     }
1209
1210     link->state &= ~DEV_CONFIG;
1211 }
1212
1213 /*======================================================================
1214
1215     The card status event handler.  Mostly, this schedules other
1216     stuff to run after an event is received.  A CARD_REMOVAL event
1217     also sets some flags to discourage the net drivers from trying
1218     to talk to the card any more.
1219
1220 ======================================================================*/
1221
1222 static int smc91c92_event(event_t event, int priority,
1223                           event_callback_args_t *args)
1224 {
1225     dev_link_t *link = args->client_data;
1226
1227     DEBUG(1, "smc91c92_event(0x%06x)\n", event);
1228
1229     switch (event) {
1230     case CS_EVENT_CARD_INSERTION:
1231         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
1232         smc91c92_config(link);
1233         break;
1234     }
1235     return 0;
1236 } /* smc91c92_event */
1237
1238 /*======================================================================
1239
1240     MII interface support for SMC91cXX based cards
1241 ======================================================================*/
1242
1243 #define MDIO_SHIFT_CLK          0x04
1244 #define MDIO_DATA_OUT           0x01
1245 #define MDIO_DIR_WRITE          0x08
1246 #define MDIO_DATA_WRITE0        (MDIO_DIR_WRITE)
1247 #define MDIO_DATA_WRITE1        (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1248 #define MDIO_DATA_READ          0x02
1249
1250 static void mdio_sync(kio_addr_t addr)
1251 {
1252     int bits;
1253     for (bits = 0; bits < 32; bits++) {
1254         outb(MDIO_DATA_WRITE1, addr);
1255         outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1256     }
1257 }
1258
1259 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1260 {
1261     kio_addr_t addr = dev->base_addr + MGMT;
1262     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1263     int i, retval = 0;
1264
1265     mdio_sync(addr);
1266     for (i = 13; i >= 0; i--) {
1267         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1268         outb(dat, addr);
1269         outb(dat | MDIO_SHIFT_CLK, addr);
1270     }
1271     for (i = 19; i > 0; i--) {
1272         outb(0, addr);
1273         retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1274         outb(MDIO_SHIFT_CLK, addr);
1275     }
1276     return (retval>>1) & 0xffff;
1277 }
1278
1279 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1280 {
1281     kio_addr_t addr = dev->base_addr + MGMT;
1282     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1283     int i;
1284
1285     mdio_sync(addr);
1286     for (i = 31; i >= 0; i--) {
1287         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1288         outb(dat, addr);
1289         outb(dat | MDIO_SHIFT_CLK, addr);
1290     }
1291     for (i = 1; i >= 0; i--) {
1292         outb(0, addr);
1293         outb(MDIO_SHIFT_CLK, addr);
1294     }
1295 }
1296
1297 /*======================================================================
1298
1299     The driver core code, most of which should be common with a
1300     non-PCMCIA implementation.
1301
1302 ======================================================================*/
1303
1304 #ifdef PCMCIA_DEBUG
1305 static void smc_dump(struct net_device *dev)
1306 {
1307     kio_addr_t ioaddr = dev->base_addr;
1308     u_short i, w, save;
1309     save = inw(ioaddr + BANK_SELECT);
1310     for (w = 0; w < 4; w++) {
1311         SMC_SELECT_BANK(w);
1312         printk(KERN_DEBUG "bank %d: ", w);
1313         for (i = 0; i < 14; i += 2)
1314             printk(" %04x", inw(ioaddr + i));
1315         printk("\n");
1316     }
1317     outw(save, ioaddr + BANK_SELECT);
1318 }
1319 #endif
1320
1321 static int smc_open(struct net_device *dev)
1322 {
1323     struct smc_private *smc = netdev_priv(dev);
1324     dev_link_t *link = &smc->link;
1325
1326 #ifdef PCMCIA_DEBUG
1327     DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1328           dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1329     if (pc_debug > 1) smc_dump(dev);
1330 #endif
1331
1332     /* Check that the PCMCIA card is still here. */
1333     if (!DEV_OK(link))
1334         return -ENODEV;
1335     /* Physical device present signature. */
1336     if (check_sig(link) < 0) {
1337         printk("smc91c92_cs: Yikes!  Bad chip signature!\n");
1338         return -ENODEV;
1339     }
1340     link->open++;
1341
1342     netif_start_queue(dev);
1343     smc->saved_skb = NULL;
1344     smc->packets_waiting = 0;
1345
1346     smc_reset(dev);
1347     init_timer(&smc->media);
1348     smc->media.function = &media_check;
1349     smc->media.data = (u_long) dev;
1350     smc->media.expires = jiffies + HZ;
1351     add_timer(&smc->media);
1352
1353     return 0;
1354 } /* smc_open */
1355
1356 /*====================================================================*/
1357
1358 static int smc_close(struct net_device *dev)
1359 {
1360     struct smc_private *smc = netdev_priv(dev);
1361     dev_link_t *link = &smc->link;
1362     kio_addr_t ioaddr = dev->base_addr;
1363
1364     DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1365           dev->name, inw(ioaddr + BANK_SELECT));
1366
1367     netif_stop_queue(dev);
1368
1369     /* Shut off all interrupts, and turn off the Tx and Rx sections.
1370        Don't bother to check for chip present. */
1371     SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1372     outw(0, ioaddr + INTERRUPT);
1373     SMC_SELECT_BANK(0);
1374     mask_bits(0xff00, ioaddr + RCR);
1375     mask_bits(0xff00, ioaddr + TCR);
1376
1377     /* Put the chip into power-down mode. */
1378     SMC_SELECT_BANK(1);
1379     outw(CTL_POWERDOWN, ioaddr + CONTROL );
1380
1381     link->open--;
1382     del_timer_sync(&smc->media);
1383
1384     return 0;
1385 } /* smc_close */
1386
1387 /*======================================================================
1388
1389    Transfer a packet to the hardware and trigger the packet send.
1390    This may be called at either from either the Tx queue code
1391    or the interrupt handler.
1392
1393 ======================================================================*/
1394
1395 static void smc_hardware_send_packet(struct net_device * dev)
1396 {
1397     struct smc_private *smc = netdev_priv(dev);
1398     struct sk_buff *skb = smc->saved_skb;
1399     kio_addr_t ioaddr = dev->base_addr;
1400     u_char packet_no;
1401
1402     if (!skb) {
1403         printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1404         return;
1405     }
1406
1407     /* There should be a packet slot waiting. */
1408     packet_no = inw(ioaddr + PNR_ARR) >> 8;
1409     if (packet_no & 0x80) {
1410         /* If not, there is a hardware problem!  Likely an ejected card. */
1411         printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1412                " failed, status %#2.2x.\n", dev->name, packet_no);
1413         dev_kfree_skb_irq(skb);
1414         smc->saved_skb = NULL;
1415         netif_start_queue(dev);
1416         return;
1417     }
1418
1419     smc->stats.tx_bytes += skb->len;
1420     /* The card should use the just-allocated buffer. */
1421     outw(packet_no, ioaddr + PNR_ARR);
1422     /* point to the beginning of the packet */
1423     outw(PTR_AUTOINC , ioaddr + POINTER);
1424
1425     /* Send the packet length (+6 for status, length and ctl byte)
1426        and the status word (set to zeros). */
1427     {
1428         u_char *buf = skb->data;
1429         u_int length = skb->len; /* The chip will pad to ethernet min. */
1430
1431         DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1432               dev->name, length);
1433
1434         /* send the packet length: +6 for status word, length, and ctl */
1435         outw(0, ioaddr + DATA_1);
1436         outw(length + 6, ioaddr + DATA_1);
1437         outsw(ioaddr + DATA_1, buf, length >> 1);
1438
1439         /* The odd last byte, if there is one, goes in the control word. */
1440         outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1441     }
1442
1443     /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1444     outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1445          (inw(ioaddr + INTERRUPT) & 0xff00),
1446          ioaddr + INTERRUPT);
1447
1448     /* The chip does the rest of the work. */
1449     outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1450
1451     smc->saved_skb = NULL;
1452     dev_kfree_skb_irq(skb);
1453     dev->trans_start = jiffies;
1454     netif_start_queue(dev);
1455     return;
1456 }
1457
1458 /*====================================================================*/
1459
1460 static void smc_tx_timeout(struct net_device *dev)
1461 {
1462     struct smc_private *smc = netdev_priv(dev);
1463     kio_addr_t ioaddr = dev->base_addr;
1464
1465     printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1466            "Tx_status %2.2x status %4.4x.\n",
1467            dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1468     smc->stats.tx_errors++;
1469     smc_reset(dev);
1470     dev->trans_start = jiffies;
1471     smc->saved_skb = NULL;
1472     netif_wake_queue(dev);
1473 }
1474
1475 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1476 {
1477     struct smc_private *smc = netdev_priv(dev);
1478     kio_addr_t ioaddr = dev->base_addr;
1479     u_short num_pages;
1480     short time_out, ir;
1481
1482     netif_stop_queue(dev);
1483
1484     DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1485           " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1486
1487     if (smc->saved_skb) {
1488         /* THIS SHOULD NEVER HAPPEN. */
1489         smc->stats.tx_aborted_errors++;
1490         printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1491                dev->name);
1492         return 1;
1493     }
1494     smc->saved_skb = skb;
1495
1496     num_pages = skb->len >> 8;
1497
1498     if (num_pages > 7) {
1499         printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1500         dev_kfree_skb (skb);
1501         smc->saved_skb = NULL;
1502         smc->stats.tx_dropped++;
1503         return 0;               /* Do not re-queue this packet. */
1504     }
1505     /* A packet is now waiting. */
1506     smc->packets_waiting++;
1507
1508     SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1509
1510     /* need MC_RESET to keep the memory consistent. errata? */
1511     if (smc->rx_ovrn) {
1512         outw(MC_RESET, ioaddr + MMU_CMD);
1513         smc->rx_ovrn = 0;
1514     }
1515
1516     /* Allocate the memory; send the packet now if we win. */
1517     outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1518     for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1519         ir = inw(ioaddr+INTERRUPT);
1520         if (ir & IM_ALLOC_INT) {
1521             /* Acknowledge the interrupt, send the packet. */
1522             outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1523             smc_hardware_send_packet(dev);      /* Send the packet now.. */
1524             return 0;
1525         }
1526     }
1527
1528     /* Otherwise defer until the Tx-space-allocated interrupt. */
1529     DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1530     outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1531
1532     return 0;
1533 }
1534
1535 /*======================================================================
1536
1537     Handle a Tx anomolous event.  Entered while in Window 2.
1538
1539 ======================================================================*/
1540
1541 static void smc_tx_err(struct net_device * dev)
1542 {
1543     struct smc_private *smc = netdev_priv(dev);
1544     kio_addr_t ioaddr = dev->base_addr;
1545     int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1546     int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1547     int tx_status;
1548
1549     /* select this as the packet to read from */
1550     outw(packet_no, ioaddr + PNR_ARR);
1551
1552     /* read the first word from this packet */
1553     outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1554
1555     tx_status = inw(ioaddr + DATA_1);
1556
1557     smc->stats.tx_errors++;
1558     if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1559     if (tx_status & TS_LATCOL)  smc->stats.tx_window_errors++;
1560     if (tx_status & TS_16COL) {
1561         smc->stats.tx_aborted_errors++;
1562         smc->tx_err++;
1563     }
1564
1565     if (tx_status & TS_SUCCESS) {
1566         printk(KERN_NOTICE "%s: Successful packet caused error "
1567                "interrupt?\n", dev->name);
1568     }
1569     /* re-enable transmit */
1570     SMC_SELECT_BANK(0);
1571     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1572     SMC_SELECT_BANK(2);
1573
1574     outw(MC_FREEPKT, ioaddr + MMU_CMD);         /* Free the packet memory. */
1575
1576     /* one less packet waiting for me */
1577     smc->packets_waiting--;
1578
1579     outw(saved_packet, ioaddr + PNR_ARR);
1580     return;
1581 }
1582
1583 /*====================================================================*/
1584
1585 static void smc_eph_irq(struct net_device *dev)
1586 {
1587     struct smc_private *smc = netdev_priv(dev);
1588     kio_addr_t ioaddr = dev->base_addr;
1589     u_short card_stats, ephs;
1590
1591     SMC_SELECT_BANK(0);
1592     ephs = inw(ioaddr + EPH);
1593     DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1594           " %4.4x.\n", dev->name, ephs);
1595     /* Could be a counter roll-over warning: update stats. */
1596     card_stats = inw(ioaddr + COUNTER);
1597     /* single collisions */
1598     smc->stats.collisions += card_stats & 0xF;
1599     card_stats >>= 4;
1600     /* multiple collisions */
1601     smc->stats.collisions += card_stats & 0xF;
1602 #if 0           /* These are for when linux supports these statistics */
1603     card_stats >>= 4;                   /* deferred */
1604     card_stats >>= 4;                   /* excess deferred */
1605 #endif
1606     /* If we had a transmit error we must re-enable the transmitter. */
1607     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1608
1609     /* Clear a link error interrupt. */
1610     SMC_SELECT_BANK(1);
1611     outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1612     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1613          ioaddr + CONTROL);
1614     SMC_SELECT_BANK(2);
1615 }
1616
1617 /*====================================================================*/
1618
1619 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1620 {
1621     struct net_device *dev = dev_id;
1622     struct smc_private *smc = netdev_priv(dev);
1623     kio_addr_t ioaddr;
1624     u_short saved_bank, saved_pointer, mask, status;
1625     unsigned int handled = 1;
1626     char bogus_cnt = INTR_WORK;         /* Work we are willing to do. */
1627
1628     if (!netif_device_present(dev))
1629         return IRQ_NONE;
1630
1631     ioaddr = dev->base_addr;
1632
1633     DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1634           irq, ioaddr);
1635
1636     smc->watchdog = 0;
1637     saved_bank = inw(ioaddr + BANK_SELECT);
1638     if ((saved_bank & 0xff00) != 0x3300) {
1639         /* The device does not exist -- the card could be off-line, or
1640            maybe it has been ejected. */
1641         DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1642               "/ejected device.\n", dev->name, irq);
1643         handled = 0;
1644         goto irq_done;
1645     }
1646
1647     SMC_SELECT_BANK(2);
1648     saved_pointer = inw(ioaddr + POINTER);
1649     mask = inw(ioaddr + INTERRUPT) >> 8;
1650     /* clear all interrupts */
1651     outw(0, ioaddr + INTERRUPT);
1652
1653     do { /* read the status flag, and mask it */
1654         status = inw(ioaddr + INTERRUPT) & 0xff;
1655         DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1656               status, mask);
1657         if ((status & mask) == 0) {
1658             if (bogus_cnt == INTR_WORK)
1659                 handled = 0;
1660             break;
1661         }
1662         if (status & IM_RCV_INT) {
1663             /* Got a packet(s). */
1664             smc_rx(dev);
1665         }
1666         if (status & IM_TX_INT) {
1667             smc_tx_err(dev);
1668             outw(IM_TX_INT, ioaddr + INTERRUPT);
1669         }
1670         status &= mask;
1671         if (status & IM_TX_EMPTY_INT) {
1672             outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1673             mask &= ~IM_TX_EMPTY_INT;
1674             smc->stats.tx_packets += smc->packets_waiting;
1675             smc->packets_waiting = 0;
1676         }
1677         if (status & IM_ALLOC_INT) {
1678             /* Clear this interrupt so it doesn't happen again */
1679             mask &= ~IM_ALLOC_INT;
1680
1681             smc_hardware_send_packet(dev);
1682
1683             /* enable xmit interrupts based on this */
1684             mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1685
1686             /* and let the card send more packets to me */
1687             netif_wake_queue(dev);
1688         }
1689         if (status & IM_RX_OVRN_INT) {
1690             smc->stats.rx_errors++;
1691             smc->stats.rx_fifo_errors++;
1692             if (smc->duplex)
1693                 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1694             outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1695         }
1696         if (status & IM_EPH_INT)
1697             smc_eph_irq(dev);
1698     } while (--bogus_cnt);
1699
1700     DEBUG(3, "  Restoring saved registers mask %2.2x bank %4.4x"
1701           " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1702
1703     /* restore state register */
1704     outw((mask<<8), ioaddr + INTERRUPT);
1705     outw(saved_pointer, ioaddr + POINTER);
1706     SMC_SELECT_BANK(saved_bank);
1707
1708     DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1709
1710 irq_done:
1711
1712     if ((smc->manfid == MANFID_OSITECH) &&
1713         (smc->cardid != PRODID_OSITECH_SEVEN)) {
1714         /* Retrigger interrupt if needed */
1715         mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1716         set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1717     }
1718     if (smc->manfid == MANFID_MOTOROLA) {
1719         u_char cor;
1720         cor = readb(smc->base + MOT_UART + CISREG_COR);
1721         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1722         writeb(cor, smc->base + MOT_UART + CISREG_COR);
1723         cor = readb(smc->base + MOT_LAN + CISREG_COR);
1724         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1725         writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1726     }
1727 #ifdef DOES_NOT_WORK
1728     if (smc->base != NULL) { /* Megahertz MFC's */
1729         readb(smc->base+MEGAHERTZ_ISR);
1730         readb(smc->base+MEGAHERTZ_ISR);
1731     }
1732 #endif
1733     return IRQ_RETVAL(handled);
1734 }
1735
1736 /*====================================================================*/
1737
1738 static void smc_rx(struct net_device *dev)
1739 {
1740     struct smc_private *smc = netdev_priv(dev);
1741     kio_addr_t ioaddr = dev->base_addr;
1742     int rx_status;
1743     int packet_length;  /* Caution: not frame length, rather words
1744                            to transfer from the chip. */
1745
1746     /* Assertion: we are in Window 2. */
1747
1748     if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1749         printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1750                dev->name);
1751         return;
1752     }
1753
1754     /*  Reset the read pointer, and read the status and packet length. */
1755     outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1756     rx_status = inw(ioaddr + DATA_1);
1757     packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1758
1759     DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1760           dev->name, rx_status, packet_length);
1761
1762     if (!(rx_status & RS_ERRORS)) {
1763         /* do stuff to make a new packet */
1764         struct sk_buff *skb;
1765
1766         /* Note: packet_length adds 5 or 6 extra bytes here! */
1767         skb = dev_alloc_skb(packet_length+2);
1768
1769         if (skb == NULL) {
1770             DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1771             smc->stats.rx_dropped++;
1772             outw(MC_RELEASE, ioaddr + MMU_CMD);
1773             return;
1774         }
1775
1776         packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1777         skb_reserve(skb, 2);
1778         insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1779              (packet_length+1)>>1);
1780         skb->protocol = eth_type_trans(skb, dev);
1781
1782         skb->dev = dev;
1783         netif_rx(skb);
1784         dev->last_rx = jiffies;
1785         smc->stats.rx_packets++;
1786         smc->stats.rx_bytes += packet_length;
1787         if (rx_status & RS_MULTICAST)
1788             smc->stats.multicast++;
1789     } else {
1790         /* error ... */
1791         smc->stats.rx_errors++;
1792
1793         if (rx_status & RS_ALGNERR)  smc->stats.rx_frame_errors++;
1794         if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1795             smc->stats.rx_length_errors++;
1796         if (rx_status & RS_BADCRC)      smc->stats.rx_crc_errors++;
1797     }
1798     /* Let the MMU free the memory of this packet. */
1799     outw(MC_RELEASE, ioaddr + MMU_CMD);
1800
1801     return;
1802 }
1803
1804 /*====================================================================*/
1805
1806 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1807 {
1808     struct smc_private *smc = netdev_priv(dev);
1809     /* Nothing to update - the 91c92 is a pretty primative chip. */
1810     return &smc->stats;
1811 }
1812
1813 /*======================================================================
1814
1815     Calculate values for the hardware multicast filter hash table.
1816
1817 ======================================================================*/
1818
1819 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1820                                u_char *multicast_table)
1821 {
1822     struct dev_mc_list  *mc_addr;
1823
1824     for (mc_addr = addrs;  mc_addr && count-- > 0;  mc_addr = mc_addr->next) {
1825         u_int position = ether_crc(6, mc_addr->dmi_addr);
1826 #ifndef final_version           /* Verify multicast address. */
1827         if ((mc_addr->dmi_addr[0] & 1) == 0)
1828             continue;
1829 #endif
1830         multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1831     }
1832 }
1833
1834 /*======================================================================
1835
1836     Set the receive mode.
1837
1838     This routine is used by both the protocol level to notify us of
1839     promiscuous/multicast mode changes, and by the open/reset code to
1840     initialize the Rx registers.  We always set the multicast list and
1841     leave the receiver running.
1842
1843 ======================================================================*/
1844
1845 static void set_rx_mode(struct net_device *dev)
1846 {
1847     kio_addr_t ioaddr = dev->base_addr;
1848     struct smc_private *smc = netdev_priv(dev);
1849     u_int multicast_table[ 2 ] = { 0, };
1850     unsigned long flags;
1851     u_short rx_cfg_setting;
1852
1853     if (dev->flags & IFF_PROMISC) {
1854         printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.\n", dev->name);
1855         rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1856     } else if (dev->flags & IFF_ALLMULTI)
1857         rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1858     else {
1859         if (dev->mc_count)  {
1860             fill_multicast_tbl(dev->mc_count, dev->mc_list,
1861                                (u_char *)multicast_table);
1862         }
1863         rx_cfg_setting = RxStripCRC | RxEnable;
1864     }
1865
1866     /* Load MC table and Rx setting into the chip without interrupts. */
1867     spin_lock_irqsave(&smc->lock, flags);
1868     SMC_SELECT_BANK(3);
1869     outl(multicast_table[0], ioaddr + MULTICAST0);
1870     outl(multicast_table[1], ioaddr + MULTICAST4);
1871     SMC_SELECT_BANK(0);
1872     outw(rx_cfg_setting, ioaddr + RCR);
1873     SMC_SELECT_BANK(2);
1874     spin_unlock_irqrestore(&smc->lock, flags);
1875
1876     return;
1877 }
1878
1879 /*======================================================================
1880
1881     Senses when a card's config changes. Here, it's coax or TP.
1882
1883 ======================================================================*/
1884
1885 static int s9k_config(struct net_device *dev, struct ifmap *map)
1886 {
1887     struct smc_private *smc = netdev_priv(dev);
1888     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1889         if (smc->cfg & CFG_MII_SELECT)
1890             return -EOPNOTSUPP;
1891         else if (map->port > 2)
1892             return -EINVAL;
1893         dev->if_port = map->port;
1894         printk(KERN_INFO "%s: switched to %s port\n",
1895                dev->name, if_names[dev->if_port]);
1896         smc_reset(dev);
1897     }
1898     return 0;
1899 }
1900
1901 /*======================================================================
1902
1903     Reset the chip, reloading every register that might be corrupted.
1904
1905 ======================================================================*/
1906
1907 /*
1908   Set transceiver type, perhaps to something other than what the user
1909   specified in dev->if_port.
1910 */
1911 static void smc_set_xcvr(struct net_device *dev, int if_port)
1912 {
1913     struct smc_private *smc = netdev_priv(dev);
1914     kio_addr_t ioaddr = dev->base_addr;
1915     u_short saved_bank;
1916
1917     saved_bank = inw(ioaddr + BANK_SELECT);
1918     SMC_SELECT_BANK(1);
1919     if (if_port == 2) {
1920         outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1921         if ((smc->manfid == MANFID_OSITECH) &&
1922             (smc->cardid != PRODID_OSITECH_SEVEN))
1923             set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1924         smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1925     } else {
1926         outw(smc->cfg, ioaddr + CONFIG);
1927         if ((smc->manfid == MANFID_OSITECH) &&
1928             (smc->cardid != PRODID_OSITECH_SEVEN))
1929             mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1930         smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1931     }
1932     SMC_SELECT_BANK(saved_bank);
1933 }
1934
1935 static void smc_reset(struct net_device *dev)
1936 {
1937     kio_addr_t ioaddr = dev->base_addr;
1938     struct smc_private *smc = netdev_priv(dev);
1939     int i;
1940
1941     DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1942
1943     /* The first interaction must be a write to bring the chip out
1944        of sleep mode. */
1945     SMC_SELECT_BANK(0);
1946     /* Reset the chip. */
1947     outw(RCR_SOFTRESET, ioaddr + RCR);
1948     udelay(10);
1949
1950     /* Clear the transmit and receive configuration registers. */
1951     outw(RCR_CLEAR, ioaddr + RCR);
1952     outw(TCR_CLEAR, ioaddr + TCR);
1953
1954     /* Set the Window 1 control, configuration and station addr registers.
1955        No point in writing the I/O base register ;-> */
1956     SMC_SELECT_BANK(1);
1957     /* Automatically release succesfully transmitted packets,
1958        Accept link errors, counter and Tx error interrupts. */
1959     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1960          ioaddr + CONTROL);
1961     smc_set_xcvr(dev, dev->if_port);
1962     if ((smc->manfid == MANFID_OSITECH) &&
1963         (smc->cardid != PRODID_OSITECH_SEVEN))
1964         outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1965              (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1966              ioaddr - 0x10 + OSITECH_AUI_PWR);
1967
1968     /* Fill in the physical address.  The databook is wrong about the order! */
1969     for (i = 0; i < 6; i += 2)
1970         outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1971              ioaddr + ADDR0 + i);
1972
1973     /* Reset the MMU */
1974     SMC_SELECT_BANK(2);
1975     outw(MC_RESET, ioaddr + MMU_CMD);
1976     outw(0, ioaddr + INTERRUPT);
1977
1978     /* Re-enable the chip. */
1979     SMC_SELECT_BANK(0);
1980     outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1981          TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1982     set_rx_mode(dev);
1983
1984     if (smc->cfg & CFG_MII_SELECT) {
1985         SMC_SELECT_BANK(3);
1986
1987         /* Reset MII */
1988         mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1989
1990         /* Advertise 100F, 100H, 10F, 10H */
1991         mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1992
1993         /* Restart MII autonegotiation */
1994         mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1995         mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1996     }
1997
1998     /* Enable interrupts. */
1999     SMC_SELECT_BANK(2);
2000     outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
2001          ioaddr + INTERRUPT);
2002 }
2003
2004 /*======================================================================
2005
2006     Media selection timer routine
2007
2008 ======================================================================*/
2009
2010 static void media_check(u_long arg)
2011 {
2012     struct net_device *dev = (struct net_device *) arg;
2013     struct smc_private *smc = netdev_priv(dev);
2014     kio_addr_t ioaddr = dev->base_addr;
2015     u_short i, media, saved_bank;
2016     u_short link;
2017
2018     saved_bank = inw(ioaddr + BANK_SELECT);
2019
2020     if (!netif_device_present(dev))
2021         goto reschedule;
2022
2023     SMC_SELECT_BANK(2);
2024
2025     /* need MC_RESET to keep the memory consistent. errata? */
2026     if (smc->rx_ovrn) {
2027         outw(MC_RESET, ioaddr + MMU_CMD);
2028         smc->rx_ovrn = 0;
2029     }
2030     i = inw(ioaddr + INTERRUPT);
2031     SMC_SELECT_BANK(0);
2032     media = inw(ioaddr + EPH) & EPH_LINK_OK;
2033     SMC_SELECT_BANK(1);
2034     media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
2035
2036     /* Check for pending interrupt with watchdog flag set: with
2037        this, we can limp along even if the interrupt is blocked */
2038     if (smc->watchdog++ && ((i>>8) & i)) {
2039         if (!smc->fast_poll)
2040             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
2041         smc_interrupt(dev->irq, smc, NULL);
2042         smc->fast_poll = HZ;
2043     }
2044     if (smc->fast_poll) {
2045         smc->fast_poll--;
2046         smc->media.expires = jiffies + HZ/100;
2047         add_timer(&smc->media);
2048         SMC_SELECT_BANK(saved_bank);
2049         return;
2050     }
2051
2052     if (smc->cfg & CFG_MII_SELECT) {
2053         if (smc->mii_if.phy_id < 0)
2054             goto reschedule;
2055
2056         SMC_SELECT_BANK(3);
2057         link = mdio_read(dev, smc->mii_if.phy_id, 1);
2058         if (!link || (link == 0xffff)) {
2059             printk(KERN_INFO "%s: MII is missing!\n", dev->name);
2060             smc->mii_if.phy_id = -1;
2061             goto reschedule;
2062         }
2063
2064         link &= 0x0004;
2065         if (link != smc->link_status) {
2066             u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
2067             printk(KERN_INFO "%s: %s link beat\n", dev->name,
2068                 (link) ? "found" : "lost");
2069             smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
2070                            ? TCR_FDUPLX : 0);
2071             if (link) {
2072                 printk(KERN_INFO "%s: autonegotiation complete: "
2073                        "%sbaseT-%cD selected\n", dev->name,
2074                        ((p & 0x0180) ? "100" : "10"),
2075                        (smc->duplex ? 'F' : 'H'));
2076             }
2077             SMC_SELECT_BANK(0);
2078             outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
2079             smc->link_status = link;
2080         }
2081         goto reschedule;
2082     }
2083
2084     /* Ignore collisions unless we've had no rx's recently */
2085     if (time_after(jiffies, dev->last_rx + HZ)) {
2086         if (smc->tx_err || (smc->media_status & EPH_16COL))
2087             media |= EPH_16COL;
2088     }
2089     smc->tx_err = 0;
2090
2091     if (media != smc->media_status) {
2092         if ((media & smc->media_status & 1) &&
2093             ((smc->media_status ^ media) & EPH_LINK_OK))
2094             printk(KERN_INFO "%s: %s link beat\n", dev->name,
2095                    (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
2096         else if ((media & smc->media_status & 2) &&
2097                  ((smc->media_status ^ media) & EPH_16COL))
2098             printk(KERN_INFO "%s: coax cable %s\n", dev->name,
2099                    (media & EPH_16COL ? "problem" : "ok"));
2100         if (dev->if_port == 0) {
2101             if (media & 1) {
2102                 if (media & EPH_LINK_OK)
2103                     printk(KERN_INFO "%s: flipped to 10baseT\n",
2104                            dev->name);
2105                 else
2106                     smc_set_xcvr(dev, 2);
2107             } else {
2108                 if (media & EPH_16COL)
2109                     smc_set_xcvr(dev, 1);
2110                 else
2111                     printk(KERN_INFO "%s: flipped to 10base2\n",
2112                            dev->name);
2113             }
2114         }
2115         smc->media_status = media;
2116     }
2117
2118 reschedule:
2119     smc->media.expires = jiffies + HZ;
2120     add_timer(&smc->media);
2121     SMC_SELECT_BANK(saved_bank);
2122 }
2123
2124 static int smc_link_ok(struct net_device *dev)
2125 {
2126     kio_addr_t ioaddr = dev->base_addr;
2127     struct smc_private *smc = netdev_priv(dev);
2128
2129     if (smc->cfg & CFG_MII_SELECT) {
2130         return mii_link_ok(&smc->mii_if);
2131     } else {
2132         SMC_SELECT_BANK(0);
2133         return inw(ioaddr + EPH) & EPH_LINK_OK;
2134     }
2135 }
2136
2137 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2138 {
2139     u16 tmp;
2140     kio_addr_t ioaddr = dev->base_addr;
2141
2142     ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2143         SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2144
2145     SMC_SELECT_BANK(1);
2146     tmp = inw(ioaddr + CONFIG);
2147     ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2148     ecmd->transceiver = XCVR_INTERNAL;
2149     ecmd->speed = SPEED_10;
2150     ecmd->phy_address = ioaddr + MGMT;
2151
2152     SMC_SELECT_BANK(0);
2153     tmp = inw(ioaddr + TCR);
2154     ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2155
2156     return 0;
2157 }
2158
2159 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2160 {
2161     u16 tmp;
2162     kio_addr_t ioaddr = dev->base_addr;
2163
2164     if (ecmd->speed != SPEED_10)
2165         return -EINVAL;
2166     if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2167         return -EINVAL;
2168     if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2169         return -EINVAL;
2170     if (ecmd->transceiver != XCVR_INTERNAL)
2171         return -EINVAL;
2172
2173     if (ecmd->port == PORT_AUI)
2174         smc_set_xcvr(dev, 1);
2175     else
2176         smc_set_xcvr(dev, 0);
2177
2178     SMC_SELECT_BANK(0);
2179     tmp = inw(ioaddr + TCR);
2180     if (ecmd->duplex == DUPLEX_FULL)
2181         tmp |= TCR_FDUPLX;
2182     else
2183         tmp &= ~TCR_FDUPLX;
2184     outw(tmp, ioaddr + TCR);
2185
2186     return 0;
2187 }
2188
2189 static int check_if_running(struct net_device *dev)
2190 {
2191         if (!netif_running(dev))
2192                 return -EINVAL;
2193         return 0;
2194 }
2195
2196 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2197 {
2198         strcpy(info->driver, DRV_NAME);
2199         strcpy(info->version, DRV_VERSION);
2200 }
2201
2202 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2203 {
2204         struct smc_private *smc = netdev_priv(dev);
2205         kio_addr_t ioaddr = dev->base_addr;
2206         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2207         int ret;
2208
2209         SMC_SELECT_BANK(3);
2210         spin_lock_irq(&smc->lock);
2211         if (smc->cfg & CFG_MII_SELECT)
2212                 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2213         else
2214                 ret = smc_netdev_get_ecmd(dev, ecmd);
2215         spin_unlock_irq(&smc->lock);
2216         SMC_SELECT_BANK(saved_bank);
2217         return ret;
2218 }
2219
2220 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2221 {
2222         struct smc_private *smc = netdev_priv(dev);
2223         kio_addr_t ioaddr = dev->base_addr;
2224         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2225         int ret;
2226
2227         SMC_SELECT_BANK(3);
2228         spin_lock_irq(&smc->lock);
2229         if (smc->cfg & CFG_MII_SELECT)
2230                 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2231         else
2232                 ret = smc_netdev_set_ecmd(dev, ecmd);
2233         spin_unlock_irq(&smc->lock);
2234         SMC_SELECT_BANK(saved_bank);
2235         return ret;
2236 }
2237
2238 static u32 smc_get_link(struct net_device *dev)
2239 {
2240         struct smc_private *smc = netdev_priv(dev);
2241         kio_addr_t ioaddr = dev->base_addr;
2242         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2243         u32 ret;
2244
2245         SMC_SELECT_BANK(3);
2246         spin_lock_irq(&smc->lock);
2247         ret = smc_link_ok(dev);
2248         spin_unlock_irq(&smc->lock);
2249         SMC_SELECT_BANK(saved_bank);
2250         return ret;
2251 }
2252
2253 #ifdef PCMCIA_DEBUG
2254 static u32 smc_get_msglevel(struct net_device *dev)
2255 {
2256         return pc_debug;
2257 }
2258
2259 static void smc_set_msglevel(struct net_device *dev, u32 val)
2260 {
2261         pc_debug = val;
2262 }
2263 #endif
2264
2265 static int smc_nway_reset(struct net_device *dev)
2266 {
2267         struct smc_private *smc = netdev_priv(dev);
2268         if (smc->cfg & CFG_MII_SELECT) {
2269                 kio_addr_t ioaddr = dev->base_addr;
2270                 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2271                 int res;
2272
2273                 SMC_SELECT_BANK(3);
2274                 res = mii_nway_restart(&smc->mii_if);
2275                 SMC_SELECT_BANK(saved_bank);
2276
2277                 return res;
2278         } else
2279                 return -EOPNOTSUPP;
2280 }
2281
2282 static struct ethtool_ops ethtool_ops = {
2283         .begin = check_if_running,
2284         .get_drvinfo = smc_get_drvinfo,
2285         .get_settings = smc_get_settings,
2286         .set_settings = smc_set_settings,
2287         .get_link = smc_get_link,
2288 #ifdef PCMCIA_DEBUG
2289         .get_msglevel = smc_get_msglevel,
2290         .set_msglevel = smc_set_msglevel,
2291 #endif
2292         .nway_reset = smc_nway_reset,
2293 };
2294
2295 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2296 {
2297         struct smc_private *smc = netdev_priv(dev);
2298         struct mii_ioctl_data *mii = if_mii(rq);
2299         int rc = 0;
2300         u16 saved_bank;
2301         kio_addr_t ioaddr = dev->base_addr;
2302
2303         if (!netif_running(dev))
2304                 return -EINVAL;
2305
2306         spin_lock_irq(&smc->lock);
2307         saved_bank = inw(ioaddr + BANK_SELECT);
2308         SMC_SELECT_BANK(3);
2309         rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2310         SMC_SELECT_BANK(saved_bank);
2311         spin_unlock_irq(&smc->lock);
2312         return rc;
2313 }
2314
2315 static struct pcmcia_device_id smc91c92_ids[] = {
2316         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2317         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2318         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2319         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2320         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2321         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2322         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2323         PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2324         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2325         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2326         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2327         PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2328         PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2329         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2330         PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2331         PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2332         PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2333         PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2334         PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2335         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2336         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2337         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2338         PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2339         PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2340         /* These conflict with other cards! */
2341         /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2342         /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2343         PCMCIA_DEVICE_NULL,
2344 };
2345 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2346
2347 static struct pcmcia_driver smc91c92_cs_driver = {
2348         .owner          = THIS_MODULE,
2349         .drv            = {
2350                 .name   = "smc91c92_cs",
2351         },
2352         .attach         = smc91c92_attach,
2353         .event          = smc91c92_event,
2354         .remove         = smc91c92_detach,
2355         .id_table       = smc91c92_ids,
2356         .suspend        = smc91c92_suspend,
2357         .resume         = smc91c92_resume,
2358 };
2359
2360 static int __init init_smc91c92_cs(void)
2361 {
2362         return pcmcia_register_driver(&smc91c92_cs_driver);
2363 }
2364
2365 static void __exit exit_smc91c92_cs(void)
2366 {
2367         pcmcia_unregister_driver(&smc91c92_cs_driver);
2368 }
2369
2370 module_init(init_smc91c92_cs);
2371 module_exit(exit_smc91c92_cs);