drivers/net/pcmcia/smc91c92_cs.c

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