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