1/*====================================================================== 2 3 Aironet driver for 4500 and 4800 series cards 4 5 This code is released under both the GPL version 2 and BSD licenses. 6 Either license may be used. The respective licenses are found at 7 the end of this file. 8 9 This code was developed by Benjamin Reed <breed@users.sourceforge.net> 10 including portions of which come from the Aironet PC4500 11 Developer's Reference Manual and used with permission. Copyright 12 (C) 1999 Benjamin Reed. All Rights Reserved. Permission to use 13 code in the Developer's manual was granted for this driver by 14 Aironet. 15 16 In addition this module was derived from dummy_cs. 17 The initial developer of dummy_cs is David A. Hinds 18 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 19 are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 20 21======================================================================*/ 22 23#ifdef __IN_PCMCIA_PACKAGE__ 24#include <pcmcia/k_compat.h> 25#endif 26#include <linux/init.h> 27#include <linux/kernel.h> 28#include <linux/module.h> 29#include <linux/ptrace.h> 30#include <linux/slab.h> 31#include <linux/string.h> 32#include <linux/timer.h> 33#include <linux/netdevice.h> 34 35#include <pcmcia/cs_types.h> 36#include <pcmcia/cs.h> 37#include <pcmcia/cistpl.h> 38#include <pcmcia/cisreg.h> 39#include <pcmcia/ds.h> 40 41#include <linux/io.h> 42#include <asm/system.h> 43 44#include "airo.h" 45 46/* 47 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If 48 you do not define PCMCIA_DEBUG at all, all the debug code will be 49 left out. If you compile with PCMCIA_DEBUG=0, the debug code will 50 be present but disabled -- but it can then be enabled for specific 51 modules at load time with a 'pc_debug=#' option to insmod. 52*/ 53#ifdef PCMCIA_DEBUG 54static int pc_debug = PCMCIA_DEBUG; 55module_param(pc_debug, int, 0); 56static char *version = "$Revision: 1.2 $"; 57#define DEBUG(n, args...) if (pc_debug > (n)) printk(KERN_DEBUG args); 58#else 59#define DEBUG(n, args...) 60#endif 61 62/*====================================================================*/ 63 64MODULE_AUTHOR("Benjamin Reed"); 65MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet " 66 "cards. This is the module that links the PCMCIA card " 67 "with the airo module."); 68MODULE_LICENSE("Dual BSD/GPL"); 69MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards"); 70 71/*====================================================================*/ 72 73/* 74 The event() function is this driver's Card Services event handler. 75 It will be called by Card Services when an appropriate card status 76 event is received. The config() and release() entry points are 77 used to configure or release a socket, in response to card 78 insertion and ejection events. They are invoked from the airo_cs 79 event handler. 80*/ 81 82static int airo_config(struct pcmcia_device *link); 83static void airo_release(struct pcmcia_device *link); 84 85/* 86 The attach() and detach() entry points are used to create and destroy 87 "instances" of the driver, where each instance represents everything 88 needed to manage one actual PCMCIA card. 89*/ 90 91static void airo_detach(struct pcmcia_device *p_dev); 92 93/* 94 You'll also need to prototype all the functions that will actually 95 be used to talk to your device. See 'pcmem_cs' for a good example 96 of a fully self-sufficient driver; the other drivers rely more or 97 less on other parts of the kernel. 98*/ 99 100/* 101 A linked list of "instances" of the aironet device. Each actual 102 PCMCIA card corresponds to one device instance, and is described 103 by one struct pcmcia_device structure (defined in ds.h). 104 105 You may not want to use a linked list for this -- for example, the 106 memory card driver uses an array of struct pcmcia_device pointers, 107 where minor device numbers are used to derive the corresponding 108 array index. 109*/ 110 111/* 112 A driver needs to provide a dev_node_t structure for each device 113 on a card. In some cases, there is only one device per card (for 114 example, ethernet cards, modems). In other cases, there may be 115 many actual or logical devices (SCSI adapters, memory cards with 116 multiple partitions). The dev_node_t structures need to be kept 117 in a linked list starting at the 'dev' field of a struct pcmcia_device 118 structure. We allocate them in the card's private data structure, 119 because they generally shouldn't be allocated dynamically. 120 121 In this case, we also provide a flag to indicate if a device is 122 "stopped" due to a power management event, or card ejection. The 123 device IO routines can use a flag like this to throttle IO to a 124 card that is not ready to accept it. 125*/ 126 127typedef struct local_info_t { 128 dev_node_t node; 129 struct net_device *eth_dev; 130} local_info_t; 131 132/*====================================================================== 133 134 airo_attach() creates an "instance" of the driver, allocating 135 local data structures for one device. The device is registered 136 with Card Services. 137 138 The dev_link structure is initialized, but we don't actually 139 configure the card at this point -- we wait until we receive a 140 card insertion event. 141 142 ======================================================================*/ 143 144static int airo_probe(struct pcmcia_device *p_dev) 145{ 146 local_info_t *local; 147 148 DEBUG(0, "airo_attach()\n"); 149 150 /* Interrupt setup */ 151 p_dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING; 152 p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID; 153 p_dev->irq.Handler = NULL; 154 155 /* 156 General socket configuration defaults can go here. In this 157 client, we assume very little, and rely on the CIS for almost 158 everything. In most clients, many details (i.e., number, sizes, 159 and attributes of IO windows) are fixed by the nature of the 160 device, and can be hard-wired here. 161 */ 162 p_dev->conf.Attributes = 0; 163 p_dev->conf.IntType = INT_MEMORY_AND_IO; 164 165 /* Allocate space for private device-specific data */ 166 local = kzalloc(sizeof(local_info_t), GFP_KERNEL); 167 if (!local) { 168 printk(KERN_ERR "airo_cs: no memory for new device\n"); 169 return -ENOMEM; 170 } 171 p_dev->priv = local; 172 173 return airo_config(p_dev); 174} /* airo_attach */ 175 176/*====================================================================== 177 178 This deletes a driver "instance". The device is de-registered 179 with Card Services. If it has been released, all local data 180 structures are freed. Otherwise, the structures will be freed 181 when the device is released. 182 183 ======================================================================*/ 184 185static void airo_detach(struct pcmcia_device *link) 186{ 187 DEBUG(0, "airo_detach(0x%p)\n", link); 188 189 airo_release(link); 190 191 if (((local_info_t *)link->priv)->eth_dev) { 192 stop_airo_card(((local_info_t *)link->priv)->eth_dev, 0); 193 } 194 ((local_info_t *)link->priv)->eth_dev = NULL; 195 196 kfree(link->priv); 197} /* airo_detach */ 198 199/*====================================================================== 200 201 airo_config() is scheduled to run after a CARD_INSERTION event 202 is received, to configure the PCMCIA socket, and to make the 203 device available to the system. 204 205 ======================================================================*/ 206 207#define CS_CHECK(fn, ret) \ 208do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) 209 210static int airo_cs_config_check(struct pcmcia_device *p_dev, 211 cistpl_cftable_entry_t *cfg, 212 cistpl_cftable_entry_t *dflt, 213 unsigned int vcc, 214 void *priv_data) 215{ 216 win_req_t *req = priv_data; 217 218 if (cfg->index == 0) 219 return -ENODEV; 220 221 /* Does this card need audio output? */ 222 if (cfg->flags & CISTPL_CFTABLE_AUDIO) { 223 p_dev->conf.Attributes |= CONF_ENABLE_SPKR; 224 p_dev->conf.Status = CCSR_AUDIO_ENA; 225 } 226 227 /* Use power settings for Vcc and Vpp if present */ 228 /* Note that the CIS values need to be rescaled */ 229 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM)) 230 p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000; 231 else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM)) 232 p_dev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM]/10000; 233 234 /* Do we need to allocate an interrupt? */ 235 if (cfg->irq.IRQInfo1 || dflt->irq.IRQInfo1) 236 p_dev->conf.Attributes |= CONF_ENABLE_IRQ; 237 238 /* IO window settings */ 239 p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0; 240 if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) { 241 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io; 242 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; 243 if (!(io->flags & CISTPL_IO_8BIT)) 244 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16; 245 if (!(io->flags & CISTPL_IO_16BIT)) 246 p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 247 p_dev->io.BasePort1 = io->win[0].base; 248 p_dev->io.NumPorts1 = io->win[0].len; 249 if (io->nwin > 1) { 250 p_dev->io.Attributes2 = p_dev->io.Attributes1; 251 p_dev->io.BasePort2 = io->win[1].base; 252 p_dev->io.NumPorts2 = io->win[1].len; 253 } 254 } 255 256 /* This reserves IO space but doesn't actually enable it */ 257 if (pcmcia_request_io(p_dev, &p_dev->io) != 0) 258 return -ENODEV; 259 260 /* 261 Now set up a common memory window, if needed. There is room 262 in the struct pcmcia_device structure for one memory window handle, 263 but if the base addresses need to be saved, or if multiple 264 windows are needed, the info should go in the private data 265 structure for this device. 266 267 Note that the memory window base is a physical address, and 268 needs to be mapped to virtual space with ioremap() before it 269 is used. 270 */ 271 if ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) { 272 cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &dflt->mem; 273 memreq_t map; 274 req->Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM; 275 req->Base = mem->win[0].host_addr; 276 req->Size = mem->win[0].len; 277 req->AccessSpeed = 0; 278 if (pcmcia_request_window(&p_dev, req, &p_dev->win) != 0) 279 return -ENODEV; 280 map.Page = 0; 281 map.CardOffset = mem->win[0].card_addr; 282 if (pcmcia_map_mem_page(p_dev->win, &map) != 0) 283 return -ENODEV; 284 } 285 /* If we got this far, we're cool! */ 286 return 0; 287} 288 289 290static int airo_config(struct pcmcia_device *link) 291{ 292 local_info_t *dev; 293 win_req_t *req; 294 int last_fn, last_ret; 295 296 dev = link->priv; 297 298 DEBUG(0, "airo_config(0x%p)\n", link); 299 300 req = kzalloc(sizeof(win_req_t), GFP_KERNEL); 301 if (!req) 302 return -ENOMEM; 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 last_ret = pcmcia_loop_config(link, airo_cs_config_check, req); 319 if (last_ret) 320 goto failed; 321 322 /* 323 Allocate an interrupt line. Note that this does not assign a 324 handler to the interrupt, unless the 'Handler' member of the 325 irq structure is initialized. 326 */ 327 if (link->conf.Attributes & CONF_ENABLE_IRQ) 328 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq)); 329 330 /* 331 This actually configures the PCMCIA socket -- setting up 332 the I/O windows and the interrupt mapping, and putting the 333 card and host interface into "Memory and IO" mode. 334 */ 335 CS_CHECK(RequestConfiguration, 336 pcmcia_request_configuration(link, &link->conf)); 337 ((local_info_t *)link->priv)->eth_dev = 338 init_airo_card(link->irq.AssignedIRQ, 339 link->io.BasePort1, 1, &handle_to_dev(link)); 340 if (!((local_info_t *)link->priv)->eth_dev) 341 goto cs_failed; 342 343 /* 344 At this point, the dev_node_t structure(s) need to be 345 initialized and arranged in a linked list at link->dev_node. 346 */ 347 strcpy(dev->node.dev_name, ((local_info_t *)link->priv)->eth_dev->name); 348 dev->node.major = dev->node.minor = 0; 349 link->dev_node = &dev->node; 350 351 /* Finally, report what we've done */ 352 printk(KERN_INFO "%s: index 0x%02x: ", 353 dev->node.dev_name, link->conf.ConfigIndex); 354 if (link->conf.Vpp) 355 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10); 356 if (link->conf.Attributes & CONF_ENABLE_IRQ) 357 printk(", irq %d", link->irq.AssignedIRQ); 358 if (link->io.NumPorts1) 359 printk(", io 0x%04x-0x%04x", link->io.BasePort1, 360 link->io.BasePort1+link->io.NumPorts1-1); 361 if (link->io.NumPorts2) 362 printk(" & 0x%04x-0x%04x", link->io.BasePort2, 363 link->io.BasePort2+link->io.NumPorts2-1); 364 if (link->win) 365 printk(", mem 0x%06lx-0x%06lx", req->Base, 366 req->Base+req->Size-1); 367 printk("\n"); 368 kfree(req); 369 return 0; 370 371 cs_failed: 372 cs_error(link, last_fn, last_ret); 373 failed: 374 airo_release(link); 375 kfree(req); 376 return -ENODEV; 377} /* airo_config */ 378 379/*====================================================================== 380 381 After a card is removed, airo_release() will unregister the 382 device, and release the PCMCIA configuration. If the device is 383 still open, this will be postponed until it is closed. 384 385 ======================================================================*/ 386 387static void airo_release(struct pcmcia_device *link) 388{ 389 DEBUG(0, "airo_release(0x%p)\n", link); 390 pcmcia_disable_device(link); 391} 392 393static int airo_suspend(struct pcmcia_device *link) 394{ 395 local_info_t *local = link->priv; 396 397 netif_device_detach(local->eth_dev); 398 399 return 0; 400} 401 402static int airo_resume(struct pcmcia_device *link) 403{ 404 local_info_t *local = link->priv; 405 406 if (link->open) { 407 reset_airo_card(local->eth_dev); 408 netif_device_attach(local->eth_dev); 409 } 410 411 return 0; 412} 413 414static struct pcmcia_device_id airo_ids[] = { 415 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a), 416 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005), 417 PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007), 418 PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007), 419 PCMCIA_DEVICE_NULL, 420}; 421MODULE_DEVICE_TABLE(pcmcia, airo_ids); 422 423static struct pcmcia_driver airo_driver = { 424 .owner = THIS_MODULE, 425 .drv = { 426 .name = "airo_cs", 427 }, 428 .probe = airo_probe, 429 .remove = airo_detach, 430 .id_table = airo_ids, 431 .suspend = airo_suspend, 432 .resume = airo_resume, 433}; 434 435static int airo_cs_init(void) 436{ 437 return pcmcia_register_driver(&airo_driver); 438} 439 440static void airo_cs_cleanup(void) 441{ 442 pcmcia_unregister_driver(&airo_driver); 443} 444 445/* 446 This program is free software; you can redistribute it and/or 447 modify it under the terms of the GNU General Public License 448 as published by the Free Software Foundation; either version 2 449 of the License, or (at your option) any later version. 450 451 This program is distributed in the hope that it will be useful, 452 but WITHOUT ANY WARRANTY; without even the implied warranty of 453 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 454 GNU General Public License for more details. 455 456 In addition: 457 458 Redistribution and use in source and binary forms, with or without 459 modification, are permitted provided that the following conditions 460 are met: 461 462 1. Redistributions of source code must retain the above copyright 463 notice, this list of conditions and the following disclaimer. 464 2. Redistributions in binary form must reproduce the above copyright 465 notice, this list of conditions and the following disclaimer in the 466 documentation and/or other materials provided with the distribution. 467 3. The name of the author may not be used to endorse or promote 468 products derived from this software without specific prior written 469 permission. 470 471 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 472 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 473 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 474 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 475 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 476 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 477 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 478 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 479 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 480 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 481 POSSIBILITY OF SUCH DAMAGE. 482*/ 483 484module_init(airo_cs_init); 485module_exit(airo_cs_cleanup); 486