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