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