SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/pcmcia/smc91c92_cs.c

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