drivers/net/wireless/airo_cs.c

   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 #include <linux/config.h>
  24 #ifdef __IN_PCMCIA_PACKAGE__
  25 #include <pcmcia/k_compat.h>
  26 #endif
  27 #include <linux/init.h>
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <linux/ptrace.h>
  31 #include <linux/slab.h>
  32 #include <linux/string.h>
  33 #include <linux/timer.h>
  34 #include <linux/netdevice.h>
  35
  36 #include <pcmcia/cs_types.h>
  37 #include <pcmcia/cs.h>
  38 #include <pcmcia/cistpl.h>
  39 #include <pcmcia/cisreg.h>
  40 #include <pcmcia/ds.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/system.h>
  44
  45 #include "airo.h"
  46
  47 /*
  48    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
  49    you do not define PCMCIA_DEBUG at all, all the debug code will be
  50    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
  51    be present but disabled -- but it can then be enabled for specific
  52    modules at load time with a 'pc_debug=#' option to insmod.
  53 */
  54 #ifdef PCMCIA_DEBUG
  55 static int pc_debug = PCMCIA_DEBUG;
  56 module_param(pc_debug, int, 0);
  57 static char *version = "$Revision: 1.2 $";
  58 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
  59 #else
  60 #define DEBUG(n, args...)
  61 #endif
  62
  63 /*====================================================================*/
  64
  65 MODULE_AUTHOR("Benjamin Reed");
  66 MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet \
  67                    cards.  This is the module that links the PCMCIA card \
  68                    with the airo module.");
  69 MODULE_LICENSE("Dual BSD/GPL");
  70 MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
  71
  72 /*====================================================================*/
  73
  74 /*
  75    The event() function is this driver's Card Services event handler.
  76    It will be called by Card Services when an appropriate card status
  77    event is received.  The config() and release() entry points are
  78    used to configure or release a socket, in response to card
  79    insertion and ejection events.  They are invoked from the airo_cs
  80    event handler.
  81 */
  82
  83 static void airo_config(dev_link_t *link);
  84 static void airo_release(dev_link_t *link);
  85
  86 /*
  87    The attach() and detach() entry points are used to create and destroy
  88    "instances" of the driver, where each instance represents everything
  89    needed to manage one actual PCMCIA card.
  90 */
  91
  92 static void airo_detach(struct pcmcia_device *p_dev);
  93
  94 /*
  95    You'll also need to prototype all the functions that will actually
  96    be used to talk to your device.  See 'pcmem_cs' for a good example
  97    of a fully self-sufficient driver; the other drivers rely more or
  98    less on other parts of the kernel.
  99 */
 100
 101 /*
 102    A linked list of "instances" of the  aironet device.  Each actual
 103    PCMCIA card corresponds to one device instance, and is described
 104    by one dev_link_t structure (defined in ds.h).
 105
 106    You may not want to use a linked list for this -- for example, the
 107    memory card driver uses an array of dev_link_t pointers, where minor
 108    device numbers are used to derive the corresponding 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 dev_link_t
 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
 127 typedef 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
 144 static int airo_attach(struct pcmcia_device *p_dev)
 145 {
 146         dev_link_t *link;
 147         local_info_t *local;
 148
 149         DEBUG(0, "airo_attach()\n");
 150
 151         /* Initialize the dev_link_t structure */
 152         link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL);
 153         if (!link) {
 154                 printk(KERN_ERR "airo_cs: no memory for new device\n");
 155                 return -ENOMEM;
 156         }
 157
 158         /* Interrupt setup */
 159         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 160         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 161         link->irq.Handler = NULL;
 162
 163         /*
 164           General socket configuration defaults can go here.  In this
 165           client, we assume very little, and rely on the CIS for almost
 166           everything.  In most clients, many details (i.e., number, sizes,
 167           and attributes of IO windows) are fixed by the nature of the
 168           device, and can be hard-wired here.
 169         */
 170         link->conf.Attributes = 0;
 171         link->conf.IntType = INT_MEMORY_AND_IO;
 172
 173         /* Allocate space for private device-specific data */
 174         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
 175         if (!local) {
 176                 printk(KERN_ERR "airo_cs: no memory for new device\n");
 177                 kfree (link);
 178                 return -ENOMEM;
 179         }
 180         link->priv = local;
 181
 182         link->handle = p_dev;
 183         p_dev->instance = link;
 184
 185         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 186         airo_config(link);
 187
 188         return 0;
 189 } /* airo_attach */
 190
 191 /*======================================================================
 192
 193   This deletes a driver "instance".  The device is de-registered
 194   with Card Services.  If it has been released, all local data
 195   structures are freed.  Otherwise, the structures will be freed
 196   when the device is released.
 197
 198   ======================================================================*/
 199
 200 static void airo_detach(struct pcmcia_device *p_dev)
 201 {
 202         dev_link_t *link = dev_to_instance(p_dev);
 203
 204         DEBUG(0, "airo_detach(0x%p)\n", link);
 205
 206         if (link->state & DEV_CONFIG)
 207                 airo_release(link);
 208
 209         if ( ((local_info_t*)link->priv)->eth_dev ) {
 210                 stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
 211         }
 212         ((local_info_t*)link->priv)->eth_dev = NULL;
 213
 214         kfree(link->priv);
 215         kfree(link);
 216 } /* airo_detach */
 217
 218 /*======================================================================
 219
 220   airo_config() is scheduled to run after a CARD_INSERTION event
 221   is received, to configure the PCMCIA socket, and to make the
 222   device available to the system.
 223
 224   ======================================================================*/
 225
 226 #define CS_CHECK(fn, ret) \
 227 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 228
 229 static void airo_config(dev_link_t *link)
 230 {
 231         client_handle_t handle;
 232         tuple_t tuple;
 233         cisparse_t parse;
 234         local_info_t *dev;
 235         int last_fn, last_ret;
 236         u_char buf[64];
 237         win_req_t req;
 238         memreq_t map;
 239
 240         handle = link->handle;
 241         dev = link->priv;
 242
 243         DEBUG(0, "airo_config(0x%p)\n", link);
 244
 245         /*
 246           This reads the card's CONFIG tuple to find its configuration
 247           registers.
 248         */
 249         tuple.DesiredTuple = CISTPL_CONFIG;
 250         tuple.Attributes = 0;
 251         tuple.TupleData = buf;
 252         tuple.TupleDataMax = sizeof(buf);
 253         tuple.TupleOffset = 0;
 254         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 255         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 256         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 257         link->conf.ConfigBase = parse.config.base;
 258         link->conf.Present = parse.config.rmask[0];
 259
 260         /* Configure card */
 261         link->state |= DEV_CONFIG;
 262
 263         /*
 264           In this loop, we scan the CIS for configuration table entries,
 265           each of which describes a valid card configuration, including
 266           voltage, IO window, memory window, and interrupt settings.
 267
 268           We make no assumptions about the card to be configured: we use
 269           just the information available in the CIS.  In an ideal world,
 270           this would work for any PCMCIA card, but it requires a complete
 271           and accurate CIS.  In practice, a driver usually "knows" most of
 272           these things without consulting the CIS, and most client drivers
 273           will only use the CIS to fill in implementation-defined details.
 274         */
 275         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 276         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 277         while (1) {
 278                 cistpl_cftable_entry_t dflt = { 0 };
 279                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 280                 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
 281                                 pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
 282                         goto next_entry;
 283
 284                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
 285                 if (cfg->index == 0) goto next_entry;
 286                 link->conf.ConfigIndex = cfg->index;
 287
 288                 /* Does this card need audio output? */
 289                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
 290                         link->conf.Attributes |= CONF_ENABLE_SPKR;
 291                         link->conf.Status = CCSR_AUDIO_ENA;
 292                 }
 293
 294                 /* Use power settings for Vcc and Vpp if present */
 295                 /*  Note that the CIS values need to be rescaled */
 296                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
 297                         link->conf.Vpp =
 298                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
 299                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
 300                         link->conf.Vpp =
 301                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
 302
 303                 /* Do we need to allocate an interrupt? */
 304                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
 305                         link->conf.Attributes |= CONF_ENABLE_IRQ;
 306
 307                 /* IO window settings */
 308                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
 309                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
 310                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
 311                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 312                         if (!(io->flags & CISTPL_IO_8BIT))
 313                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 314                         if (!(io->flags & CISTPL_IO_16BIT))
 315                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 316                         link->io.BasePort1 = io->win[0].base;
 317                         link->io.NumPorts1 = io->win[0].len;
 318                         if (io->nwin > 1) {
 319                                 link->io.Attributes2 = link->io.Attributes1;
 320                                 link->io.BasePort2 = io->win[1].base;
 321                                 link->io.NumPorts2 = io->win[1].len;
 322                         }
 323                 }
 324
 325                 /* This reserves IO space but doesn't actually enable it */
 326                 if (pcmcia_request_io(link->handle, &link->io) != 0)
 327                         goto next_entry;
 328
 329                 /*
 330                   Now set up a common memory window, if needed.  There is room
 331                   in the dev_link_t structure for one memory window handle,
 332                   but if the base addresses need to be saved, or if multiple
 333                   windows are needed, the info should go in the private data
 334                   structure for this device.
 335
 336                   Note that the memory window base is a physical address, and
 337                   needs to be mapped to virtual space with ioremap() before it
 338                   is used.
 339                 */
 340                 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
 341                         cistpl_mem_t *mem =
 342                                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
 343                         req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
 344                         req.Base = mem->win[0].host_addr;
 345                         req.Size = mem->win[0].len;
 346                         req.AccessSpeed = 0;
 347                         if (pcmcia_request_window(&link->handle, &req, &link->win) != 0)
 348                                 goto next_entry;
 349                         map.Page = 0; map.CardOffset = mem->win[0].card_addr;
 350                         if (pcmcia_map_mem_page(link->win, &map) != 0)
 351                                 goto next_entry;
 352                 }
 353                 /* If we got this far, we're cool! */
 354                 break;
 355
 356         next_entry:
 357                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
 358         }
 359
 360     /*
 361       Allocate an interrupt line.  Note that this does not assign a
 362       handler to the interrupt, unless the 'Handler' member of the
 363       irq structure is initialized.
 364     */
 365         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 366                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 367
 368         /*
 369           This actually configures the PCMCIA socket -- setting up
 370           the I/O windows and the interrupt mapping, and putting the
 371           card and host interface into "Memory and IO" mode.
 372         */
 373         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 374         ((local_info_t*)link->priv)->eth_dev =
 375                 init_airo_card( link->irq.AssignedIRQ,
 376                                 link->io.BasePort1, 1, &handle_to_dev(handle) );
 377         if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
 378
 379         /*
 380           At this point, the dev_node_t structure(s) need to be
 381           initialized and arranged in a linked list at link->dev.
 382         */
 383         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
 384         dev->node.major = dev->node.minor = 0;
 385         link->dev = &dev->node;
 386
 387         /* Finally, report what we've done */
 388         printk(KERN_INFO "%s: index 0x%02x: ",
 389                dev->node.dev_name, link->conf.ConfigIndex);
 390         if (link->conf.Vpp)
 391                 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
 392         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 393                 printk(", irq %d", link->irq.AssignedIRQ);
 394         if (link->io.NumPorts1)
 395                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 396                        link->io.BasePort1+link->io.NumPorts1-1);
 397         if (link->io.NumPorts2)
 398                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 399                        link->io.BasePort2+link->io.NumPorts2-1);
 400         if (link->win)
 401                 printk(", mem 0x%06lx-0x%06lx", req.Base,
 402                        req.Base+req.Size-1);
 403         printk("\n");
 404
 405         link->state &= ~DEV_CONFIG_PENDING;
 406         return;
 407
 408  cs_failed:
 409         cs_error(link->handle, last_fn, last_ret);
 410         airo_release(link);
 411
 412 } /* airo_config */
 413
 414 /*======================================================================
 415
 416   After a card is removed, airo_release() will unregister the
 417   device, and release the PCMCIA configuration.  If the device is
 418   still open, this will be postponed until it is closed.
 419
 420   ======================================================================*/
 421
 422 static void airo_release(dev_link_t *link)
 423 {
 424         DEBUG(0, "airo_release(0x%p)\n", link);
 425         pcmcia_disable_device(link->handle);
 426 }
 427
 428 static int airo_suspend(struct pcmcia_device *p_dev)
 429 {
 430         dev_link_t *link = dev_to_instance(p_dev);
 431         local_info_t *local = link->priv;
 432
 433         if (link->state & DEV_CONFIG)
 434                 netif_device_detach(local->eth_dev);
 435
 436         return 0;
 437 }
 438
 439 static int airo_resume(struct pcmcia_device *p_dev)
 440 {
 441         dev_link_t *link = dev_to_instance(p_dev);
 442         local_info_t *local = link->priv;
 443
 444         if ((link->state & DEV_CONFIG) && (link->open)) {
 445                 reset_airo_card(local->eth_dev);
 446                 netif_device_attach(local->eth_dev);
 447         }
 448
 449         return 0;
 450 }
 451
 452 static struct pcmcia_device_id airo_ids[] = {
 453         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
 454         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
 455         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
 456         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
 457         PCMCIA_DEVICE_NULL,
 458 };
 459 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
 460
 461 static struct pcmcia_driver airo_driver = {
 462         .owner          = THIS_MODULE,
 463         .drv            = {
 464                 .name   = "airo_cs",
 465         },
 466         .probe          = airo_attach,
 467         .remove         = airo_detach,
 468         .id_table       = airo_ids,
 469         .suspend        = airo_suspend,
 470         .resume         = airo_resume,
 471 };
 472
 473 static int airo_cs_init(void)
 474 {
 475         return pcmcia_register_driver(&airo_driver);
 476 }
 477
 478 static void airo_cs_cleanup(void)
 479 {
 480         pcmcia_unregister_driver(&airo_driver);
 481 }
 482
 483 /*
 484     This program is free software; you can redistribute it and/or
 485     modify it under the terms of the GNU General Public License
 486     as published by the Free Software Foundation; either version 2
 487     of the License, or (at your option) any later version.
 488
 489     This program is distributed in the hope that it will be useful,
 490     but WITHOUT ANY WARRANTY; without even the implied warranty of
 491     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 492     GNU General Public License for more details.
 493
 494     In addition:
 495
 496     Redistribution and use in source and binary forms, with or without
 497     modification, are permitted provided that the following conditions
 498     are met:
 499
 500     1. Redistributions of source code must retain the above copyright
 501        notice, this list of conditions and the following disclaimer.
 502     2. Redistributions in binary form must reproduce the above copyright
 503        notice, this list of conditions and the following disclaimer in the
 504        documentation and/or other materials provided with the distribution.
 505     3. The name of the author may not be used to endorse or promote
 506        products derived from this software without specific prior written
 507        permission.
 508
 509     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 510     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 511     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 512     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 513     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 514     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 515     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 516     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 517     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 518     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 519     POSSIBILITY OF SUCH DAMAGE.
 520 */
 521
 522 module_init(airo_cs_init);
 523 module_exit(airo_cs_cleanup);