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