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->resource[0]->end = p_dev->resource[1]->end = 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_lines = io->flags & CISTPL_IO_LINES_MASK;
 260                 p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 261                 p_dev->resource[0]->flags |=
 262                         pcmcia_io_cfg_data_width(io->flags);
 263                 p_dev->resource[0]->start = io->win[0].base;
 264                 p_dev->resource[0]->end = io->win[0].len;
 265                 if (io->nwin > 1) {
 266                         p_dev->resource[1]->flags = p_dev->resource[0]->flags;
 267                         p_dev->resource[1]->start = io->win[1].base;
 268                         p_dev->resource[1]->end = io->win[1].len;
 269                 }
 270
 271                 /* This reserves IO space but doesn't actually enable it */
 272                 if (pcmcia_request_io(p_dev) != 0)
 273                         goto next_entry;
 274         }
 275         return 0;
 276
 277 next_entry:
 278         pcmcia_disable_device(p_dev);
 279         return -ENODEV;
 280 };
 281
 282 static int
 283 spectrum_cs_config(struct pcmcia_device *link)
 284 {
 285         struct orinoco_private *priv = link->priv;
 286         hermes_t *hw = &priv->hw;
 287         int ret;
 288         void __iomem *mem;
 289
 290         /*
 291          * In this loop, we scan the CIS for configuration table
 292          * entries, each of which describes a valid card
 293          * configuration, including voltage, IO window, memory window,
 294          * and interrupt settings.
 295          *
 296          * We make no assumptions about the card to be configured: we
 297          * use just the information available in the CIS.  In an ideal
 298          * world, this would work for any PCMCIA card, but it requires
 299          * a complete and accurate CIS.  In practice, a driver usually
 300          * "knows" most of these things without consulting the CIS,
 301          * and most client drivers will only use the CIS to fill in
 302          * implementation-defined details.
 303          */
 304         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
 305         if (ret) {
 306                 if (!ignore_cis_vcc)
 307                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
 308                                "CIS configuration.  Maybe you need the "
 309                                "ignore_cis_vcc=1 parameter.\n");
 310                 goto failed;
 311         }
 312
 313         ret = pcmcia_request_irq(link, orinoco_interrupt);
 314         if (ret)
 315                 goto failed;
 316
 317         /* We initialize the hermes structure before completing PCMCIA
 318          * configuration just in case the interrupt handler gets
 319          * called. */
 320         mem = ioport_map(link->resource[0]->start,
 321                         resource_size(link->resource[0]));
 322         if (!mem)
 323                 goto failed;
 324
 325         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 326         hw->eeprom_pda = true;
 327
 328         /*
 329          * This actually configures the PCMCIA socket -- setting up
 330          * the I/O windows and the interrupt mapping, and putting the
 331          * card and host interface into "Memory and IO" mode.
 332          */
 333         ret = pcmcia_request_configuration(link, &link->conf);
 334         if (ret)
 335                 goto failed;
 336
 337         /* Reset card */
 338         if (spectrum_cs_hard_reset(priv) != 0)
 339                 goto failed;
 340
 341         /* Initialise the main driver */
 342         if (orinoco_init(priv) != 0) {
 343                 printk(KERN_ERR PFX "orinoco_init() failed\n");
 344                 goto failed;
 345         }
 346
 347         /* Register an interface with the stack */
 348         if (orinoco_if_add(priv, link->resource[0]->start,
 349                            link->irq, NULL) != 0) {
 350                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
 351                 goto failed;
 352         }
 353
 354         return 0;
 355
 356  failed:
 357         spectrum_cs_release(link);
 358         return -ENODEV;
 359 }                               /* spectrum_cs_config */
 360
 361 /*
 362  * After a card is removed, spectrum_cs_release() will unregister the
 363  * device, and release the PCMCIA configuration.  If the device is
 364  * still open, this will be postponed until it is closed.
 365  */
 366 static void
 367 spectrum_cs_release(struct pcmcia_device *link)
 368 {
 369         struct orinoco_private *priv = link->priv;
 370         unsigned long flags;
 371
 372         /* We're committed to taking the device away now, so mark the
 373          * hardware as unavailable */
 374         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
 375         priv->hw_unavailable++;
 376         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
 377
 378         pcmcia_disable_device(link);
 379         if (priv->hw.iobase)
 380                 ioport_unmap(priv->hw.iobase);
 381 }                               /* spectrum_cs_release */
 382
 383
 384 static int
 385 spectrum_cs_suspend(struct pcmcia_device *link)
 386 {
 387         struct orinoco_private *priv = link->priv;
 388         int err = 0;
 389
 390         /* Mark the device as stopped, to block IO until later */
 391         orinoco_down(priv);
 392
 393         return err;
 394 }
 395
 396 static int
 397 spectrum_cs_resume(struct pcmcia_device *link)
 398 {
 399         struct orinoco_private *priv = link->priv;
 400         int err = orinoco_up(priv);
 401
 402         return err;
 403 }
 404
 405
 406 /********************************************************************/
 407 /* Module initialization                                            */
 408 /********************************************************************/
 409
 410 /* Can't be declared "const" or the whole __initdata section will
 411  * become const */
 412 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
 413         " (Pavel Roskin <proski@gnu.org>,"
 414         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
 415
 416 static struct pcmcia_device_id spectrum_cs_ids[] = {
 417         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
 418         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
 419         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
 420         PCMCIA_DEVICE_NULL,
 421 };
 422 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
 423
 424 static struct pcmcia_driver orinoco_driver = {
 425         .owner          = THIS_MODULE,
 426         .drv            = {
 427                 .name   = DRIVER_NAME,
 428         },
 429         .probe          = spectrum_cs_probe,
 430         .remove         = spectrum_cs_detach,
 431         .suspend        = spectrum_cs_suspend,
 432         .resume         = spectrum_cs_resume,
 433         .id_table       = spectrum_cs_ids,
 434 };
 435
 436 static int __init
 437 init_spectrum_cs(void)
 438 {
 439         printk(KERN_DEBUG "%s\n", version);
 440
 441         return pcmcia_register_driver(&orinoco_driver);
 442 }
 443
 444 static void __exit
 445 exit_spectrum_cs(void)
 446 {
 447         pcmcia_unregister_driver(&orinoco_driver);
 448 }
 449
 450 module_init(init_spectrum_cs);
 451 module_exit(exit_spectrum_cs);