drivers/net/pcmcia/smc91c92_cs.c

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