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         conf_reg_t reg;
  83         u_int save_cor;
  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         reg.Function = 0;
  91         reg.Action = CS_READ;
  92         reg.Offset = CISREG_COR;
  93         ret = pcmcia_access_configuration_register(link, &reg);
  94         if (ret)
  95                 goto failed;
  96         save_cor = reg.Value;
  97
  98         /* Soft-Reset card */
  99         reg.Action = CS_WRITE;
 100         reg.Offset = CISREG_COR;
 101         reg.Value = (save_cor | COR_SOFT_RESET);
 102         ret = pcmcia_access_configuration_register(link, &reg);
 103         if (ret)
 104                 goto failed;
 105         udelay(1000);
 106
 107         /* Read CCSR */
 108         reg.Action = CS_READ;
 109         reg.Offset = CISREG_CCSR;
 110         ret = pcmcia_access_configuration_register(link, &reg);
 111         if (ret)
 112                 goto failed;
 113
 114         /*
 115          * Start or stop the firmware.  Memory width bit should be
 116          * preserved from the value we've just read.
 117          */
 118         reg.Action = CS_WRITE;
 119         reg.Offset = CISREG_CCSR;
 120         reg.Value = (idle ? HCR_IDLE : HCR_RUN) | (reg.Value & HCR_MEM16);
 121         ret = pcmcia_access_configuration_register(link, &reg);
 122         if (ret)
 123                 goto failed;
 124         udelay(1000);
 125
 126         /* Restore original COR configuration index */
 127         reg.Action = CS_WRITE;
 128         reg.Offset = CISREG_COR;
 129         reg.Value = (save_cor & ~COR_SOFT_RESET);
 130         ret = pcmcia_access_configuration_register(link, &reg);
 131         if (ret)
 132                 goto failed;
 133         udelay(1000);
 134         return 0;
 135
 136 failed:
 137         return -ENODEV;
 138 }
 139
 140 /********************************************************************/
 141 /* Device methods                                                   */
 142 /********************************************************************/
 143
 144 static int
 145 spectrum_cs_hard_reset(struct orinoco_private *priv)
 146 {
 147         struct orinoco_pccard *card = priv->card;
 148         struct pcmcia_device *link = card->p_dev;
 149
 150         /* Soft reset using COR and HCR */
 151         spectrum_reset(link, 0);
 152
 153         return 0;
 154 }
 155
 156 static int
 157 spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
 158 {
 159         struct orinoco_pccard *card = priv->card;
 160         struct pcmcia_device *link = card->p_dev;
 161
 162         return spectrum_reset(link, idle);
 163 }
 164
 165 /********************************************************************/
 166 /* PCMCIA stuff                                                     */
 167 /********************************************************************/
 168
 169 /*
 170  * This creates an "instance" of the driver, allocating local data
 171  * structures for one device.  The device is registered with Card
 172  * Services.
 173  *
 174  * The dev_link structure is initialized, but we don't actually
 175  * configure the card at this point -- we wait until we receive a card
 176  * insertion event.  */
 177 static int
 178 spectrum_cs_probe(struct pcmcia_device *link)
 179 {
 180         struct orinoco_private *priv;
 181         struct orinoco_pccard *card;
 182
 183         priv = alloc_orinocodev(sizeof(*card), &link->dev,
 184                                 spectrum_cs_hard_reset,
 185                                 spectrum_cs_stop_firmware);
 186         if (!priv)
 187                 return -ENOMEM;
 188         card = priv->card;
 189
 190         /* Link both structures together */
 191         card->p_dev = link;
 192         link->priv = priv;
 193
 194         /* General socket configuration defaults can go here.  In this
 195          * client, we assume very little, and rely on the CIS for
 196          * almost everything.  In most clients, many details (i.e.,
 197          * number, sizes, and attributes of IO windows) are fixed by
 198          * the nature of the device, and can be hard-wired here. */
 199         link->conf.Attributes = 0;
 200         link->conf.IntType = INT_MEMORY_AND_IO;
 201
 202         return spectrum_cs_config(link);
 203 }                               /* spectrum_cs_attach */
 204
 205 /*
 206  * This deletes a driver "instance".  The device is de-registered with
 207  * Card Services.  If it has been released, all local data structures
 208  * are freed.  Otherwise, the structures will be freed when the device
 209  * is released.
 210  */
 211 static void spectrum_cs_detach(struct pcmcia_device *link)
 212 {
 213         struct orinoco_private *priv = link->priv;
 214
 215         orinoco_if_del(priv);
 216
 217         spectrum_cs_release(link);
 218
 219         free_orinocodev(priv);
 220 }                               /* spectrum_cs_detach */
 221
 222 /*
 223  * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
 224  * event is received, to configure the PCMCIA socket, and to make the
 225  * device available to the system.
 226  */
 227
 228 static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
 229                                     cistpl_cftable_entry_t *cfg,
 230                                     cistpl_cftable_entry_t *dflt,
 231                                     unsigned int vcc,
 232                                     void *priv_data)
 233 {
 234         if (cfg->index == 0)
 235                 goto next_entry;
 236
 237         /* Use power settings for Vcc and Vpp if present */
 238         /* Note that the CIS values need to be rescaled */
 239         if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 240                 if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
 241                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
 242                               __func__, vcc,
 243                               cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
 244                         if (!ignore_cis_vcc)
 245                                 goto next_entry;
 246                 }
 247         } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
 248                 if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
 249                         DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
 250                               __func__, vcc,
 251                               dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
 252                         if (!ignore_cis_vcc)
 253                                 goto next_entry;
 254                 }
 255         }
 256
 257         if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
 258                 p_dev->conf.Vpp =
 259                         cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 260         else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
 261                 p_dev->conf.Vpp =
 262                         dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
 263
 264         /* Do we need to allocate an interrupt? */
 265         p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 266
 267         /* IO window settings */
 268         p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
 269         if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
 270                 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
 271                 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 272                 if (!(io->flags & CISTPL_IO_8BIT))
 273                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 274                 if (!(io->flags & CISTPL_IO_16BIT))
 275                         p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 276                 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
 277                 p_dev->io.BasePort1 = io->win[0].base;
 278                 p_dev->io.NumPorts1 = io->win[0].len;
 279                 if (io->nwin > 1) {
 280                         p_dev->io.Attributes2 = p_dev->io.Attributes1;
 281                         p_dev->io.BasePort2 = io->win[1].base;
 282                         p_dev->io.NumPorts2 = io->win[1].len;
 283                 }
 284
 285                 /* This reserves IO space but doesn't actually enable it */
 286                 if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
 287                         goto next_entry;
 288         }
 289         return 0;
 290
 291 next_entry:
 292         pcmcia_disable_device(p_dev);
 293         return -ENODEV;
 294 };
 295
 296 static int
 297 spectrum_cs_config(struct pcmcia_device *link)
 298 {
 299         struct orinoco_private *priv = link->priv;
 300         hermes_t *hw = &priv->hw;
 301         int ret;
 302         void __iomem *mem;
 303
 304         /*
 305          * In this loop, we scan the CIS for configuration table
 306          * entries, each of which describes a valid card
 307          * configuration, including voltage, IO window, memory window,
 308          * and interrupt settings.
 309          *
 310          * We make no assumptions about the card to be configured: we
 311          * use just the information available in the CIS.  In an ideal
 312          * world, this would work for any PCMCIA card, but it requires
 313          * a complete and accurate CIS.  In practice, a driver usually
 314          * "knows" most of these things without consulting the CIS,
 315          * and most client drivers will only use the CIS to fill in
 316          * implementation-defined details.
 317          */
 318         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
 319         if (ret) {
 320                 if (!ignore_cis_vcc)
 321                         printk(KERN_ERR PFX "GetNextTuple(): No matching "
 322                                "CIS configuration.  Maybe you need the "
 323                                "ignore_cis_vcc=1 parameter.\n");
 324                 goto failed;
 325         }
 326
 327         ret = pcmcia_request_irq(link, orinoco_interrupt);
 328         if (ret)
 329                 goto failed;
 330
 331         /* We initialize the hermes structure before completing PCMCIA
 332          * configuration just in case the interrupt handler gets
 333          * called. */
 334         mem = ioport_map(link->io.BasePort1, link->io.NumPorts1);
 335         if (!mem)
 336                 goto failed;
 337
 338         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 339         hw->eeprom_pda = true;
 340
 341         /*
 342          * This actually configures the PCMCIA socket -- setting up
 343          * the I/O windows and the interrupt mapping, and putting the
 344          * card and host interface into "Memory and IO" mode.
 345          */
 346         ret = pcmcia_request_configuration(link, &link->conf);
 347         if (ret)
 348                 goto failed;
 349
 350         /* Reset card */
 351         if (spectrum_cs_hard_reset(priv) != 0)
 352                 goto failed;
 353
 354         /* Initialise the main driver */
 355         if (orinoco_init(priv) != 0) {
 356                 printk(KERN_ERR PFX "orinoco_init() failed\n");
 357                 goto failed;
 358         }
 359
 360         /* Register an interface with the stack */
 361         if (orinoco_if_add(priv, link->io.BasePort1,
 362                            link->irq, NULL) != 0) {
 363                 printk(KERN_ERR PFX "orinoco_if_add() failed\n");
 364                 goto failed;
 365         }
 366
 367         return 0;
 368
 369  failed:
 370         spectrum_cs_release(link);
 371         return -ENODEV;
 372 }                               /* spectrum_cs_config */
 373
 374 /*
 375  * After a card is removed, spectrum_cs_release() will unregister the
 376  * device, and release the PCMCIA configuration.  If the device is
 377  * still open, this will be postponed until it is closed.
 378  */
 379 static void
 380 spectrum_cs_release(struct pcmcia_device *link)
 381 {
 382         struct orinoco_private *priv = link->priv;
 383         unsigned long flags;
 384
 385         /* We're committed to taking the device away now, so mark the
 386          * hardware as unavailable */
 387         priv->hw.ops->lock_irqsave(&priv->lock, &flags);
 388         priv->hw_unavailable++;
 389         priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
 390
 391         pcmcia_disable_device(link);
 392         if (priv->hw.iobase)
 393                 ioport_unmap(priv->hw.iobase);
 394 }                               /* spectrum_cs_release */
 395
 396
 397 static int
 398 spectrum_cs_suspend(struct pcmcia_device *link)
 399 {
 400         struct orinoco_private *priv = link->priv;
 401         int err = 0;
 402
 403         /* Mark the device as stopped, to block IO until later */
 404         orinoco_down(priv);
 405
 406         return err;
 407 }
 408
 409 static int
 410 spectrum_cs_resume(struct pcmcia_device *link)
 411 {
 412         struct orinoco_private *priv = link->priv;
 413         int err = orinoco_up(priv);
 414
 415         return err;
 416 }
 417
 418
 419 /********************************************************************/
 420 /* Module initialization                                            */
 421 /********************************************************************/
 422
 423 /* Can't be declared "const" or the whole __initdata section will
 424  * become const */
 425 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
 426         " (Pavel Roskin <proski@gnu.org>,"
 427         " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
 428
 429 static struct pcmcia_device_id spectrum_cs_ids[] = {
 430         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
 431         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
 432         PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */
 433         PCMCIA_DEVICE_NULL,
 434 };
 435 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
 436
 437 static struct pcmcia_driver orinoco_driver = {
 438         .owner          = THIS_MODULE,
 439         .drv            = {
 440                 .name   = DRIVER_NAME,
 441         },
 442         .probe          = spectrum_cs_probe,
 443         .remove         = spectrum_cs_detach,
 444         .suspend        = spectrum_cs_suspend,
 445         .resume         = spectrum_cs_resume,
 446         .id_table       = spectrum_cs_ids,
 447 };
 448
 449 static int __init
 450 init_spectrum_cs(void)
 451 {
 452         printk(KERN_DEBUG "%s\n", version);
 453
 454         return pcmcia_register_driver(&orinoco_driver);
 455 }
 456
 457 static void __exit
 458 exit_spectrum_cs(void)
 459 {
 460         pcmcia_unregister_driver(&orinoco_driver);
 461 }
 462
 463 module_init(init_spectrum_cs);
 464 module_exit(exit_spectrum_cs);