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/delay.h> 27 #include <pcmcia/cistpl.h> 28 #include <pcmcia/cisreg.h> 29 #include <pcmcia/ds.h> 30 31 #include "orinoco.h" 32 33 /********************************************************************/ 34 /* Module stuff */ 35 /********************************************************************/ 36 37 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>"); 38 MODULE_DESCRIPTION("Driver for Symbol Spectrum24 Trilogy cards with firmware downloader"); 39 MODULE_LICENSE("Dual MPL/GPL"); 40 41 /* Module parameters */ 42 43 /* Some D-Link cards have buggy CIS. They do work at 5v properly, but 44 * don't have any CIS entry for it. This workaround it... */ 45 static int ignore_cis_vcc; /* = 0 */ 46 module_param(ignore_cis_vcc, int, 0); 47 MODULE_PARM_DESC(ignore_cis_vcc, "Allow voltage mismatch between card and socket"); 48 49 /********************************************************************/ 50 /* Data structures */ 51 /********************************************************************/ 52 53 /* PCMCIA specific device information (goes in the card field of 54 * struct orinoco_private */ 55 struct orinoco_pccard { 56 struct pcmcia_device *p_dev; 57 }; 58 59 /********************************************************************/ 60 /* Function prototypes */ 61 /********************************************************************/ 62 63 static int spectrum_cs_config(struct pcmcia_device *link); 64 static void spectrum_cs_release(struct pcmcia_device *link); 65 66 /* Constants for the CISREG_CCSR register */ 67 #define HCR_RUN 0x07 /* run firmware after reset */ 68 #define HCR_IDLE 0x0E /* don't run firmware after reset */ 69 #define HCR_MEM16 0x10 /* memory width bit, should be preserved */ 70 71 72 /* 73 * Reset the card using configuration registers COR and CCSR. 74 * If IDLE is 1, stop the firmware, so that it can be safely rewritten. 75 */ 76 static int spectrum_reset(struct pcmcia_device * link,int idle)77 spectrum_reset(struct pcmcia_device *link, int idle) 78 { 79 int ret; 80 u8 save_cor; 81 u8 ccsr; 82 83 /* Doing it if hardware is gone is guaranteed crash */ 84 if (!pcmcia_dev_present(link)) 85 return -ENODEV; 86 87 /* Save original COR value */ 88 ret = pcmcia_read_config_byte(link, CISREG_COR, &save_cor); 89 if (ret) 90 goto failed; 91 92 /* Soft-Reset card */ 93 ret = pcmcia_write_config_byte(link, CISREG_COR, 94 (save_cor | COR_SOFT_RESET)); 95 if (ret) 96 goto failed; 97 udelay(1000); 98 99 /* Read CCSR */ 100 ret = pcmcia_read_config_byte(link, CISREG_CCSR, &ccsr); 101 if (ret) 102 goto failed; 103 104 /* 105 * Start or stop the firmware. Memory width bit should be 106 * preserved from the value we've just read. 107 */ 108 ccsr = (idle ? HCR_IDLE : HCR_RUN) | (ccsr & HCR_MEM16); 109 ret = pcmcia_write_config_byte(link, CISREG_CCSR, ccsr); 110 if (ret) 111 goto failed; 112 udelay(1000); 113 114 /* Restore original COR configuration index */ 115 ret = pcmcia_write_config_byte(link, CISREG_COR, 116 (save_cor & ~COR_SOFT_RESET)); 117 if (ret) 118 goto failed; 119 udelay(1000); 120 return 0; 121 122 failed: 123 return -ENODEV; 124 } 125 126 /********************************************************************/ 127 /* Device methods */ 128 /********************************************************************/ 129 130 static int spectrum_cs_hard_reset(struct orinoco_private * priv)131 spectrum_cs_hard_reset(struct orinoco_private *priv) 132 { 133 struct orinoco_pccard *card = priv->card; 134 struct pcmcia_device *link = card->p_dev; 135 136 /* Soft reset using COR and HCR */ 137 spectrum_reset(link, 0); 138 139 return 0; 140 } 141 142 static int spectrum_cs_stop_firmware(struct orinoco_private * priv,int idle)143 spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle) 144 { 145 struct orinoco_pccard *card = priv->card; 146 struct pcmcia_device *link = card->p_dev; 147 148 return spectrum_reset(link, idle); 149 } 150 151 /********************************************************************/ 152 /* PCMCIA stuff */ 153 /********************************************************************/ 154 155 static int spectrum_cs_probe(struct pcmcia_device * link)156 spectrum_cs_probe(struct pcmcia_device *link) 157 { 158 struct orinoco_private *priv; 159 struct orinoco_pccard *card; 160 int ret; 161 162 priv = alloc_orinocodev(sizeof(*card), &link->dev, 163 spectrum_cs_hard_reset, 164 spectrum_cs_stop_firmware); 165 if (!priv) 166 return -ENOMEM; 167 card = priv->card; 168 169 /* Link both structures together */ 170 card->p_dev = link; 171 link->priv = priv; 172 173 ret = spectrum_cs_config(link); 174 if (ret) 175 goto err_free_orinocodev; 176 177 return 0; 178 179 err_free_orinocodev: 180 free_orinocodev(priv); 181 return ret; 182 } 183 spectrum_cs_detach(struct pcmcia_device * link)184 static void spectrum_cs_detach(struct pcmcia_device *link) 185 { 186 struct orinoco_private *priv = link->priv; 187 188 orinoco_if_del(priv); 189 190 spectrum_cs_release(link); 191 192 free_orinocodev(priv); 193 } /* spectrum_cs_detach */ 194 spectrum_cs_config_check(struct pcmcia_device * p_dev,void * priv_data)195 static int spectrum_cs_config_check(struct pcmcia_device *p_dev, 196 void *priv_data) 197 { 198 if (p_dev->config_index == 0) 199 return -EINVAL; 200 201 return pcmcia_request_io(p_dev); 202 }; 203 204 static int spectrum_cs_config(struct pcmcia_device * link)205 spectrum_cs_config(struct pcmcia_device *link) 206 { 207 struct orinoco_private *priv = link->priv; 208 struct hermes *hw = &priv->hw; 209 int ret; 210 void __iomem *mem; 211 212 link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC | 213 CONF_AUTO_SET_IO | CONF_ENABLE_IRQ; 214 if (ignore_cis_vcc) 215 link->config_flags &= ~CONF_AUTO_CHECK_VCC; 216 ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL); 217 if (ret) { 218 if (!ignore_cis_vcc) 219 printk(KERN_ERR PFX "GetNextTuple(): No matching " 220 "CIS configuration. Maybe you need the " 221 "ignore_cis_vcc=1 parameter.\n"); 222 goto failed; 223 } 224 225 mem = ioport_map(link->resource[0]->start, 226 resource_size(link->resource[0])); 227 if (!mem) 228 goto failed; 229 230 /* We initialize the hermes structure before completing PCMCIA 231 * configuration just in case the interrupt handler gets 232 * called. */ 233 hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING); 234 hw->eeprom_pda = true; 235 236 ret = pcmcia_request_irq(link, orinoco_interrupt); 237 if (ret) 238 goto failed; 239 240 ret = pcmcia_enable_device(link); 241 if (ret) 242 goto failed; 243 244 /* Reset card */ 245 if (spectrum_cs_hard_reset(priv) != 0) 246 goto failed; 247 248 /* Initialise the main driver */ 249 if (orinoco_init(priv) != 0) { 250 printk(KERN_ERR PFX "orinoco_init() failed\n"); 251 goto failed; 252 } 253 254 /* Register an interface with the stack */ 255 if (orinoco_if_add(priv, link->resource[0]->start, 256 link->irq, NULL) != 0) { 257 printk(KERN_ERR PFX "orinoco_if_add() failed\n"); 258 goto failed; 259 } 260 261 return 0; 262 263 failed: 264 spectrum_cs_release(link); 265 return -ENODEV; 266 } /* spectrum_cs_config */ 267 268 static void spectrum_cs_release(struct pcmcia_device * link)269 spectrum_cs_release(struct pcmcia_device *link) 270 { 271 struct orinoco_private *priv = link->priv; 272 unsigned long flags; 273 274 /* We're committed to taking the device away now, so mark the 275 * hardware as unavailable */ 276 priv->hw.ops->lock_irqsave(&priv->lock, &flags); 277 priv->hw_unavailable++; 278 priv->hw.ops->unlock_irqrestore(&priv->lock, &flags); 279 280 pcmcia_disable_device(link); 281 if (priv->hw.iobase) 282 ioport_unmap(priv->hw.iobase); 283 } /* spectrum_cs_release */ 284 285 286 static int spectrum_cs_suspend(struct pcmcia_device * link)287 spectrum_cs_suspend(struct pcmcia_device *link) 288 { 289 struct orinoco_private *priv = link->priv; 290 291 /* Mark the device as stopped, to block IO until later */ 292 orinoco_down(priv); 293 294 return 0; 295 } 296 297 static int spectrum_cs_resume(struct pcmcia_device * link)298 spectrum_cs_resume(struct pcmcia_device *link) 299 { 300 struct orinoco_private *priv = link->priv; 301 int err = orinoco_up(priv); 302 303 return err; 304 } 305 306 307 /********************************************************************/ 308 /* Module initialization */ 309 /********************************************************************/ 310 311 static const struct pcmcia_device_id spectrum_cs_ids[] = { 312 PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */ 313 PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */ 314 PCMCIA_DEVICE_PROD_ID12("Intel", "PRO/Wireless LAN PC Card", 0x816cc815, 0x6fbf459a), /* 2011B, not 2011 */ 315 PCMCIA_DEVICE_NULL, 316 }; 317 MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids); 318 319 static struct pcmcia_driver orinoco_driver = { 320 .owner = THIS_MODULE, 321 .name = DRIVER_NAME, 322 .probe = spectrum_cs_probe, 323 .remove = spectrum_cs_detach, 324 .suspend = spectrum_cs_suspend, 325 .resume = spectrum_cs_resume, 326 .id_table = spectrum_cs_ids, 327 }; 328 module_pcmcia_driver(orinoco_driver); 329