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