1/*** -*- linux-c -*- ********************************************************** 2 3 Driver for Atmel at76c502 at76c504 and at76c506 wireless cards. 4 5 Copyright 2000-2001 ATMEL Corporation. 6 Copyright 2003 Simon Kelley. 7 8 This code was developed from version 2.1.1 of the Atmel drivers, 9 released by Atmel corp. under the GPL in December 2002. It also 10 includes code from the Linux aironet drivers (C) Benjamin Reed, 11 and the Linux PCMCIA package, (C) David Hinds. 12 13 For all queries about this code, please contact the current author, 14 Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation. 15 16 This program is free software; you can redistribute it and/or modify 17 it under the terms of the GNU General Public License as published by 18 the Free Software Foundation; either version 2 of the License, or 19 (at your option) any later version. 20 21 This software is distributed in the hope that it will be useful, 22 but WITHOUT ANY WARRANTY; without even the implied warranty of 23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 GNU General Public License for more details. 25 26 You should have received a copy of the GNU General Public License 27 along with Atmel wireless lan drivers; if not, write to the Free Software 28 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 29 30******************************************************************************/ 31 32#ifdef __IN_PCMCIA_PACKAGE__ 33#include <pcmcia/k_compat.h> 34#endif 35#include <linux/init.h> 36#include <linux/kernel.h> 37#include <linux/module.h> 38#include <linux/ptrace.h> 39#include <linux/slab.h> 40#include <linux/string.h> 41#include <linux/netdevice.h> 42#include <linux/moduleparam.h> 43#include <linux/device.h> 44 45#include <pcmcia/cs_types.h> 46#include <pcmcia/cs.h> 47#include <pcmcia/cistpl.h> 48#include <pcmcia/cisreg.h> 49#include <pcmcia/ds.h> 50#include <pcmcia/ciscode.h> 51 52#include <asm/io.h> 53#include <asm/system.h> 54#include <linux/wireless.h> 55 56#include "atmel.h" 57 58/* 59 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If 60 you do not define PCMCIA_DEBUG at all, all the debug code will be 61 left out. If you compile with PCMCIA_DEBUG=0, the debug code will 62 be present but disabled -- but it can then be enabled for specific 63 modules at load time with a 'pc_debug=#' option to insmod. 64*/ 65 66#ifdef PCMCIA_DEBUG 67static int pc_debug = PCMCIA_DEBUG; 68module_param(pc_debug, int, 0); 69static char *version = "$Revision: 1.1.1.1 $"; 70#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args); 71#else 72#define DEBUG(n, args...) 73#endif 74 75/*====================================================================*/ 76 77MODULE_AUTHOR("Simon Kelley"); 78MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards."); 79MODULE_LICENSE("GPL"); 80MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards"); 81 82/*====================================================================*/ 83 84/* 85 The event() function is this driver's Card Services event handler. 86 It will be called by Card Services when an appropriate card status 87 event is received. The config() and release() entry points are 88 used to configure or release a socket, in response to card 89 insertion and ejection events. They are invoked from the atmel_cs 90 event handler. 91*/ 92 93static int atmel_config(struct pcmcia_device *link); 94static void atmel_release(struct pcmcia_device *link); 95 96/* 97 The attach() and detach() entry points are used to create and destroy 98 "instances" of the driver, where each instance represents everything 99 needed to manage one actual PCMCIA card. 100*/ 101 102static void atmel_detach(struct pcmcia_device *p_dev); 103 104/* 105 You'll also need to prototype all the functions that will actually 106 be used to talk to your device. See 'pcmem_cs' for a good example 107 of a fully self-sufficient driver; the other drivers rely more or 108 less on other parts of the kernel. 109*/ 110 111/* 112 A linked list of "instances" of the atmelnet device. Each actual 113 PCMCIA card corresponds to one device instance, and is described 114 by one struct pcmcia_device structure (defined in ds.h). 115 116 You may not want to use a linked list for this -- for example, the 117 memory card driver uses an array of struct pcmcia_device pointers, where minor 118 device numbers are used to derive the corresponding array index. 119*/ 120 121/* 122 A driver needs to provide a dev_node_t structure for each device 123 on a card. In some cases, there is only one device per card (for 124 example, ethernet cards, modems). In other cases, there may be 125 many actual or logical devices (SCSI adapters, memory cards with 126 multiple partitions). The dev_node_t structures need to be kept 127 in a linked list starting at the 'dev' field of a struct pcmcia_device 128 structure. We allocate them in the card's private data structure, 129 because they generally shouldn't be allocated dynamically. 130 131 In this case, we also provide a flag to indicate if a device is 132 "stopped" due to a power management event, or card ejection. The 133 device IO routines can use a flag like this to throttle IO to a 134 card that is not ready to accept it. 135*/ 136 137typedef struct local_info_t { 138 dev_node_t node; 139 struct net_device *eth_dev; 140} local_info_t; 141 142/*====================================================================== 143 144 atmel_attach() creates an "instance" of the driver, allocating 145 local data structures for one device. The device is registered 146 with Card Services. 147 148 The dev_link structure is initialized, but we don't actually 149 configure the card at this point -- we wait until we receive a 150 card insertion event. 151 152 ======================================================================*/ 153 154static int atmel_probe(struct pcmcia_device *p_dev) 155{ 156 local_info_t *local; 157 158 DEBUG(0, "atmel_attach()\n"); 159 160 /* Interrupt setup */ 161 p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE; 162 p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID; 163 p_dev->irq.Handler = NULL; 164 165 /* 166 General socket configuration defaults can go here. In this 167 client, we assume very little, and rely on the CIS for almost 168 everything. In most clients, many details (i.e., number, sizes, 169 and attributes of IO windows) are fixed by the nature of the 170 device, and can be hard-wired here. 171 */ 172 p_dev->conf.Attributes = 0; 173 p_dev->conf.IntType = INT_MEMORY_AND_IO; 174 175 /* Allocate space for private device-specific data */ 176 local = kzalloc(sizeof(local_info_t), GFP_KERNEL); 177 if (!local) { 178 printk(KERN_ERR "atmel_cs: no memory for new device\n"); 179 return -ENOMEM; 180 } 181 p_dev->priv = local; 182 183 return atmel_config(p_dev); 184} /* atmel_attach */ 185 186/*====================================================================== 187 188 This deletes a driver "instance". The device is de-registered 189 with Card Services. If it has been released, all local data 190 structures are freed. Otherwise, the structures will be freed 191 when the device is released. 192 193 ======================================================================*/ 194 195static void atmel_detach(struct pcmcia_device *link) 196{ 197 DEBUG(0, "atmel_detach(0x%p)\n", link); 198 199 atmel_release(link); 200 201 kfree(link->priv); 202} 203 204/*====================================================================== 205 206 atmel_config() is scheduled to run after a CARD_INSERTION event 207 is received, to configure the PCMCIA socket, and to make the 208 device available to the system. 209 210 ======================================================================*/ 211 212#define CS_CHECK(fn, ret) \ 213do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0) 214 215/* Call-back function to interrogate PCMCIA-specific information 216 about the current existance of the card */ 217static int card_present(void *arg) 218{ 219 struct pcmcia_device *link = (struct pcmcia_device *)arg; 220 221 if (pcmcia_dev_present(link)) 222 return 1; 223 224 return 0; 225} 226 227static int atmel_config(struct pcmcia_device *link) 228{ 229 tuple_t tuple; 230 cisparse_t parse; 231 local_info_t *dev; 232 int last_fn, last_ret; 233 u_char buf[64]; 234 struct pcmcia_device_id *did; 235 236 dev = link->priv; 237 did = handle_to_dev(link).driver_data; 238 239 DEBUG(0, "atmel_config(0x%p)\n", link); 240 241 tuple.Attributes = 0; 242 tuple.TupleData = buf; 243 tuple.TupleDataMax = sizeof(buf); 244 tuple.TupleOffset = 0; 245 246 /* 247 In this loop, we scan the CIS for configuration table entries, 248 each of which describes a valid card configuration, including 249 voltage, IO window, memory window, and interrupt settings. 250 251 We make no assumptions about the card to be configured: we use 252 just the information available in the CIS. In an ideal world, 253 this would work for any PCMCIA card, but it requires a complete 254 and accurate CIS. In practice, a driver usually "knows" most of 255 these things without consulting the CIS, and most client drivers 256 will only use the CIS to fill in implementation-defined details. 257 */ 258 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 259 CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple)); 260 while (1) { 261 cistpl_cftable_entry_t dflt = { 0 }; 262 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); 263 if (pcmcia_get_tuple_data(link, &tuple) != 0 || 264 pcmcia_parse_tuple(link, &tuple, &parse) != 0) 265 goto next_entry; 266 267 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg; 268 if (cfg->index == 0) goto next_entry; 269 link->conf.ConfigIndex = cfg->index; 270 271 /* Does this card need audio output? */ 272 if (cfg->flags & CISTPL_CFTABLE_AUDIO) { 273 link->conf.Attributes |= CONF_ENABLE_SPKR; 274 link->conf.Status = CCSR_AUDIO_ENA; 275 } 276 277 /* Use power settings for Vcc and Vpp if present */ 278 /* Note that the CIS values need to be rescaled */ 279 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM)) 280 link->conf.Vpp = 281 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000; 282 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM)) 283 link->conf.Vpp = 284 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000; 285 286 /* Do we need to allocate an interrupt? */ 287 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) 288 link->conf.Attributes |= CONF_ENABLE_IRQ; 289 290 /* IO window settings */ 291 link->io.NumPorts1 = link->io.NumPorts2 = 0; 292 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { 293 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; 294 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; 295 if (!(io->flags & CISTPL_IO_8BIT)) 296 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; 297 if (!(io->flags & CISTPL_IO_16BIT)) 298 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 299 link->io.BasePort1 = io->win[0].base; 300 link->io.NumPorts1 = io->win[0].len; 301 if (io->nwin > 1) { 302 link->io.Attributes2 = link->io.Attributes1; 303 link->io.BasePort2 = io->win[1].base; 304 link->io.NumPorts2 = io->win[1].len; 305 } 306 } 307 308 /* This reserves IO space but doesn't actually enable it */ 309 if (pcmcia_request_io(link, &link->io) != 0) 310 goto next_entry; 311 312 /* If we got this far, we're cool! */ 313 break; 314 315 next_entry: 316 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple)); 317 } 318 319 /* 320 Allocate an interrupt line. Note that this does not assign a 321 handler to the interrupt, unless the 'Handler' member of the 322 irq structure is initialized. 323 */ 324 if (link->conf.Attributes & CONF_ENABLE_IRQ) 325 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq)); 326 327 /* 328 This actually configures the PCMCIA socket -- setting up 329 the I/O windows and the interrupt mapping, and putting the 330 card and host interface into "Memory and IO" mode. 331 */ 332 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf)); 333 334 if (link->irq.AssignedIRQ == 0) { 335 printk(KERN_ALERT 336 "atmel: cannot assign IRQ: check that CONFIG_ISA is set in kernel config."); 337 goto cs_failed; 338 } 339 340 ((local_info_t*)link->priv)->eth_dev = 341 init_atmel_card(link->irq.AssignedIRQ, 342 link->io.BasePort1, 343 did ? did->driver_info : ATMEL_FW_TYPE_NONE, 344 &handle_to_dev(link), 345 card_present, 346 link); 347 if (!((local_info_t*)link->priv)->eth_dev) 348 goto cs_failed; 349 350 351 /* 352 At this point, the dev_node_t structure(s) need to be 353 initialized and arranged in a linked list at link->dev_node. 354 */ 355 strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name ); 356 dev->node.major = dev->node.minor = 0; 357 link->dev_node = &dev->node; 358 359 return 0; 360 361 cs_failed: 362 cs_error(link, last_fn, last_ret); 363 atmel_release(link); 364 return -ENODEV; 365} 366 367/*====================================================================== 368 369 After a card is removed, atmel_release() will unregister the 370 device, and release the PCMCIA configuration. If the device is 371 still open, this will be postponed until it is closed. 372 373 ======================================================================*/ 374 375static void atmel_release(struct pcmcia_device *link) 376{ 377 struct net_device *dev = ((local_info_t*)link->priv)->eth_dev; 378 379 DEBUG(0, "atmel_release(0x%p)\n", link); 380 381 if (dev) 382 stop_atmel_card(dev); 383 ((local_info_t*)link->priv)->eth_dev = NULL; 384 385 pcmcia_disable_device(link); 386} 387 388static int atmel_suspend(struct pcmcia_device *link) 389{ 390 local_info_t *local = link->priv; 391 392 netif_device_detach(local->eth_dev); 393 394 return 0; 395} 396 397static int atmel_resume(struct pcmcia_device *link) 398{ 399 local_info_t *local = link->priv; 400 401 atmel_open(local->eth_dev); 402 netif_device_attach(local->eth_dev); 403 404 return 0; 405} 406 407/*====================================================================*/ 408/* We use the driver_info field to store the correct firmware type for a card. */ 409 410#define PCMCIA_DEVICE_MANF_CARD_INFO(manf, card, info) { \ 411 .match_flags = PCMCIA_DEV_ID_MATCH_MANF_ID| \ 412 PCMCIA_DEV_ID_MATCH_CARD_ID, \ 413 .manf_id = (manf), \ 414 .card_id = (card), \ 415 .driver_info = (kernel_ulong_t)(info), } 416 417#define PCMCIA_DEVICE_PROD_ID12_INFO(v1, v2, vh1, vh2, info) { \ 418 .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID1| \ 419 PCMCIA_DEV_ID_MATCH_PROD_ID2, \ 420 .prod_id = { (v1), (v2), NULL, NULL }, \ 421 .prod_id_hash = { (vh1), (vh2), 0, 0 }, \ 422 .driver_info = (kernel_ulong_t)(info), } 423 424static struct pcmcia_device_id atmel_ids[] = { 425 PCMCIA_DEVICE_MANF_CARD_INFO(0x0101, 0x0620, ATMEL_FW_TYPE_502_3COM), 426 PCMCIA_DEVICE_MANF_CARD_INFO(0x0101, 0x0696, ATMEL_FW_TYPE_502_3COM), 427 PCMCIA_DEVICE_MANF_CARD_INFO(0x01bf, 0x3302, ATMEL_FW_TYPE_502E), 428 PCMCIA_DEVICE_MANF_CARD_INFO(0xd601, 0x0007, ATMEL_FW_TYPE_502), 429 PCMCIA_DEVICE_PROD_ID12_INFO("11WAVE", "11WP611AL-E", 0x9eb2da1f, 0xc9a0d3f9, ATMEL_FW_TYPE_502E), 430 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR", 0xabda4164, 0x41b37e1f, ATMEL_FW_TYPE_502), 431 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR_D", 0xabda4164, 0x3675d704, ATMEL_FW_TYPE_502D), 432 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR_E", 0xabda4164, 0x4172e792, ATMEL_FW_TYPE_502E), 433 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504_R", 0xabda4164, 0x917f3d72, ATMEL_FW_TYPE_504_2958), 434 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504", 0xabda4164, 0x5040670a, ATMEL_FW_TYPE_504), 435 PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504A", 0xabda4164, 0xe15ed87f, ATMEL_FW_TYPE_504A_2958), 436 PCMCIA_DEVICE_PROD_ID12_INFO("BT", "Voyager 1020 Laptop Adapter", 0xae49b86a, 0x1e957cd5, ATMEL_FW_TYPE_502), 437 PCMCIA_DEVICE_PROD_ID12_INFO("CNet", "CNWLC 11Mbps Wireless PC Card V-5", 0xbc477dde, 0x502fae6b, ATMEL_FW_TYPE_502E), 438 PCMCIA_DEVICE_PROD_ID12_INFO("IEEE 802.11b", "Wireless LAN PC Card", 0x5b878724, 0x122f1df6, ATMEL_FW_TYPE_502), 439 PCMCIA_DEVICE_PROD_ID12_INFO("IEEE 802.11b", "Wireless LAN Card S", 0x5b878724, 0x5fba533a, ATMEL_FW_TYPE_504_2958), 440 PCMCIA_DEVICE_PROD_ID12_INFO("OEM", "11Mbps Wireless LAN PC Card V-3", 0xfea54c90, 0x1c5b0f68, ATMEL_FW_TYPE_502), 441 PCMCIA_DEVICE_PROD_ID12_INFO("SMC", "2632W", 0xc4f8b18b, 0x30f38774, ATMEL_FW_TYPE_502D), 442 PCMCIA_DEVICE_PROD_ID12_INFO("SMC", "2632W-V2", 0xc4f8b18b, 0x172d1377, ATMEL_FW_TYPE_502), 443 PCMCIA_DEVICE_PROD_ID12_INFO("Wireless", "PC_CARD", 0xa407ecdd, 0x119f6314, ATMEL_FW_TYPE_502D), 444 PCMCIA_DEVICE_PROD_ID12_INFO("WLAN", "802.11b PC CARD", 0x575c516c, 0xb1f6dbc4, ATMEL_FW_TYPE_502D), 445 PCMCIA_DEVICE_PROD_ID12_INFO("LG", "LW2100N", 0xb474d43a, 0x6b1fec94, ATMEL_FW_TYPE_502E), 446 PCMCIA_DEVICE_NULL 447}; 448 449MODULE_DEVICE_TABLE(pcmcia, atmel_ids); 450 451static struct pcmcia_driver atmel_driver = { 452 .owner = THIS_MODULE, 453 .drv = { 454 .name = "atmel_cs", 455 }, 456 .probe = atmel_probe, 457 .remove = atmel_detach, 458 .id_table = atmel_ids, 459 .suspend = atmel_suspend, 460 .resume = atmel_resume, 461}; 462 463static int atmel_cs_init(void) 464{ 465 return pcmcia_register_driver(&atmel_driver); 466} 467 468static void atmel_cs_cleanup(void) 469{ 470 pcmcia_unregister_driver(&atmel_driver); 471} 472 473/* 474 This program is free software; you can redistribute it and/or 475 modify it under the terms of the GNU General Public License 476 as published by the Free Software Foundation; either version 2 477 of the License, or (at your option) any later version. 478 479 This program is distributed in the hope that it will be useful, 480 but WITHOUT ANY WARRANTY; without even the implied warranty of 481 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 482 GNU General Public License for more details. 483 484 In addition: 485 486 Redistribution and use in source and binary forms, with or without 487 modification, are permitted provided that the following conditions 488 are met: 489 490 1. Redistributions of source code must retain the above copyright 491 notice, this list of conditions and the following disclaimer. 492 2. Redistributions in binary form must reproduce the above copyright 493 notice, this list of conditions and the following disclaimer in the 494 documentation and/or other materials provided with the distribution. 495 3. The name of the author may not be used to endorse or promote 496 products derived from this software without specific prior written 497 permission. 498 499 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 500 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 501 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 502 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 503 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 504 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 505 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 506 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 507 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 508 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 509 POSSIBILITY OF SUCH DAMAGE. 510*/ 511 512module_init(atmel_cs_init); 513module_exit(atmel_cs_cleanup); 514