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                                     void *priv_data)
 209 {
 210         if (p_dev->config_index == 0)
 211                 return -EINVAL;
 212
 213         return pcmcia_request_io(p_dev);
 214 };
 215
 216 static int
 217 spectrum_cs_config(struct pcmcia_device *link)
 218 {
 219         struct orinoco_private *priv = link->priv;
 220         hermes_t *hw = &priv->hw;
 221         int ret;
 222         void __iomem *mem;
 223
 224         /*
 225          * In this loop, we scan the CIS for configuration table
 226          * entries, each of which describes a valid card
 227          * configuration, including voltage, IO window, memory window,
 228          * and interrupt settings.
 229          *
 230          * We make no assumptions about the card to be configured: we
 231          * use just the information available in the CIS.  In an ideal
 232          * world, this would work for any PCMCIA card, but it requires
 233          * a complete and accurate CIS.  In practice, a driver usually
 234          * "knows" most of these things without consulting the CIS,
 235          * and most client drivers will only use the CIS to fill in
 236          * implementation-defined details.
 237          */
 238         link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC |
 239                 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
 240         if (ignore_cis_vcc)
 241                 link->config_flags &= ~CONF_AUTO_CHECK_VCC;
 242         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
 243         if (ret) {
 244                 if (!ignore_cis_vcc)
 245                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
 246                                "CIS configuration.  Maybe you need the "
 247                                "ignore_cis_vcc=1 parameter.\n");
 248                 goto failed;
 249         }
 250
 251         ret = pcmcia_request_irq(link, orinoco_interrupt);
 252         if (ret)
 253                 goto failed;
 254
 255         /* We initialize the hermes structure before completing PCMCIA
 256          * configuration just in case the interrupt handler gets
 257          * called. */
 258         mem = ioport_map(link->resource[0]->start,
 259                         resource_size(link->resource[0]));
 260         if (!mem)
 261                 goto failed;
 262
 263         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 264         hw->eeprom_pda = true;
 265
 266         /*
 267          * This actually configures the PCMCIA socket -- setting up
 268          * the I/O windows and the interrupt mapping, and putting the
 269          * card and host interface into "Memory and IO" mode.
 270          */
 271         ret = pcmcia_enable_device(link);
 272         if (ret)
 273                 goto failed;
 274
 275         /* Reset card */
 276         if (spectrum_cs_hard_reset(priv) != 0)
 277                 goto failed;
 278
 279         /* Initialise the main driver */
 280         if (orinoco_init(priv) != 0) {
 281                 printk(KERN_ERR PFX "orinoco_init() failed\n");
 282                 goto failed;
 283         }
 284
 285         /* Register an interface with the stack */
 286         if (orinoco_if_add(priv, link->resource[0]->start,
 287                            link->irq, NULL) != 0) {
 288                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
 289                 goto failed;
 290         }
 291
 292         return 0;
 293
 294  failed:
 295         spectrum_cs_release(link);
 296         return -ENODEV;
 297 }                               /* spectrum_cs_config */
 298
 299 /*
 300  * After a card is removed, spectrum_cs_release() will unregister the
 301  * device, and release the PCMCIA configuration.  If the device is
 302  * still open, this will be postponed until it is closed.
 303  */
 304 static void
 305 spectrum_cs_release(struct pcmcia_device *link)
 306 {
 307         struct orinoco_private *priv = link->priv;
 308         unsigned long flags;
 309
 310         /* We're committed to taking the device away now, so mark the
 311          * hardware as unavailable */
 312         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
 313         priv->hw_unavailable++;
 314         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
 315
 316         pcmcia_disable_device(link);
 317         if (priv->hw.iobase)
 318                 ioport_unmap(priv->hw.iobase);
 319 }                               /* spectrum_cs_release */
 320
 321
 322 static int
 323 spectrum_cs_suspend(struct pcmcia_device *link)
 324 {
 325         struct orinoco_private *priv = link->priv;
 326         int err = 0;
 327
 328         /* Mark the device as stopped, to block IO until later */
 329         orinoco_down(priv);
 330
 331         return err;
 332 }
 333
 334 static int
 335 spectrum_cs_resume(struct pcmcia_device *link)
 336 {
 337         struct orinoco_private *priv = link->priv;
 338         int err = orinoco_up(priv);
 339
 340         return err;
 341 }
 342
 343
 344 /********************************************************************/
 345 /* Module initialization                                            */
 346 /********************************************************************/
 347
 348 /* Can't be declared "const" or the whole __initdata section will
 349  * become const */
 350 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
 351         " (Pavel Roskin <proski@gnu.org>,"
 352         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
 353
 354 static struct pcmcia_device_id spectrum_cs_ids[] = {
 355         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
 356         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
 357         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
 358         PCMCIA_DEVICE_NULL,
 359 };
 360 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
 361
 362 static struct pcmcia_driver orinoco_driver = {
 363         .owner          = THIS_MODULE,
 364         .name           = DRIVER_NAME,
 365         .probe          = spectrum_cs_probe,
 366         .remove         = spectrum_cs_detach,
 367         .suspend        = spectrum_cs_suspend,
 368         .resume         = spectrum_cs_resume,
 369         .id_table       = spectrum_cs_ids,
 370 };
 371
 372 static int __init
 373 init_spectrum_cs(void)
 374 {
 375         printk(KERN_DEBUG "%s\n", version);
 376
 377         return pcmcia_register_driver(&orinoco_driver);
 378 }
 379
 380 static void __exit
 381 exit_spectrum_cs(void)
 382 {
 383         pcmcia_unregister_driver(&orinoco_driver);
 384 }
 385
 386 module_init(init_spectrum_cs);
 387 module_exit(exit_spectrum_cs);