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