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