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