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