drivers/net/pcmcia/smc91c92_cs.c

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