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