drivers/net/pcmcia/smc91c92_cs.c

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