drivers/net/wireless/orinoco/spectrum_cs.c

   1 /*
   2  * Driver for 802.11b cards using RAM-loadable Symbol firmware, such as
   3  * Symbol Wireless Networker LA4137, CompactFlash cards by Socket
   4  * Communications and Intel PRO/Wireless 2011B.
   5  *
   6  * The driver implements Symbol firmware download.  The rest is handled
   7  * in hermes.c and main.c.
   8  *
   9  * Utilities for downloading the Symbol firmware are available at
  10  * http://sourceforge.net/projects/orinoco/
  11  *
  12  * Copyright (C) 2002-2005 Pavel Roskin <proski@gnu.org>
  13  * Portions based on orinoco_cs.c:
  14  *      Copyright (C) David Gibson, Linuxcare Australia
  15  * Portions based on Spectrum24tDnld.c from original spectrum24 driver:
  16  *      Copyright (C) Symbol Technologies.
  17  *
  18  * See copyright notice in file main.c.
  19  */
  20
  21 #define DRIVER_NAME "spectrum_cs"
  22 #define PFX DRIVER_NAME ": "
  23
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <pcmcia/cs.h>
  29 #include <pcmcia/cistpl.h>
  30 #include <pcmcia/cisreg.h>
  31 #include <pcmcia/ds.h>
  32
  33 #include "orinoco.h"
  34
  35 /********************************************************************/
  36 /* Module stuff                                                     */
  37 /********************************************************************/
  38
  39 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
  40 MODULE_DESCRIPTION("Driver for Symbol Spectrum24 Trilogy cards with firmware downloader");
  41 MODULE_LICENSE("Dual MPL/GPL");
  42
  43 /* Module parameters */
  44
  45 /* Some D-Link cards have buggy CIS. They do work at 5v properly, but
  46  * don't have any CIS entry for it. This workaround it... */
  47 static int ignore_cis_vcc; /* = 0 */
  48 module_param(ignore_cis_vcc, int, 0);
  49 MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket");
  50
  51 /********************************************************************/
  52 /* Data structures                                                  */
  53 /********************************************************************/
  54
  55 /* PCMCIA specific device information (goes in the card field of
  56  * struct orinoco_private */
  57 struct orinoco_pccard {
  58         struct pcmcia_device    *p_dev;
  59 };
  60
  61 /********************************************************************/
  62 /* Function prototypes                                              */
  63 /********************************************************************/
  64
  65 static int spectrum_cs_config(struct pcmcia_device *link);
  66 static void spectrum_cs_release(struct pcmcia_device *link);
  67
  68 /* Constants for the CISREG_CCSR register */
  69 #define HCR_RUN         0x07    /* run firmware after reset */
  70 #define HCR_IDLE        0x0E    /* don't run firmware after reset */
  71 #define HCR_MEM16       0x10    /* memory width bit, should be preserved */
  72
  73
  74 /*
  75  * Reset the card using configuration registers COR and CCSR.
  76  * If IDLE is 1, stop the firmware, so that it can be safely rewritten.
  77  */
  78 static int
  79 spectrum_reset(struct pcmcia_device *link, int idle)
  80 {
  81         int ret;
  82         u8 save_cor;
  83         u8 ccsr;
  84
  85         /* Doing it if hardware is gone is guaranteed crash */
  86         if (!pcmcia_dev_present(link))
  87                 return -ENODEV;
  88
  89         /* Save original COR value */
  90         ret = pcmcia_read_config_byte(link, CISREG_COR, &save_cor);
  91         if (ret)
  92                 goto failed;
  93
  94         /* Soft-Reset card */
  95         ret = pcmcia_write_config_byte(link, CISREG_COR,
  96                                 (save_cor | COR_SOFT_RESET));
  97         if (ret)
  98                 goto failed;
  99         udelay(1000);
 100
 101         /* Read CCSR */
 102         ret = pcmcia_read_config_byte(link, CISREG_CCSR, &ccsr);
 103         if (ret)
 104                 goto failed;
 105
 106         /*
 107          * Start or stop the firmware.  Memory width bit should be
 108          * preserved from the value we've just read.
 109          */
 110         ccsr = (idle ? HCR_IDLE : HCR_RUN) | (ccsr & HCR_MEM16);
 111         ret = pcmcia_write_config_byte(link, CISREG_CCSR, ccsr);
 112         if (ret)
 113                 goto failed;
 114         udelay(1000);
 115
 116         /* Restore original COR configuration index */
 117         ret = pcmcia_write_config_byte(link, CISREG_COR,
 118                                 (save_cor & ~COR_SOFT_RESET));
 119         if (ret)
 120                 goto failed;
 121         udelay(1000);
 122         return 0;
 123
 124 failed:
 125         return -ENODEV;
 126 }
 127
 128 /********************************************************************/
 129 /* Device methods                                                   */
 130 /********************************************************************/
 131
 132 static int
 133 spectrum_cs_hard_reset(struct orinoco_private *priv)
 134 {
 135         struct orinoco_pccard *card = priv->card;
 136         struct pcmcia_device *link = card->p_dev;
 137
 138         /* Soft reset using COR and HCR */
 139         spectrum_reset(link, 0);
 140
 141         return 0;
 142 }
 143
 144 static int
 145 spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
 146 {
 147         struct orinoco_pccard *card = priv->card;
 148         struct pcmcia_device *link = card->p_dev;
 149
 150         return spectrum_reset(link, idle);
 151 }
 152
 153 /********************************************************************/
 154 /* PCMCIA stuff                                                     */
 155 /********************************************************************/
 156
 157 /*
 158  * This creates an "instance" of the driver, allocating local data
 159  * structures for one device.  The device is registered with Card
 160  * Services.
 161  *
 162  * The dev_link structure is initialized, but we don't actually
 163  * configure the card at this point -- we wait until we receive a card
 164  * insertion event.  */
 165 static int
 166 spectrum_cs_probe(struct pcmcia_device *link)
 167 {
 168         struct orinoco_private *priv;
 169         struct orinoco_pccard *card;
 170
 171         priv = alloc_orinocodev(sizeof(*card), &link->dev,
 172                                 spectrum_cs_hard_reset,
 173                                 spectrum_cs_stop_firmware);
 174         if (!priv)
 175                 return -ENOMEM;
 176         card = priv->card;
 177
 178         /* Link both structures together */
 179         card->p_dev = link;
 180         link->priv = priv;
 181
 182         /* General socket configuration defaults can go here.  In this
 183          * client, we assume very little, and rely on the CIS for
 184          * almost everything.  In most clients, many details (i.e.,
 185          * number, sizes, and attributes of IO windows) are fixed by
 186          * the nature of the device, and can be hard-wired here. */
 187         link->conf.Attributes = 0;
 188         link->conf.IntType = INT_MEMORY_AND_IO;
 189
 190         return spectrum_cs_config(link);
 191 }                               /* spectrum_cs_attach */
 192
 193 /*
 194  * This deletes a driver "instance".  The device is de-registered with
 195  * Card Services.  If it has been released, all local data structures
 196  * are freed.  Otherwise, the structures will be freed when the device
 197  * is released.
 198  */
 199 static void spectrum_cs_detach(struct pcmcia_device *link)
 200 {
 201         struct orinoco_private *priv = link->priv;
 202
 203         orinoco_if_del(priv);
 204
 205         spectrum_cs_release(link);
 206
 207         free_orinocodev(priv);
 208 }                               /* spectrum_cs_detach */
 209
 210 /*
 211  * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
 212  * event is received, to configure the PCMCIA socket, and to make the
 213  * device available to the system.
 214  */
 215
 216 static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
 217                                     cistpl_cftable_entry_t *cfg,
 218                                     cistpl_cftable_entry_t *dflt,
 219                                     unsigned int vcc,
 220                                     void *priv_data)
 221 {
 222         if (cfg->index == 0)
 223                 goto next_entry;
 224
 225         /* Use power settings for Vcc and Vpp if present */
 226         /* Note that the CIS values need to be rescaled */
 227         if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 228                 if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
 229                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
 230                               __func__, vcc,
 231                               cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
 232                         if (!ignore_cis_vcc)
 233                                 goto next_entry;
 234                 }
 235         } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 236                 if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
 237                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
 238                               __func__, vcc,
 239                               dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
 240                         if (!ignore_cis_vcc)
 241                                 goto next_entry;
 242                 }
 243         }
 244
 245         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 246                 p_dev->conf.Vpp =
 247                         cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 248         else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
 249                 p_dev->conf.Vpp =
 250                         dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 251
 252         /* Do we need to allocate an interrupt? */
 253         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 254
 255         /* IO window settings */
 256         p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
 257         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
 258                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
 259                 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 260                 if (!(io->flags & CISTPL_IO_8BIT))
 261                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 262                 if (!(io->flags & CISTPL_IO_16BIT))
 263                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 264                 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 265                 p_dev->io.BasePort1 = io->win[0].base;
 266                 p_dev->io.NumPorts1 = io->win[0].len;
 267                 if (io->nwin > 1) {
 268                         p_dev->io.Attributes2 = p_dev->io.Attributes1;
 269                         p_dev->io.BasePort2 = io->win[1].base;
 270                         p_dev->io.NumPorts2 = io->win[1].len;
 271                 }
 272
 273                 /* This reserves IO space but doesn't actually enable it */
 274                 if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
 275                         goto next_entry;
 276         }
 277         return 0;
 278
 279 next_entry:
 280         pcmcia_disable_device(p_dev);
 281         return -ENODEV;
 282 };
 283
 284 static int
 285 spectrum_cs_config(struct pcmcia_device *link)
 286 {
 287         struct orinoco_private *priv = link->priv;
 288         hermes_t *hw = &priv->hw;
 289         int ret;
 290         void __iomem *mem;
 291
 292         /*
 293          * In this loop, we scan the CIS for configuration table
 294          * entries, each of which describes a valid card
 295          * configuration, including voltage, IO window, memory window,
 296          * and interrupt settings.
 297          *
 298          * We make no assumptions about the card to be configured: we
 299          * use just the information available in the CIS.  In an ideal
 300          * world, this would work for any PCMCIA card, but it requires
 301          * a complete and accurate CIS.  In practice, a driver usually
 302          * "knows" most of these things without consulting the CIS,
 303          * and most client drivers will only use the CIS to fill in
 304          * implementation-defined details.
 305          */
 306         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
 307         if (ret) {
 308                 if (!ignore_cis_vcc)
 309                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
 310                                "CIS configuration.  Maybe you need the "
 311                                "ignore_cis_vcc=1 parameter.\n");
 312                 goto failed;
 313         }
 314
 315         ret = pcmcia_request_irq(link, orinoco_interrupt);
 316         if (ret)
 317                 goto failed;
 318
 319         /* We initialize the hermes structure before completing PCMCIA
 320          * configuration just in case the interrupt handler gets
 321          * called. */
 322         mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
 323         if (!mem)
 324                 goto failed;
 325
 326         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 327         hw->eeprom_pda = true;
 328
 329         /*
 330          * This actually configures the PCMCIA socket -- setting up
 331          * the I/O windows and the interrupt mapping, and putting the
 332          * card and host interface into "Memory and IO" mode.
 333          */
 334         ret = pcmcia_request_configuration(link, &link->conf);
 335         if (ret)
 336                 goto failed;
 337
 338         /* Reset card */
 339         if (spectrum_cs_hard_reset(priv) != 0)
 340                 goto failed;
 341
 342         /* Initialise the main driver */
 343         if (orinoco_init(priv) != 0) {
 344                 printk(KERN_ERR PFX "orinoco_init() failed\n");
 345                 goto failed;
 346         }
 347
 348         /* Register an interface with the stack */
 349         if (orinoco_if_add(priv, link->io.BasePort1,
 350                            link->irq, NULL) != 0) {
 351                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
 352                 goto failed;
 353         }
 354
 355         return 0;
 356
 357  failed:
 358         spectrum_cs_release(link);
 359         return -ENODEV;
 360 }                               /* spectrum_cs_config */
 361
 362 /*
 363  * After a card is removed, spectrum_cs_release() will unregister the
 364  * device, and release the PCMCIA configuration.  If the device is
 365  * still open, this will be postponed until it is closed.
 366  */
 367 static void
 368 spectrum_cs_release(struct pcmcia_device *link)
 369 {
 370         struct orinoco_private *priv = link->priv;
 371         unsigned long flags;
 372
 373         /* We're committed to taking the device away now, so mark the
 374          * hardware as unavailable */
 375         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
 376         priv->hw_unavailable++;
 377         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
 378
 379         pcmcia_disable_device(link);
 380         if (priv->hw.iobase)
 381                 ioport_unmap(priv->hw.iobase);
 382 }                               /* spectrum_cs_release */
 383
 384
 385 static int
 386 spectrum_cs_suspend(struct pcmcia_device *link)
 387 {
 388         struct orinoco_private *priv = link->priv;
 389         int err = 0;
 390
 391         /* Mark the device as stopped, to block IO until later */
 392         orinoco_down(priv);
 393
 394         return err;
 395 }
 396
 397 static int
 398 spectrum_cs_resume(struct pcmcia_device *link)
 399 {
 400         struct orinoco_private *priv = link->priv;
 401         int err = orinoco_up(priv);
 402
 403         return err;
 404 }
 405
 406
 407 /********************************************************************/
 408 /* Module initialization                                            */
 409 /********************************************************************/
 410
 411 /* Can't be declared "const" or the whole __initdata section will
 412  * become const */
 413 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
 414         " (Pavel Roskin <proski@gnu.org>,"
 415         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
 416
 417 static struct pcmcia_device_id spectrum_cs_ids[] = {
 418         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
 419         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
 420         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
 421         PCMCIA_DEVICE_NULL,
 422 };
 423 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
 424
 425 static struct pcmcia_driver orinoco_driver = {
 426         .owner          = THIS_MODULE,
 427         .drv            = {
 428                 .name   = DRIVER_NAME,
 429         },
 430         .probe          = spectrum_cs_probe,
 431         .remove         = spectrum_cs_detach,
 432         .suspend        = spectrum_cs_suspend,
 433         .resume         = spectrum_cs_resume,
 434         .id_table       = spectrum_cs_ids,
 435 };
 436
 437 static int __init
 438 init_spectrum_cs(void)
 439 {
 440         printk(KERN_DEBUG "%s\n", version);
 441
 442         return pcmcia_register_driver(&orinoco_driver);
 443 }
 444
 445 static void __exit
 446 exit_spectrum_cs(void)
 447 {
 448         pcmcia_unregister_driver(&orinoco_driver);
 449 }
 450
 451 module_init(init_spectrum_cs);
 452 module_exit(exit_spectrum_cs);