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         if ((link->state & DEV_CONFIG) && (link->open))
 878                 netif_device_detach(dev);
 879
 880         return 0;
 881 }
 882
 883 static int smc91c92_resume(struct pcmcia_device *p_dev)
 884 {
 885         dev_link_t *link = dev_to_instance(p_dev);
 886         struct net_device *dev = link->priv;
 887         struct smc_private *smc = netdev_priv(dev);
 888         int i;
 889
 890         if (link->state & DEV_CONFIG) {
 891                 if ((smc->manfid == MANFID_MEGAHERTZ) &&
 892                     (smc->cardid == PRODID_MEGAHERTZ_EM3288))
 893                         mhz_3288_power(link);
 894                 if (smc->manfid == MANFID_MOTOROLA)
 895                         mot_config(link);
 896                 if ((smc->manfid == MANFID_OSITECH) &&
 897                     (smc->cardid != PRODID_OSITECH_SEVEN)) {
 898                         /* Power up the card and enable interrupts */
 899                         set_bits(0x0300, dev->base_addr-0x10+OSITECH_AUI_PWR);
 900                         set_bits(0x0300, dev->base_addr-0x10+OSITECH_RESET_ISR);
 901                 }
 902                 if (((smc->manfid == MANFID_OSITECH) &&
 903                      (smc->cardid == PRODID_OSITECH_SEVEN)) ||
 904                     ((smc->manfid == MANFID_PSION) &&
 905                      (smc->cardid == PRODID_PSION_NET100))) {
 906                         /* Download the Seven of Diamonds firmware */
 907                         for (i = 0; i < sizeof(__Xilinx7OD); i++) {
 908                                 outb(__Xilinx7OD[i], link->io.BasePort1+2);
 909                                 udelay(50);
 910                         }
 911                 }
 912                 if (link->open) {
 913                         smc_reset(dev);
 914                         netif_device_attach(dev);
 915                 }
 916         }
 917
 918         return 0;
 919 }
 920
 921
 922 /*======================================================================
 923
 924     This verifies that the chip is some SMC91cXX variant, and returns
 925     the revision code if successful.  Otherwise, it returns -ENODEV.
 926
 927 ======================================================================*/
 928
 929 static int check_sig(dev_link_t *link)
 930 {
 931     struct net_device *dev = link->priv;
 932     kio_addr_t ioaddr = dev->base_addr;
 933     int width;
 934     u_short s;
 935
 936     SMC_SELECT_BANK(1);
 937     if (inw(ioaddr + BANK_SELECT) >> 8 != 0x33) {
 938         /* Try powering up the chip */
 939         outw(0, ioaddr + CONTROL);
 940         mdelay(55);
 941     }
 942
 943     /* Try setting bus width */
 944     width = (link->io.Attributes1 == IO_DATA_PATH_WIDTH_AUTO);
 945     s = inb(ioaddr + CONFIG);
 946     if (width)
 947         s |= CFG_16BIT;
 948     else
 949         s &= ~CFG_16BIT;
 950     outb(s, ioaddr + CONFIG);
 951
 952     /* Check Base Address Register to make sure bus width is OK */
 953     s = inw(ioaddr + BASE_ADDR);
 954     if ((inw(ioaddr + BANK_SELECT) >> 8 == 0x33) &&
 955         ((s >> 8) != (s & 0xff))) {
 956         SMC_SELECT_BANK(3);
 957         s = inw(ioaddr + REVISION);
 958         return (s & 0xff);
 959     }
 960
 961     if (width) {
 962             modconf_t mod = {
 963                     .Attributes = CONF_IO_CHANGE_WIDTH,
 964             };
 965             printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
 966
 967             smc91c92_suspend(link->handle);
 968             pcmcia_modify_configuration(link->handle, &mod);
 969             smc91c92_resume(link->handle);
 970             return check_sig(link);
 971     }
 972     return -ENODEV;
 973 }
 974
 975 /*======================================================================
 976
 977     smc91c92_config() is scheduled to run after a CARD_INSERTION event
 978     is received, to configure the PCMCIA socket, and to make the
 979     ethernet device available to the system.
 980
 981 ======================================================================*/
 982
 983 #define CS_EXIT_TEST(ret, svc, label) \
 984 if (ret != CS_SUCCESS) { cs_error(link->handle, svc, ret); goto label; }
 985
 986 static void smc91c92_config(dev_link_t *link)
 987 {
 988     client_handle_t handle = link->handle;
 989     struct net_device *dev = link->priv;
 990     struct smc_private *smc = netdev_priv(dev);
 991     struct smc_cfg_mem *cfg_mem;
 992     tuple_t *tuple;
 993     cisparse_t *parse;
 994     u_char *buf;
 995     char *name;
 996     int i, j, rev;
 997     kio_addr_t ioaddr;
 998     u_long mir;
 999
1000     DEBUG(0, "smc91c92_config(0x%p)\n", link);
1001
1002     cfg_mem = kmalloc(sizeof(struct smc_cfg_mem), GFP_KERNEL);
1003     if (!cfg_mem)
1004         goto config_failed;
1005
1006     tuple = &cfg_mem->tuple;
1007     parse = &cfg_mem->parse;
1008     buf = cfg_mem->buf;
1009
1010     tuple->Attributes = tuple->TupleOffset = 0;
1011     tuple->TupleData = (cisdata_t *)buf;
1012     tuple->TupleDataMax = 64;
1013
1014     tuple->DesiredTuple = CISTPL_CONFIG;
1015     i = first_tuple(handle, tuple, parse);
1016     CS_EXIT_TEST(i, ParseTuple, config_failed);
1017     link->conf.ConfigBase = parse->config.base;
1018     link->conf.Present = parse->config.rmask[0];
1019
1020     tuple->DesiredTuple = CISTPL_MANFID;
1021     tuple->Attributes = TUPLE_RETURN_COMMON;
1022     if (first_tuple(handle, tuple, parse) == CS_SUCCESS) {
1023         smc->manfid = parse->manfid.manf;
1024         smc->cardid = parse->manfid.card;
1025     }
1026
1027     /* Configure card */
1028     link->state |= DEV_CONFIG;
1029
1030     if ((smc->manfid == MANFID_OSITECH) &&
1031         (smc->cardid != PRODID_OSITECH_SEVEN)) {
1032         i = osi_config(link);
1033     } else if ((smc->manfid == MANFID_MOTOROLA) ||
1034                ((smc->manfid == MANFID_MEGAHERTZ) &&
1035                 ((smc->cardid == PRODID_MEGAHERTZ_VARIOUS) ||
1036                  (smc->cardid == PRODID_MEGAHERTZ_EM3288)))) {
1037         i = mhz_mfc_config(link);
1038     } else {
1039         i = smc_config(link);
1040     }
1041     CS_EXIT_TEST(i, RequestIO, config_failed);
1042
1043     i = pcmcia_request_irq(link->handle, &link->irq);
1044     CS_EXIT_TEST(i, RequestIRQ, config_failed);
1045     i = pcmcia_request_configuration(link->handle, &link->conf);
1046     CS_EXIT_TEST(i, RequestConfiguration, config_failed);
1047
1048     if (smc->manfid == MANFID_MOTOROLA)
1049         mot_config(link);
1050
1051     dev->irq = link->irq.AssignedIRQ;
1052
1053     if ((if_port >= 0) && (if_port <= 2))
1054         dev->if_port = if_port;
1055     else
1056         printk(KERN_NOTICE "smc91c92_cs: invalid if_port requested\n");
1057
1058     switch (smc->manfid) {
1059     case MANFID_OSITECH:
1060     case MANFID_PSION:
1061         i = osi_setup(link, smc->manfid, smc->cardid); break;
1062     case MANFID_SMC:
1063     case MANFID_NEW_MEDIA:
1064         i = smc_setup(link); break;
1065     case 0x128: /* For broken Megahertz cards */
1066     case MANFID_MEGAHERTZ:
1067         i = mhz_setup(link); break;
1068     case MANFID_MOTOROLA:
1069     default: /* get the hw address from EEPROM */
1070         i = mot_setup(link); break;
1071     }
1072
1073     if (i != 0) {
1074         printk(KERN_NOTICE "smc91c92_cs: Unable to find hardware address.\n");
1075         goto config_undo;
1076     }
1077
1078     smc->duplex = 0;
1079     smc->rx_ovrn = 0;
1080
1081     rev = check_sig(link);
1082     name = "???";
1083     if (rev > 0)
1084         switch (rev >> 4) {
1085         case 3: name = "92"; break;
1086         case 4: name = ((rev & 15) >= 6) ? "96" : "94"; break;
1087         case 5: name = "95"; break;
1088         case 7: name = "100"; break;
1089         case 8: name = "100-FD"; break;
1090         case 9: name = "110"; break;
1091         }
1092
1093     ioaddr = dev->base_addr;
1094     if (rev > 0) {
1095         u_long mcr;
1096         SMC_SELECT_BANK(0);
1097         mir = inw(ioaddr + MEMINFO) & 0xff;
1098         if (mir == 0xff) mir++;
1099         /* Get scale factor for memory size */
1100         mcr = ((rev >> 4) > 3) ? inw(ioaddr + MEMCFG) : 0x0200;
1101         mir *= 128 * (1<<((mcr >> 9) & 7));
1102         SMC_SELECT_BANK(1);
1103         smc->cfg = inw(ioaddr + CONFIG) & ~CFG_AUI_SELECT;
1104         smc->cfg |= CFG_NO_WAIT | CFG_16BIT | CFG_STATIC;
1105         if (smc->manfid == MANFID_OSITECH)
1106             smc->cfg |= CFG_IRQ_SEL_1 | CFG_IRQ_SEL_0;
1107         if ((rev >> 4) >= 7)
1108             smc->cfg |= CFG_MII_SELECT;
1109     } else
1110         mir = 0;
1111
1112     if (smc->cfg & CFG_MII_SELECT) {
1113         SMC_SELECT_BANK(3);
1114
1115         for (i = 0; i < 32; i++) {
1116             j = mdio_read(dev, i, 1);
1117             if ((j != 0) && (j != 0xffff)) break;
1118         }
1119         smc->mii_if.phy_id = (i < 32) ? i : -1;
1120
1121         SMC_SELECT_BANK(0);
1122     }
1123
1124     link->dev = &smc->node;
1125     link->state &= ~DEV_CONFIG_PENDING;
1126     SET_NETDEV_DEV(dev, &handle_to_dev(handle));
1127
1128     if (register_netdev(dev) != 0) {
1129         printk(KERN_ERR "smc91c92_cs: register_netdev() failed\n");
1130         link->dev = NULL;
1131         goto config_undo;
1132     }
1133
1134     strcpy(smc->node.dev_name, dev->name);
1135
1136     printk(KERN_INFO "%s: smc91c%s rev %d: io %#3lx, irq %d, "
1137            "hw_addr ", dev->name, name, (rev & 0x0f), dev->base_addr,
1138            dev->irq);
1139     for (i = 0; i < 6; i++)
1140         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
1141
1142     if (rev > 0) {
1143         if (mir & 0x3ff)
1144             printk(KERN_INFO "  %lu byte", mir);
1145         else
1146             printk(KERN_INFO "  %lu kb", mir>>10);
1147         printk(" buffer, %s xcvr\n", (smc->cfg & CFG_MII_SELECT) ?
1148                "MII" : if_names[dev->if_port]);
1149     }
1150
1151     if (smc->cfg & CFG_MII_SELECT) {
1152         if (smc->mii_if.phy_id != -1) {
1153             DEBUG(0, "  MII transceiver at index %d, status %x.\n",
1154                   smc->mii_if.phy_id, j);
1155         } else {
1156             printk(KERN_NOTICE "  No MII transceivers found!\n");
1157         }
1158     }
1159     kfree(cfg_mem);
1160     return;
1161
1162 config_undo:
1163     unregister_netdev(dev);
1164 config_failed:                  /* CS_EXIT_TEST() calls jump to here... */
1165     smc91c92_release(link);
1166     link->state &= ~DEV_CONFIG_PENDING;
1167     kfree(cfg_mem);
1168
1169 } /* smc91c92_config */
1170
1171 /*======================================================================
1172
1173     After a card is removed, smc91c92_release() will unregister the net
1174     device, and release the PCMCIA configuration.  If the device is
1175     still open, this will be postponed until it is closed.
1176
1177 ======================================================================*/
1178
1179 static void smc91c92_release(dev_link_t *link)
1180 {
1181         DEBUG(0, "smc91c92_release(0x%p)\n", link);
1182         if (link->win) {
1183                 struct net_device *dev = link->priv;
1184                 struct smc_private *smc = netdev_priv(dev);
1185                 iounmap(smc->base);
1186         }
1187         pcmcia_disable_device(link->handle);
1188 }
1189
1190 /*======================================================================
1191
1192     MII interface support for SMC91cXX based cards
1193 ======================================================================*/
1194
1195 #define MDIO_SHIFT_CLK          0x04
1196 #define MDIO_DATA_OUT           0x01
1197 #define MDIO_DIR_WRITE          0x08
1198 #define MDIO_DATA_WRITE0        (MDIO_DIR_WRITE)
1199 #define MDIO_DATA_WRITE1        (MDIO_DIR_WRITE | MDIO_DATA_OUT)
1200 #define MDIO_DATA_READ          0x02
1201
1202 static void mdio_sync(kio_addr_t addr)
1203 {
1204     int bits;
1205     for (bits = 0; bits < 32; bits++) {
1206         outb(MDIO_DATA_WRITE1, addr);
1207         outb(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
1208     }
1209 }
1210
1211 static int mdio_read(struct net_device *dev, int phy_id, int loc)
1212 {
1213     kio_addr_t addr = dev->base_addr + MGMT;
1214     u_int cmd = (0x06<<10)|(phy_id<<5)|loc;
1215     int i, retval = 0;
1216
1217     mdio_sync(addr);
1218     for (i = 13; i >= 0; i--) {
1219         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1220         outb(dat, addr);
1221         outb(dat | MDIO_SHIFT_CLK, addr);
1222     }
1223     for (i = 19; i > 0; i--) {
1224         outb(0, addr);
1225         retval = (retval << 1) | ((inb(addr) & MDIO_DATA_READ) != 0);
1226         outb(MDIO_SHIFT_CLK, addr);
1227     }
1228     return (retval>>1) & 0xffff;
1229 }
1230
1231 static void mdio_write(struct net_device *dev, int phy_id, int loc, int value)
1232 {
1233     kio_addr_t addr = dev->base_addr + MGMT;
1234     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
1235     int i;
1236
1237     mdio_sync(addr);
1238     for (i = 31; i >= 0; i--) {
1239         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
1240         outb(dat, addr);
1241         outb(dat | MDIO_SHIFT_CLK, addr);
1242     }
1243     for (i = 1; i >= 0; i--) {
1244         outb(0, addr);
1245         outb(MDIO_SHIFT_CLK, addr);
1246     }
1247 }
1248
1249 /*======================================================================
1250
1251     The driver core code, most of which should be common with a
1252     non-PCMCIA implementation.
1253
1254 ======================================================================*/
1255
1256 #ifdef PCMCIA_DEBUG
1257 static void smc_dump(struct net_device *dev)
1258 {
1259     kio_addr_t ioaddr = dev->base_addr;
1260     u_short i, w, save;
1261     save = inw(ioaddr + BANK_SELECT);
1262     for (w = 0; w < 4; w++) {
1263         SMC_SELECT_BANK(w);
1264         printk(KERN_DEBUG "bank %d: ", w);
1265         for (i = 0; i < 14; i += 2)
1266             printk(" %04x", inw(ioaddr + i));
1267         printk("\n");
1268     }
1269     outw(save, ioaddr + BANK_SELECT);
1270 }
1271 #endif
1272
1273 static int smc_open(struct net_device *dev)
1274 {
1275     struct smc_private *smc = netdev_priv(dev);
1276     dev_link_t *link = &smc->link;
1277
1278 #ifdef PCMCIA_DEBUG
1279     DEBUG(0, "%s: smc_open(%p), ID/Window %4.4x.\n",
1280           dev->name, dev, inw(dev->base_addr + BANK_SELECT));
1281     if (pc_debug > 1) smc_dump(dev);
1282 #endif
1283
1284     /* Check that the PCMCIA card is still here. */
1285     if (!DEV_OK(link))
1286         return -ENODEV;
1287     /* Physical device present signature. */
1288     if (check_sig(link) < 0) {
1289         printk("smc91c92_cs: Yikes!  Bad chip signature!\n");
1290         return -ENODEV;
1291     }
1292     link->open++;
1293
1294     netif_start_queue(dev);
1295     smc->saved_skb = NULL;
1296     smc->packets_waiting = 0;
1297
1298     smc_reset(dev);
1299     init_timer(&smc->media);
1300     smc->media.function = &media_check;
1301     smc->media.data = (u_long) dev;
1302     smc->media.expires = jiffies + HZ;
1303     add_timer(&smc->media);
1304
1305     return 0;
1306 } /* smc_open */
1307
1308 /*====================================================================*/
1309
1310 static int smc_close(struct net_device *dev)
1311 {
1312     struct smc_private *smc = netdev_priv(dev);
1313     dev_link_t *link = &smc->link;
1314     kio_addr_t ioaddr = dev->base_addr;
1315
1316     DEBUG(0, "%s: smc_close(), status %4.4x.\n",
1317           dev->name, inw(ioaddr + BANK_SELECT));
1318
1319     netif_stop_queue(dev);
1320
1321     /* Shut off all interrupts, and turn off the Tx and Rx sections.
1322        Don't bother to check for chip present. */
1323     SMC_SELECT_BANK(2); /* Nominally paranoia, but do no assume... */
1324     outw(0, ioaddr + INTERRUPT);
1325     SMC_SELECT_BANK(0);
1326     mask_bits(0xff00, ioaddr + RCR);
1327     mask_bits(0xff00, ioaddr + TCR);
1328
1329     /* Put the chip into power-down mode. */
1330     SMC_SELECT_BANK(1);
1331     outw(CTL_POWERDOWN, ioaddr + CONTROL );
1332
1333     link->open--;
1334     del_timer_sync(&smc->media);
1335
1336     return 0;
1337 } /* smc_close */
1338
1339 /*======================================================================
1340
1341    Transfer a packet to the hardware and trigger the packet send.
1342    This may be called at either from either the Tx queue code
1343    or the interrupt handler.
1344
1345 ======================================================================*/
1346
1347 static void smc_hardware_send_packet(struct net_device * dev)
1348 {
1349     struct smc_private *smc = netdev_priv(dev);
1350     struct sk_buff *skb = smc->saved_skb;
1351     kio_addr_t ioaddr = dev->base_addr;
1352     u_char packet_no;
1353
1354     if (!skb) {
1355         printk(KERN_ERR "%s: In XMIT with no packet to send.\n", dev->name);
1356         return;
1357     }
1358
1359     /* There should be a packet slot waiting. */
1360     packet_no = inw(ioaddr + PNR_ARR) >> 8;
1361     if (packet_no & 0x80) {
1362         /* If not, there is a hardware problem!  Likely an ejected card. */
1363         printk(KERN_WARNING "%s: 91c92 hardware Tx buffer allocation"
1364                " failed, status %#2.2x.\n", dev->name, packet_no);
1365         dev_kfree_skb_irq(skb);
1366         smc->saved_skb = NULL;
1367         netif_start_queue(dev);
1368         return;
1369     }
1370
1371     smc->stats.tx_bytes += skb->len;
1372     /* The card should use the just-allocated buffer. */
1373     outw(packet_no, ioaddr + PNR_ARR);
1374     /* point to the beginning of the packet */
1375     outw(PTR_AUTOINC , ioaddr + POINTER);
1376
1377     /* Send the packet length (+6 for status, length and ctl byte)
1378        and the status word (set to zeros). */
1379     {
1380         u_char *buf = skb->data;
1381         u_int length = skb->len; /* The chip will pad to ethernet min. */
1382
1383         DEBUG(2, "%s: Trying to xmit packet of length %d.\n",
1384               dev->name, length);
1385
1386         /* send the packet length: +6 for status word, length, and ctl */
1387         outw(0, ioaddr + DATA_1);
1388         outw(length + 6, ioaddr + DATA_1);
1389         outsw(ioaddr + DATA_1, buf, length >> 1);
1390
1391         /* The odd last byte, if there is one, goes in the control word. */
1392         outw((length & 1) ? 0x2000 | buf[length-1] : 0, ioaddr + DATA_1);
1393     }
1394
1395     /* Enable the Tx interrupts, both Tx (TxErr) and TxEmpty. */
1396     outw(((IM_TX_INT|IM_TX_EMPTY_INT)<<8) |
1397          (inw(ioaddr + INTERRUPT) & 0xff00),
1398          ioaddr + INTERRUPT);
1399
1400     /* The chip does the rest of the work. */
1401     outw(MC_ENQUEUE , ioaddr + MMU_CMD);
1402
1403     smc->saved_skb = NULL;
1404     dev_kfree_skb_irq(skb);
1405     dev->trans_start = jiffies;
1406     netif_start_queue(dev);
1407     return;
1408 }
1409
1410 /*====================================================================*/
1411
1412 static void smc_tx_timeout(struct net_device *dev)
1413 {
1414     struct smc_private *smc = netdev_priv(dev);
1415     kio_addr_t ioaddr = dev->base_addr;
1416
1417     printk(KERN_NOTICE "%s: SMC91c92 transmit timed out, "
1418            "Tx_status %2.2x status %4.4x.\n",
1419            dev->name, inw(ioaddr)&0xff, inw(ioaddr + 2));
1420     smc->stats.tx_errors++;
1421     smc_reset(dev);
1422     dev->trans_start = jiffies;
1423     smc->saved_skb = NULL;
1424     netif_wake_queue(dev);
1425 }
1426
1427 static int smc_start_xmit(struct sk_buff *skb, struct net_device *dev)
1428 {
1429     struct smc_private *smc = netdev_priv(dev);
1430     kio_addr_t ioaddr = dev->base_addr;
1431     u_short num_pages;
1432     short time_out, ir;
1433
1434     netif_stop_queue(dev);
1435
1436     DEBUG(2, "%s: smc_start_xmit(length = %d) called,"
1437           " status %4.4x.\n", dev->name, skb->len, inw(ioaddr + 2));
1438
1439     if (smc->saved_skb) {
1440         /* THIS SHOULD NEVER HAPPEN. */
1441         smc->stats.tx_aborted_errors++;
1442         printk(KERN_DEBUG "%s: Internal error -- sent packet while busy.\n",
1443                dev->name);
1444         return 1;
1445     }
1446     smc->saved_skb = skb;
1447
1448     num_pages = skb->len >> 8;
1449
1450     if (num_pages > 7) {
1451         printk(KERN_ERR "%s: Far too big packet error.\n", dev->name);
1452         dev_kfree_skb (skb);
1453         smc->saved_skb = NULL;
1454         smc->stats.tx_dropped++;
1455         return 0;               /* Do not re-queue this packet. */
1456     }
1457     /* A packet is now waiting. */
1458     smc->packets_waiting++;
1459
1460     SMC_SELECT_BANK(2); /* Paranoia, we should always be in window 2 */
1461
1462     /* need MC_RESET to keep the memory consistent. errata? */
1463     if (smc->rx_ovrn) {
1464         outw(MC_RESET, ioaddr + MMU_CMD);
1465         smc->rx_ovrn = 0;
1466     }
1467
1468     /* Allocate the memory; send the packet now if we win. */
1469     outw(MC_ALLOC | num_pages, ioaddr + MMU_CMD);
1470     for (time_out = MEMORY_WAIT_TIME; time_out >= 0; time_out--) {
1471         ir = inw(ioaddr+INTERRUPT);
1472         if (ir & IM_ALLOC_INT) {
1473             /* Acknowledge the interrupt, send the packet. */
1474             outw((ir&0xff00) | IM_ALLOC_INT, ioaddr + INTERRUPT);
1475             smc_hardware_send_packet(dev);      /* Send the packet now.. */
1476             return 0;
1477         }
1478     }
1479
1480     /* Otherwise defer until the Tx-space-allocated interrupt. */
1481     DEBUG(2, "%s: memory allocation deferred.\n", dev->name);
1482     outw((IM_ALLOC_INT << 8) | (ir & 0xff00), ioaddr + INTERRUPT);
1483
1484     return 0;
1485 }
1486
1487 /*======================================================================
1488
1489     Handle a Tx anomolous event.  Entered while in Window 2.
1490
1491 ======================================================================*/
1492
1493 static void smc_tx_err(struct net_device * dev)
1494 {
1495     struct smc_private *smc = netdev_priv(dev);
1496     kio_addr_t ioaddr = dev->base_addr;
1497     int saved_packet = inw(ioaddr + PNR_ARR) & 0xff;
1498     int packet_no = inw(ioaddr + FIFO_PORTS) & 0x7f;
1499     int tx_status;
1500
1501     /* select this as the packet to read from */
1502     outw(packet_no, ioaddr + PNR_ARR);
1503
1504     /* read the first word from this packet */
1505     outw(PTR_AUTOINC | PTR_READ | 0, ioaddr + POINTER);
1506
1507     tx_status = inw(ioaddr + DATA_1);
1508
1509     smc->stats.tx_errors++;
1510     if (tx_status & TS_LOSTCAR) smc->stats.tx_carrier_errors++;
1511     if (tx_status & TS_LATCOL)  smc->stats.tx_window_errors++;
1512     if (tx_status & TS_16COL) {
1513         smc->stats.tx_aborted_errors++;
1514         smc->tx_err++;
1515     }
1516
1517     if (tx_status & TS_SUCCESS) {
1518         printk(KERN_NOTICE "%s: Successful packet caused error "
1519                "interrupt?\n", dev->name);
1520     }
1521     /* re-enable transmit */
1522     SMC_SELECT_BANK(0);
1523     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1524     SMC_SELECT_BANK(2);
1525
1526     outw(MC_FREEPKT, ioaddr + MMU_CMD);         /* Free the packet memory. */
1527
1528     /* one less packet waiting for me */
1529     smc->packets_waiting--;
1530
1531     outw(saved_packet, ioaddr + PNR_ARR);
1532     return;
1533 }
1534
1535 /*====================================================================*/
1536
1537 static void smc_eph_irq(struct net_device *dev)
1538 {
1539     struct smc_private *smc = netdev_priv(dev);
1540     kio_addr_t ioaddr = dev->base_addr;
1541     u_short card_stats, ephs;
1542
1543     SMC_SELECT_BANK(0);
1544     ephs = inw(ioaddr + EPH);
1545     DEBUG(2, "%s: Ethernet protocol handler interrupt, status"
1546           " %4.4x.\n", dev->name, ephs);
1547     /* Could be a counter roll-over warning: update stats. */
1548     card_stats = inw(ioaddr + COUNTER);
1549     /* single collisions */
1550     smc->stats.collisions += card_stats & 0xF;
1551     card_stats >>= 4;
1552     /* multiple collisions */
1553     smc->stats.collisions += card_stats & 0xF;
1554 #if 0           /* These are for when linux supports these statistics */
1555     card_stats >>= 4;                   /* deferred */
1556     card_stats >>= 4;                   /* excess deferred */
1557 #endif
1558     /* If we had a transmit error we must re-enable the transmitter. */
1559     outw(inw(ioaddr + TCR) | TCR_ENABLE | smc->duplex, ioaddr + TCR);
1560
1561     /* Clear a link error interrupt. */
1562     SMC_SELECT_BANK(1);
1563     outw(CTL_AUTO_RELEASE | 0x0000, ioaddr + CONTROL);
1564     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1565          ioaddr + CONTROL);
1566     SMC_SELECT_BANK(2);
1567 }
1568
1569 /*====================================================================*/
1570
1571 static irqreturn_t smc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1572 {
1573     struct net_device *dev = dev_id;
1574     struct smc_private *smc = netdev_priv(dev);
1575     kio_addr_t ioaddr;
1576     u_short saved_bank, saved_pointer, mask, status;
1577     unsigned int handled = 1;
1578     char bogus_cnt = INTR_WORK;         /* Work we are willing to do. */
1579
1580     if (!netif_device_present(dev))
1581         return IRQ_NONE;
1582
1583     ioaddr = dev->base_addr;
1584
1585     DEBUG(3, "%s: SMC91c92 interrupt %d at %#x.\n", dev->name,
1586           irq, ioaddr);
1587
1588     smc->watchdog = 0;
1589     saved_bank = inw(ioaddr + BANK_SELECT);
1590     if ((saved_bank & 0xff00) != 0x3300) {
1591         /* The device does not exist -- the card could be off-line, or
1592            maybe it has been ejected. */
1593         DEBUG(1, "%s: SMC91c92 interrupt %d for non-existent"
1594               "/ejected device.\n", dev->name, irq);
1595         handled = 0;
1596         goto irq_done;
1597     }
1598
1599     SMC_SELECT_BANK(2);
1600     saved_pointer = inw(ioaddr + POINTER);
1601     mask = inw(ioaddr + INTERRUPT) >> 8;
1602     /* clear all interrupts */
1603     outw(0, ioaddr + INTERRUPT);
1604
1605     do { /* read the status flag, and mask it */
1606         status = inw(ioaddr + INTERRUPT) & 0xff;
1607         DEBUG(3, "%s: Status is %#2.2x (mask %#2.2x).\n", dev->name,
1608               status, mask);
1609         if ((status & mask) == 0) {
1610             if (bogus_cnt == INTR_WORK)
1611                 handled = 0;
1612             break;
1613         }
1614         if (status & IM_RCV_INT) {
1615             /* Got a packet(s). */
1616             smc_rx(dev);
1617         }
1618         if (status & IM_TX_INT) {
1619             smc_tx_err(dev);
1620             outw(IM_TX_INT, ioaddr + INTERRUPT);
1621         }
1622         status &= mask;
1623         if (status & IM_TX_EMPTY_INT) {
1624             outw(IM_TX_EMPTY_INT, ioaddr + INTERRUPT);
1625             mask &= ~IM_TX_EMPTY_INT;
1626             smc->stats.tx_packets += smc->packets_waiting;
1627             smc->packets_waiting = 0;
1628         }
1629         if (status & IM_ALLOC_INT) {
1630             /* Clear this interrupt so it doesn't happen again */
1631             mask &= ~IM_ALLOC_INT;
1632
1633             smc_hardware_send_packet(dev);
1634
1635             /* enable xmit interrupts based on this */
1636             mask |= (IM_TX_EMPTY_INT | IM_TX_INT);
1637
1638             /* and let the card send more packets to me */
1639             netif_wake_queue(dev);
1640         }
1641         if (status & IM_RX_OVRN_INT) {
1642             smc->stats.rx_errors++;
1643             smc->stats.rx_fifo_errors++;
1644             if (smc->duplex)
1645                 smc->rx_ovrn = 1; /* need MC_RESET outside smc_interrupt */
1646             outw(IM_RX_OVRN_INT, ioaddr + INTERRUPT);
1647         }
1648         if (status & IM_EPH_INT)
1649             smc_eph_irq(dev);
1650     } while (--bogus_cnt);
1651
1652     DEBUG(3, "  Restoring saved registers mask %2.2x bank %4.4x"
1653           " pointer %4.4x.\n", mask, saved_bank, saved_pointer);
1654
1655     /* restore state register */
1656     outw((mask<<8), ioaddr + INTERRUPT);
1657     outw(saved_pointer, ioaddr + POINTER);
1658     SMC_SELECT_BANK(saved_bank);
1659
1660     DEBUG(3, "%s: Exiting interrupt IRQ%d.\n", dev->name, irq);
1661
1662 irq_done:
1663
1664     if ((smc->manfid == MANFID_OSITECH) &&
1665         (smc->cardid != PRODID_OSITECH_SEVEN)) {
1666         /* Retrigger interrupt if needed */
1667         mask_bits(0x00ff, ioaddr-0x10+OSITECH_RESET_ISR);
1668         set_bits(0x0300, ioaddr-0x10+OSITECH_RESET_ISR);
1669     }
1670     if (smc->manfid == MANFID_MOTOROLA) {
1671         u_char cor;
1672         cor = readb(smc->base + MOT_UART + CISREG_COR);
1673         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_UART + CISREG_COR);
1674         writeb(cor, smc->base + MOT_UART + CISREG_COR);
1675         cor = readb(smc->base + MOT_LAN + CISREG_COR);
1676         writeb(cor & ~COR_IREQ_ENA, smc->base + MOT_LAN + CISREG_COR);
1677         writeb(cor, smc->base + MOT_LAN + CISREG_COR);
1678     }
1679 #ifdef DOES_NOT_WORK
1680     if (smc->base != NULL) { /* Megahertz MFC's */
1681         readb(smc->base+MEGAHERTZ_ISR);
1682         readb(smc->base+MEGAHERTZ_ISR);
1683     }
1684 #endif
1685     return IRQ_RETVAL(handled);
1686 }
1687
1688 /*====================================================================*/
1689
1690 static void smc_rx(struct net_device *dev)
1691 {
1692     struct smc_private *smc = netdev_priv(dev);
1693     kio_addr_t ioaddr = dev->base_addr;
1694     int rx_status;
1695     int packet_length;  /* Caution: not frame length, rather words
1696                            to transfer from the chip. */
1697
1698     /* Assertion: we are in Window 2. */
1699
1700     if (inw(ioaddr + FIFO_PORTS) & FP_RXEMPTY) {
1701         printk(KERN_ERR "%s: smc_rx() with nothing on Rx FIFO.\n",
1702                dev->name);
1703         return;
1704     }
1705
1706     /*  Reset the read pointer, and read the status and packet length. */
1707     outw(PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER);
1708     rx_status = inw(ioaddr + DATA_1);
1709     packet_length = inw(ioaddr + DATA_1) & 0x07ff;
1710
1711     DEBUG(2, "%s: Receive status %4.4x length %d.\n",
1712           dev->name, rx_status, packet_length);
1713
1714     if (!(rx_status & RS_ERRORS)) {
1715         /* do stuff to make a new packet */
1716         struct sk_buff *skb;
1717
1718         /* Note: packet_length adds 5 or 6 extra bytes here! */
1719         skb = dev_alloc_skb(packet_length+2);
1720
1721         if (skb == NULL) {
1722             DEBUG(1, "%s: Low memory, packet dropped.\n", dev->name);
1723             smc->stats.rx_dropped++;
1724             outw(MC_RELEASE, ioaddr + MMU_CMD);
1725             return;
1726         }
1727
1728         packet_length -= (rx_status & RS_ODDFRAME ? 5 : 6);
1729         skb_reserve(skb, 2);
1730         insw(ioaddr+DATA_1, skb_put(skb, packet_length),
1731              (packet_length+1)>>1);
1732         skb->protocol = eth_type_trans(skb, dev);
1733
1734         skb->dev = dev;
1735         netif_rx(skb);
1736         dev->last_rx = jiffies;
1737         smc->stats.rx_packets++;
1738         smc->stats.rx_bytes += packet_length;
1739         if (rx_status & RS_MULTICAST)
1740             smc->stats.multicast++;
1741     } else {
1742         /* error ... */
1743         smc->stats.rx_errors++;
1744
1745         if (rx_status & RS_ALGNERR)  smc->stats.rx_frame_errors++;
1746         if (rx_status & (RS_TOOSHORT | RS_TOOLONG))
1747             smc->stats.rx_length_errors++;
1748         if (rx_status & RS_BADCRC)      smc->stats.rx_crc_errors++;
1749     }
1750     /* Let the MMU free the memory of this packet. */
1751     outw(MC_RELEASE, ioaddr + MMU_CMD);
1752
1753     return;
1754 }
1755
1756 /*====================================================================*/
1757
1758 static struct net_device_stats *smc_get_stats(struct net_device *dev)
1759 {
1760     struct smc_private *smc = netdev_priv(dev);
1761     /* Nothing to update - the 91c92 is a pretty primative chip. */
1762     return &smc->stats;
1763 }
1764
1765 /*======================================================================
1766
1767     Calculate values for the hardware multicast filter hash table.
1768
1769 ======================================================================*/
1770
1771 static void fill_multicast_tbl(int count, struct dev_mc_list *addrs,
1772                                u_char *multicast_table)
1773 {
1774     struct dev_mc_list  *mc_addr;
1775
1776     for (mc_addr = addrs;  mc_addr && count-- > 0;  mc_addr = mc_addr->next) {
1777         u_int position = ether_crc(6, mc_addr->dmi_addr);
1778 #ifndef final_version           /* Verify multicast address. */
1779         if ((mc_addr->dmi_addr[0] & 1) == 0)
1780             continue;
1781 #endif
1782         multicast_table[position >> 29] |= 1 << ((position >> 26) & 7);
1783     }
1784 }
1785
1786 /*======================================================================
1787
1788     Set the receive mode.
1789
1790     This routine is used by both the protocol level to notify us of
1791     promiscuous/multicast mode changes, and by the open/reset code to
1792     initialize the Rx registers.  We always set the multicast list and
1793     leave the receiver running.
1794
1795 ======================================================================*/
1796
1797 static void set_rx_mode(struct net_device *dev)
1798 {
1799     kio_addr_t ioaddr = dev->base_addr;
1800     struct smc_private *smc = netdev_priv(dev);
1801     u_int multicast_table[ 2 ] = { 0, };
1802     unsigned long flags;
1803     u_short rx_cfg_setting;
1804
1805     if (dev->flags & IFF_PROMISC) {
1806         printk(KERN_NOTICE "%s: setting Rx mode to promiscuous.\n", dev->name);
1807         rx_cfg_setting = RxStripCRC | RxEnable | RxPromisc | RxAllMulti;
1808     } else if (dev->flags & IFF_ALLMULTI)
1809         rx_cfg_setting = RxStripCRC | RxEnable | RxAllMulti;
1810     else {
1811         if (dev->mc_count)  {
1812             fill_multicast_tbl(dev->mc_count, dev->mc_list,
1813                                (u_char *)multicast_table);
1814         }
1815         rx_cfg_setting = RxStripCRC | RxEnable;
1816     }
1817
1818     /* Load MC table and Rx setting into the chip without interrupts. */
1819     spin_lock_irqsave(&smc->lock, flags);
1820     SMC_SELECT_BANK(3);
1821     outl(multicast_table[0], ioaddr + MULTICAST0);
1822     outl(multicast_table[1], ioaddr + MULTICAST4);
1823     SMC_SELECT_BANK(0);
1824     outw(rx_cfg_setting, ioaddr + RCR);
1825     SMC_SELECT_BANK(2);
1826     spin_unlock_irqrestore(&smc->lock, flags);
1827
1828     return;
1829 }
1830
1831 /*======================================================================
1832
1833     Senses when a card's config changes. Here, it's coax or TP.
1834
1835 ======================================================================*/
1836
1837 static int s9k_config(struct net_device *dev, struct ifmap *map)
1838 {
1839     struct smc_private *smc = netdev_priv(dev);
1840     if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
1841         if (smc->cfg & CFG_MII_SELECT)
1842             return -EOPNOTSUPP;
1843         else if (map->port > 2)
1844             return -EINVAL;
1845         dev->if_port = map->port;
1846         printk(KERN_INFO "%s: switched to %s port\n",
1847                dev->name, if_names[dev->if_port]);
1848         smc_reset(dev);
1849     }
1850     return 0;
1851 }
1852
1853 /*======================================================================
1854
1855     Reset the chip, reloading every register that might be corrupted.
1856
1857 ======================================================================*/
1858
1859 /*
1860   Set transceiver type, perhaps to something other than what the user
1861   specified in dev->if_port.
1862 */
1863 static void smc_set_xcvr(struct net_device *dev, int if_port)
1864 {
1865     struct smc_private *smc = netdev_priv(dev);
1866     kio_addr_t ioaddr = dev->base_addr;
1867     u_short saved_bank;
1868
1869     saved_bank = inw(ioaddr + BANK_SELECT);
1870     SMC_SELECT_BANK(1);
1871     if (if_port == 2) {
1872         outw(smc->cfg | CFG_AUI_SELECT, ioaddr + CONFIG);
1873         if ((smc->manfid == MANFID_OSITECH) &&
1874             (smc->cardid != PRODID_OSITECH_SEVEN))
1875             set_bits(OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1876         smc->media_status = ((dev->if_port == 0) ? 0x0001 : 0x0002);
1877     } else {
1878         outw(smc->cfg, ioaddr + CONFIG);
1879         if ((smc->manfid == MANFID_OSITECH) &&
1880             (smc->cardid != PRODID_OSITECH_SEVEN))
1881             mask_bits(~OSI_AUI_PWR, ioaddr - 0x10 + OSITECH_AUI_PWR);
1882         smc->media_status = ((dev->if_port == 0) ? 0x0012 : 0x4001);
1883     }
1884     SMC_SELECT_BANK(saved_bank);
1885 }
1886
1887 static void smc_reset(struct net_device *dev)
1888 {
1889     kio_addr_t ioaddr = dev->base_addr;
1890     struct smc_private *smc = netdev_priv(dev);
1891     int i;
1892
1893     DEBUG(0, "%s: smc91c92 reset called.\n", dev->name);
1894
1895     /* The first interaction must be a write to bring the chip out
1896        of sleep mode. */
1897     SMC_SELECT_BANK(0);
1898     /* Reset the chip. */
1899     outw(RCR_SOFTRESET, ioaddr + RCR);
1900     udelay(10);
1901
1902     /* Clear the transmit and receive configuration registers. */
1903     outw(RCR_CLEAR, ioaddr + RCR);
1904     outw(TCR_CLEAR, ioaddr + TCR);
1905
1906     /* Set the Window 1 control, configuration and station addr registers.
1907        No point in writing the I/O base register ;-> */
1908     SMC_SELECT_BANK(1);
1909     /* Automatically release succesfully transmitted packets,
1910        Accept link errors, counter and Tx error interrupts. */
1911     outw(CTL_AUTO_RELEASE | CTL_TE_ENABLE | CTL_CR_ENABLE,
1912          ioaddr + CONTROL);
1913     smc_set_xcvr(dev, dev->if_port);
1914     if ((smc->manfid == MANFID_OSITECH) &&
1915         (smc->cardid != PRODID_OSITECH_SEVEN))
1916         outw((dev->if_port == 2 ? OSI_AUI_PWR : 0) |
1917              (inw(ioaddr-0x10+OSITECH_AUI_PWR) & 0xff00),
1918              ioaddr - 0x10 + OSITECH_AUI_PWR);
1919
1920     /* Fill in the physical address.  The databook is wrong about the order! */
1921     for (i = 0; i < 6; i += 2)
1922         outw((dev->dev_addr[i+1]<<8)+dev->dev_addr[i],
1923              ioaddr + ADDR0 + i);
1924
1925     /* Reset the MMU */
1926     SMC_SELECT_BANK(2);
1927     outw(MC_RESET, ioaddr + MMU_CMD);
1928     outw(0, ioaddr + INTERRUPT);
1929
1930     /* Re-enable the chip. */
1931     SMC_SELECT_BANK(0);
1932     outw(((smc->cfg & CFG_MII_SELECT) ? 0 : TCR_MONCSN) |
1933          TCR_ENABLE | TCR_PAD_EN | smc->duplex, ioaddr + TCR);
1934     set_rx_mode(dev);
1935
1936     if (smc->cfg & CFG_MII_SELECT) {
1937         SMC_SELECT_BANK(3);
1938
1939         /* Reset MII */
1940         mdio_write(dev, smc->mii_if.phy_id, 0, 0x8000);
1941
1942         /* Advertise 100F, 100H, 10F, 10H */
1943         mdio_write(dev, smc->mii_if.phy_id, 4, 0x01e1);
1944
1945         /* Restart MII autonegotiation */
1946         mdio_write(dev, smc->mii_if.phy_id, 0, 0x0000);
1947         mdio_write(dev, smc->mii_if.phy_id, 0, 0x1200);
1948     }
1949
1950     /* Enable interrupts. */
1951     SMC_SELECT_BANK(2);
1952     outw((IM_EPH_INT | IM_RX_OVRN_INT | IM_RCV_INT) << 8,
1953          ioaddr + INTERRUPT);
1954 }
1955
1956 /*======================================================================
1957
1958     Media selection timer routine
1959
1960 ======================================================================*/
1961
1962 static void media_check(u_long arg)
1963 {
1964     struct net_device *dev = (struct net_device *) arg;
1965     struct smc_private *smc = netdev_priv(dev);
1966     kio_addr_t ioaddr = dev->base_addr;
1967     u_short i, media, saved_bank;
1968     u_short link;
1969
1970     saved_bank = inw(ioaddr + BANK_SELECT);
1971
1972     if (!netif_device_present(dev))
1973         goto reschedule;
1974
1975     SMC_SELECT_BANK(2);
1976
1977     /* need MC_RESET to keep the memory consistent. errata? */
1978     if (smc->rx_ovrn) {
1979         outw(MC_RESET, ioaddr + MMU_CMD);
1980         smc->rx_ovrn = 0;
1981     }
1982     i = inw(ioaddr + INTERRUPT);
1983     SMC_SELECT_BANK(0);
1984     media = inw(ioaddr + EPH) & EPH_LINK_OK;
1985     SMC_SELECT_BANK(1);
1986     media |= (inw(ioaddr + CONFIG) & CFG_AUI_SELECT) ? 2 : 1;
1987
1988     /* Check for pending interrupt with watchdog flag set: with
1989        this, we can limp along even if the interrupt is blocked */
1990     if (smc->watchdog++ && ((i>>8) & i)) {
1991         if (!smc->fast_poll)
1992             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
1993         smc_interrupt(dev->irq, smc, NULL);
1994         smc->fast_poll = HZ;
1995     }
1996     if (smc->fast_poll) {
1997         smc->fast_poll--;
1998         smc->media.expires = jiffies + HZ/100;
1999         add_timer(&smc->media);
2000         SMC_SELECT_BANK(saved_bank);
2001         return;
2002     }
2003
2004     if (smc->cfg & CFG_MII_SELECT) {
2005         if (smc->mii_if.phy_id < 0)
2006             goto reschedule;
2007
2008         SMC_SELECT_BANK(3);
2009         link = mdio_read(dev, smc->mii_if.phy_id, 1);
2010         if (!link || (link == 0xffff)) {
2011             printk(KERN_INFO "%s: MII is missing!\n", dev->name);
2012             smc->mii_if.phy_id = -1;
2013             goto reschedule;
2014         }
2015
2016         link &= 0x0004;
2017         if (link != smc->link_status) {
2018             u_short p = mdio_read(dev, smc->mii_if.phy_id, 5);
2019             printk(KERN_INFO "%s: %s link beat\n", dev->name,
2020                 (link) ? "found" : "lost");
2021             smc->duplex = (((p & 0x0100) || ((p & 0x1c0) == 0x40))
2022                            ? TCR_FDUPLX : 0);
2023             if (link) {
2024                 printk(KERN_INFO "%s: autonegotiation complete: "
2025                        "%sbaseT-%cD selected\n", dev->name,
2026                        ((p & 0x0180) ? "100" : "10"),
2027                        (smc->duplex ? 'F' : 'H'));
2028             }
2029             SMC_SELECT_BANK(0);
2030             outw(inw(ioaddr + TCR) | smc->duplex, ioaddr + TCR);
2031             smc->link_status = link;
2032         }
2033         goto reschedule;
2034     }
2035
2036     /* Ignore collisions unless we've had no rx's recently */
2037     if (time_after(jiffies, dev->last_rx + HZ)) {
2038         if (smc->tx_err || (smc->media_status & EPH_16COL))
2039             media |= EPH_16COL;
2040     }
2041     smc->tx_err = 0;
2042
2043     if (media != smc->media_status) {
2044         if ((media & smc->media_status & 1) &&
2045             ((smc->media_status ^ media) & EPH_LINK_OK))
2046             printk(KERN_INFO "%s: %s link beat\n", dev->name,
2047                    (smc->media_status & EPH_LINK_OK ? "lost" : "found"));
2048         else if ((media & smc->media_status & 2) &&
2049                  ((smc->media_status ^ media) & EPH_16COL))
2050             printk(KERN_INFO "%s: coax cable %s\n", dev->name,
2051                    (media & EPH_16COL ? "problem" : "ok"));
2052         if (dev->if_port == 0) {
2053             if (media & 1) {
2054                 if (media & EPH_LINK_OK)
2055                     printk(KERN_INFO "%s: flipped to 10baseT\n",
2056                            dev->name);
2057                 else
2058                     smc_set_xcvr(dev, 2);
2059             } else {
2060                 if (media & EPH_16COL)
2061                     smc_set_xcvr(dev, 1);
2062                 else
2063                     printk(KERN_INFO "%s: flipped to 10base2\n",
2064                            dev->name);
2065             }
2066         }
2067         smc->media_status = media;
2068     }
2069
2070 reschedule:
2071     smc->media.expires = jiffies + HZ;
2072     add_timer(&smc->media);
2073     SMC_SELECT_BANK(saved_bank);
2074 }
2075
2076 static int smc_link_ok(struct net_device *dev)
2077 {
2078     kio_addr_t ioaddr = dev->base_addr;
2079     struct smc_private *smc = netdev_priv(dev);
2080
2081     if (smc->cfg & CFG_MII_SELECT) {
2082         return mii_link_ok(&smc->mii_if);
2083     } else {
2084         SMC_SELECT_BANK(0);
2085         return inw(ioaddr + EPH) & EPH_LINK_OK;
2086     }
2087 }
2088
2089 static int smc_netdev_get_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2090 {
2091     u16 tmp;
2092     kio_addr_t ioaddr = dev->base_addr;
2093
2094     ecmd->supported = (SUPPORTED_TP | SUPPORTED_AUI |
2095         SUPPORTED_10baseT_Half | SUPPORTED_10baseT_Full);
2096
2097     SMC_SELECT_BANK(1);
2098     tmp = inw(ioaddr + CONFIG);
2099     ecmd->port = (tmp & CFG_AUI_SELECT) ? PORT_AUI : PORT_TP;
2100     ecmd->transceiver = XCVR_INTERNAL;
2101     ecmd->speed = SPEED_10;
2102     ecmd->phy_address = ioaddr + MGMT;
2103
2104     SMC_SELECT_BANK(0);
2105     tmp = inw(ioaddr + TCR);
2106     ecmd->duplex = (tmp & TCR_FDUPLX) ? DUPLEX_FULL : DUPLEX_HALF;
2107
2108     return 0;
2109 }
2110
2111 static int smc_netdev_set_ecmd(struct net_device *dev, struct ethtool_cmd *ecmd)
2112 {
2113     u16 tmp;
2114     kio_addr_t ioaddr = dev->base_addr;
2115
2116     if (ecmd->speed != SPEED_10)
2117         return -EINVAL;
2118     if (ecmd->duplex != DUPLEX_HALF && ecmd->duplex != DUPLEX_FULL)
2119         return -EINVAL;
2120     if (ecmd->port != PORT_TP && ecmd->port != PORT_AUI)
2121         return -EINVAL;
2122     if (ecmd->transceiver != XCVR_INTERNAL)
2123         return -EINVAL;
2124
2125     if (ecmd->port == PORT_AUI)
2126         smc_set_xcvr(dev, 1);
2127     else
2128         smc_set_xcvr(dev, 0);
2129
2130     SMC_SELECT_BANK(0);
2131     tmp = inw(ioaddr + TCR);
2132     if (ecmd->duplex == DUPLEX_FULL)
2133         tmp |= TCR_FDUPLX;
2134     else
2135         tmp &= ~TCR_FDUPLX;
2136     outw(tmp, ioaddr + TCR);
2137
2138     return 0;
2139 }
2140
2141 static int check_if_running(struct net_device *dev)
2142 {
2143         if (!netif_running(dev))
2144                 return -EINVAL;
2145         return 0;
2146 }
2147
2148 static void smc_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
2149 {
2150         strcpy(info->driver, DRV_NAME);
2151         strcpy(info->version, DRV_VERSION);
2152 }
2153
2154 static int smc_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2155 {
2156         struct smc_private *smc = netdev_priv(dev);
2157         kio_addr_t ioaddr = dev->base_addr;
2158         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2159         int ret;
2160
2161         SMC_SELECT_BANK(3);
2162         spin_lock_irq(&smc->lock);
2163         if (smc->cfg & CFG_MII_SELECT)
2164                 ret = mii_ethtool_gset(&smc->mii_if, ecmd);
2165         else
2166                 ret = smc_netdev_get_ecmd(dev, ecmd);
2167         spin_unlock_irq(&smc->lock);
2168         SMC_SELECT_BANK(saved_bank);
2169         return ret;
2170 }
2171
2172 static int smc_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
2173 {
2174         struct smc_private *smc = netdev_priv(dev);
2175         kio_addr_t ioaddr = dev->base_addr;
2176         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2177         int ret;
2178
2179         SMC_SELECT_BANK(3);
2180         spin_lock_irq(&smc->lock);
2181         if (smc->cfg & CFG_MII_SELECT)
2182                 ret = mii_ethtool_sset(&smc->mii_if, ecmd);
2183         else
2184                 ret = smc_netdev_set_ecmd(dev, ecmd);
2185         spin_unlock_irq(&smc->lock);
2186         SMC_SELECT_BANK(saved_bank);
2187         return ret;
2188 }
2189
2190 static u32 smc_get_link(struct net_device *dev)
2191 {
2192         struct smc_private *smc = netdev_priv(dev);
2193         kio_addr_t ioaddr = dev->base_addr;
2194         u16 saved_bank = inw(ioaddr + BANK_SELECT);
2195         u32 ret;
2196
2197         SMC_SELECT_BANK(3);
2198         spin_lock_irq(&smc->lock);
2199         ret = smc_link_ok(dev);
2200         spin_unlock_irq(&smc->lock);
2201         SMC_SELECT_BANK(saved_bank);
2202         return ret;
2203 }
2204
2205 #ifdef PCMCIA_DEBUG
2206 static u32 smc_get_msglevel(struct net_device *dev)
2207 {
2208         return pc_debug;
2209 }
2210
2211 static void smc_set_msglevel(struct net_device *dev, u32 val)
2212 {
2213         pc_debug = val;
2214 }
2215 #endif
2216
2217 static int smc_nway_reset(struct net_device *dev)
2218 {
2219         struct smc_private *smc = netdev_priv(dev);
2220         if (smc->cfg & CFG_MII_SELECT) {
2221                 kio_addr_t ioaddr = dev->base_addr;
2222                 u16 saved_bank = inw(ioaddr + BANK_SELECT);
2223                 int res;
2224
2225                 SMC_SELECT_BANK(3);
2226                 res = mii_nway_restart(&smc->mii_if);
2227                 SMC_SELECT_BANK(saved_bank);
2228
2229                 return res;
2230         } else
2231                 return -EOPNOTSUPP;
2232 }
2233
2234 static struct ethtool_ops ethtool_ops = {
2235         .begin = check_if_running,
2236         .get_drvinfo = smc_get_drvinfo,
2237         .get_settings = smc_get_settings,
2238         .set_settings = smc_set_settings,
2239         .get_link = smc_get_link,
2240 #ifdef PCMCIA_DEBUG
2241         .get_msglevel = smc_get_msglevel,
2242         .set_msglevel = smc_set_msglevel,
2243 #endif
2244         .nway_reset = smc_nway_reset,
2245 };
2246
2247 static int smc_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
2248 {
2249         struct smc_private *smc = netdev_priv(dev);
2250         struct mii_ioctl_data *mii = if_mii(rq);
2251         int rc = 0;
2252         u16 saved_bank;
2253         kio_addr_t ioaddr = dev->base_addr;
2254
2255         if (!netif_running(dev))
2256                 return -EINVAL;
2257
2258         spin_lock_irq(&smc->lock);
2259         saved_bank = inw(ioaddr + BANK_SELECT);
2260         SMC_SELECT_BANK(3);
2261         rc = generic_mii_ioctl(&smc->mii_if, mii, cmd, NULL);
2262         SMC_SELECT_BANK(saved_bank);
2263         spin_unlock_irq(&smc->lock);
2264         return rc;
2265 }
2266
2267 static struct pcmcia_device_id smc91c92_ids[] = {
2268         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0109, 0x0501),
2269         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x0140, 0x000a),
2270         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3288", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x04cd2988, 0x46a52d63),
2271         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "CC/XJEM3336", "DATA/FAX/CELL ETHERNET MODEM", 0xf510db04, 0x0143b773, 0x46a52d63),
2272         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "EM1144T", "PCMCIA MODEM", 0xf510db04, 0x856d66c8, 0xbd6c43ef),
2273         PCMCIA_PFC_DEVICE_PROD_ID123(0, "MEGAHERTZ", "XJEM1144/CCEM1144", "PCMCIA MODEM", 0xf510db04, 0x52d21e1e, 0xbd6c43ef),
2274         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Gateway 2000", "XJEM3336", 0xdd9989be, 0x662c394c),
2275         PCMCIA_PFC_DEVICE_PROD_ID12(0, "MEGAHERTZ", "XJEM1144/CCEM1144", 0xf510db04, 0x52d21e1e),
2276         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Diamonds Modem+Ethernet", 0xc2f80cd, 0x656947b9),
2277         PCMCIA_PFC_DEVICE_PROD_ID12(0, "Ositech", "Trumpcard:Jack of Hearts Modem+Ethernet", 0xc2f80cd, 0xdc9ba5ed),
2278         PCMCIA_MFC_DEVICE_MANF_CARD(0, 0x016c, 0x0020),
2279         PCMCIA_DEVICE_MANF_CARD(0x016c, 0x0023),
2280         PCMCIA_DEVICE_PROD_ID123("BASICS by New Media Corporation", "Ethernet", "SMC91C94", 0x23c78a9d, 0x00b2e941, 0xcef397fb),
2281         PCMCIA_DEVICE_PROD_ID12("ARGOSY", "Fast Ethernet PCCard", 0x78f308dc, 0xdcea68bc),
2282         PCMCIA_DEVICE_PROD_ID12("dit Co., Ltd.", "PC Card-10/100BTX", 0xe59365c8, 0x6a2161d1),
2283         PCMCIA_DEVICE_PROD_ID12("DYNALINK", "L100C", 0x6a26d1cf, 0xc16ce9c5),
2284         PCMCIA_DEVICE_PROD_ID12("Farallon", "Farallon Enet", 0x58d93fc4, 0x244734e9),
2285         PCMCIA_DEVICE_PROD_ID12("Megahertz", "CC10BT/2", 0x33234748, 0x3c95b953),
2286         PCMCIA_DEVICE_PROD_ID12("MELCO/SMC", "LPC-TX", 0xa2cd8e6d, 0x42da662a),
2287         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Four of Diamonds Ethernet", 0xc2f80cd, 0xb3466314),
2288         PCMCIA_DEVICE_PROD_ID12("Ositech", "Trumpcard:Seven of Diamonds Ethernet", 0xc2f80cd, 0x194b650a),
2289         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "Fast Ethernet PCCard", 0x281f1c5d, 0xdcea68bc),
2290         PCMCIA_DEVICE_PROD_ID12("Psion", "10Mb Ethernet", 0x4ef00b21, 0x844be9e9),
2291         PCMCIA_DEVICE_PROD_ID12("SMC", "EtherEZ Ethernet 8020", 0xc4f8b18b, 0x4a0eeb2d),
2292         /* These conflict with other cards! */
2293         /* PCMCIA_DEVICE_MANF_CARD(0x0186, 0x0100), */
2294         /* PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab), */
2295         PCMCIA_DEVICE_NULL,
2296 };
2297 MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
2298
2299 static struct pcmcia_driver smc91c92_cs_driver = {
2300         .owner          = THIS_MODULE,
2301         .drv            = {
2302                 .name   = "smc91c92_cs",
2303         },
2304         .probe          = smc91c92_attach,
2305         .remove         = smc91c92_detach,
2306         .id_table       = smc91c92_ids,
2307         .suspend        = smc91c92_suspend,
2308         .resume         = smc91c92_resume,
2309 };
2310
2311 static int __init init_smc91c92_cs(void)
2312 {
2313         return pcmcia_register_driver(&smc91c92_cs_driver);
2314 }
2315
2316 static void __exit exit_smc91c92_cs(void)
2317 {
2318         pcmcia_unregister_driver(&smc91c92_cs_driver);
2319 }
2320
2321 module_init(init_smc91c92_cs);
2322 module_exit(exit_smc91c92_cs);