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 #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 <asm/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
  54 static int pc_debug = PCMCIA_DEBUG;
  55 module_param(pc_debug, int, 0);
  56 static 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
  64 MODULE_AUTHOR("Benjamin Reed");
  65 MODULE_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.");
  68 MODULE_LICENSE("Dual BSD/GPL");
  69 MODULE_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
  82 static int airo_config(struct pcmcia_device *link);
  83 static 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
  91 static 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, where minor
 107    device numbers are used to derive the corresponding array index.
 108 */
 109
 110 /*
 111    A driver needs to provide a dev_node_t structure for each device
 112    on a card.  In some cases, there is only one device per card (for
 113    example, ethernet cards, modems).  In other cases, there may be
 114    many actual or logical devices (SCSI adapters, memory cards with
 115    multiple partitions).  The dev_node_t structures need to be kept
 116    in a linked list starting at the 'dev' field of a struct pcmcia_device
 117    structure.  We allocate them in the card's private data structure,
 118    because they generally shouldn't be allocated dynamically.
 119
 120    In this case, we also provide a flag to indicate if a device is
 121    "stopped" due to a power management event, or card ejection.  The
 122    device IO routines can use a flag like this to throttle IO to a
 123    card that is not ready to accept it.
 124 */
 125
 126 typedef struct local_info_t {
 127         dev_node_t      node;
 128         struct net_device *eth_dev;
 129 } local_info_t;
 130
 131 /*======================================================================
 132
 133   airo_attach() creates an "instance" of the driver, allocating
 134   local data structures for one device.  The device is registered
 135   with Card Services.
 136
 137   The dev_link structure is initialized, but we don't actually
 138   configure the card at this point -- we wait until we receive a
 139   card insertion event.
 140
 141   ======================================================================*/
 142
 143 static int airo_probe(struct pcmcia_device *p_dev)
 144 {
 145         local_info_t *local;
 146
 147         DEBUG(0, "airo_attach()\n");
 148
 149         /* Interrupt setup */
 150         p_dev->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 151         p_dev->irq.IRQInfo1 = IRQ_LEVEL_ID;
 152         p_dev->irq.Handler = NULL;
 153
 154         /*
 155           General socket configuration defaults can go here.  In this
 156           client, we assume very little, and rely on the CIS for almost
 157           everything.  In most clients, many details (i.e., number, sizes,
 158           and attributes of IO windows) are fixed by the nature of the
 159           device, and can be hard-wired here.
 160         */
 161         p_dev->conf.Attributes = 0;
 162         p_dev->conf.IntType = INT_MEMORY_AND_IO;
 163
 164         /* Allocate space for private device-specific data */
 165         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
 166         if (!local) {
 167                 printk(KERN_ERR "airo_cs: no memory for new device\n");
 168                 return -ENOMEM;
 169         }
 170         p_dev->priv = local;
 171
 172         return airo_config(p_dev);
 173 } /* airo_attach */
 174
 175 /*======================================================================
 176
 177   This deletes a driver "instance".  The device is de-registered
 178   with Card Services.  If it has been released, all local data
 179   structures are freed.  Otherwise, the structures will be freed
 180   when the device is released.
 181
 182   ======================================================================*/
 183
 184 static void airo_detach(struct pcmcia_device *link)
 185 {
 186         DEBUG(0, "airo_detach(0x%p)\n", link);
 187
 188         airo_release(link);
 189
 190         if ( ((local_info_t*)link->priv)->eth_dev ) {
 191                 stop_airo_card( ((local_info_t*)link->priv)->eth_dev, 0 );
 192         }
 193         ((local_info_t*)link->priv)->eth_dev = NULL;
 194
 195         kfree(link->priv);
 196 } /* airo_detach */
 197
 198 /*======================================================================
 199
 200   airo_config() is scheduled to run after a CARD_INSERTION event
 201   is received, to configure the PCMCIA socket, and to make the
 202   device available to the system.
 203
 204   ======================================================================*/
 205
 206 #define CS_CHECK(fn, ret) \
 207 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 208
 209 static int airo_config(struct pcmcia_device *link)
 210 {
 211         tuple_t tuple;
 212         cisparse_t parse;
 213         local_info_t *dev;
 214         int last_fn, last_ret;
 215         u_char buf[64];
 216         win_req_t req;
 217         memreq_t map;
 218
 219         dev = link->priv;
 220
 221         DEBUG(0, "airo_config(0x%p)\n", link);
 222
 223         /*
 224           This reads the card's CONFIG tuple to find its configuration
 225           registers.
 226         */
 227         tuple.DesiredTuple = CISTPL_CONFIG;
 228         tuple.Attributes = 0;
 229         tuple.TupleData = buf;
 230         tuple.TupleDataMax = sizeof(buf);
 231         tuple.TupleOffset = 0;
 232         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 233         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
 234         CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
 235         link->conf.ConfigBase = parse.config.base;
 236         link->conf.Present = parse.config.rmask[0];
 237
 238         /*
 239           In this loop, we scan the CIS for configuration table entries,
 240           each of which describes a valid card configuration, including
 241           voltage, IO window, memory window, and interrupt settings.
 242
 243           We make no assumptions about the card to be configured: we use
 244           just the information available in the CIS.  In an ideal world,
 245           this would work for any PCMCIA card, but it requires a complete
 246           and accurate CIS.  In practice, a driver usually "knows" most of
 247           these things without consulting the CIS, and most client drivers
 248           will only use the CIS to fill in implementation-defined details.
 249         */
 250         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 251         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 252         while (1) {
 253                 cistpl_cftable_entry_t dflt = { 0 };
 254                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 255                 if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
 256                                 pcmcia_parse_tuple(link, &tuple, &parse) != 0)
 257                         goto next_entry;
 258
 259                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
 260                 if (cfg->index == 0) goto next_entry;
 261                 link->conf.ConfigIndex = cfg->index;
 262
 263                 /* Does this card need audio output? */
 264                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
 265                         link->conf.Attributes |= CONF_ENABLE_SPKR;
 266                         link->conf.Status = CCSR_AUDIO_ENA;
 267                 }
 268
 269                 /* Use power settings for Vcc and Vpp if present */
 270                 /*  Note that the CIS values need to be rescaled */
 271                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
 272                         link->conf.Vpp =
 273                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
 274                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
 275                         link->conf.Vpp =
 276                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
 277
 278                 /* Do we need to allocate an interrupt? */
 279                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
 280                         link->conf.Attributes |= CONF_ENABLE_IRQ;
 281
 282                 /* IO window settings */
 283                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
 284                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
 285                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
 286                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 287                         if (!(io->flags & CISTPL_IO_8BIT))
 288                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 289                         if (!(io->flags & CISTPL_IO_16BIT))
 290                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 291                         link->io.BasePort1 = io->win[0].base;
 292                         link->io.NumPorts1 = io->win[0].len;
 293                         if (io->nwin > 1) {
 294                                 link->io.Attributes2 = link->io.Attributes1;
 295                                 link->io.BasePort2 = io->win[1].base;
 296                                 link->io.NumPorts2 = io->win[1].len;
 297                         }
 298                 }
 299
 300                 /* This reserves IO space but doesn't actually enable it */
 301                 if (pcmcia_request_io(link, &link->io) != 0)
 302                         goto next_entry;
 303
 304                 /*
 305                   Now set up a common memory window, if needed.  There is room
 306                   in the struct pcmcia_device structure for one memory window handle,
 307                   but if the base addresses need to be saved, or if multiple
 308                   windows are needed, the info should go in the private data
 309                   structure for this device.
 310
 311                   Note that the memory window base is a physical address, and
 312                   needs to be mapped to virtual space with ioremap() before it
 313                   is used.
 314                 */
 315                 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
 316                         cistpl_mem_t *mem =
 317                                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
 318                         req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
 319                         req.Base = mem->win[0].host_addr;
 320                         req.Size = mem->win[0].len;
 321                         req.AccessSpeed = 0;
 322                         if (pcmcia_request_window(&link, &req, &link->win) != 0)
 323                                 goto next_entry;
 324                         map.Page = 0; map.CardOffset = mem->win[0].card_addr;
 325                         if (pcmcia_map_mem_page(link->win, &map) != 0)
 326                                 goto next_entry;
 327                 }
 328                 /* If we got this far, we're cool! */
 329                 break;
 330
 331         next_entry:
 332                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
 333         }
 334
 335     /*
 336       Allocate an interrupt line.  Note that this does not assign a
 337       handler to the interrupt, unless the 'Handler' member of the
 338       irq structure is initialized.
 339     */
 340         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 341                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 342
 343         /*
 344           This actually configures the PCMCIA socket -- setting up
 345           the I/O windows and the interrupt mapping, and putting the
 346           card and host interface into "Memory and IO" mode.
 347         */
 348         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 349         ((local_info_t*)link->priv)->eth_dev =
 350                 init_airo_card( link->irq.AssignedIRQ,
 351                                 link->io.BasePort1, 1, &handle_to_dev(link) );
 352         if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
 353
 354         /*
 355           At this point, the dev_node_t structure(s) need to be
 356           initialized and arranged in a linked list at link->dev_node.
 357         */
 358         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
 359         dev->node.major = dev->node.minor = 0;
 360         link->dev_node = &dev->node;
 361
 362         /* Finally, report what we've done */
 363         printk(KERN_INFO "%s: index 0x%02x: ",
 364                dev->node.dev_name, link->conf.ConfigIndex);
 365         if (link->conf.Vpp)
 366                 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
 367         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 368                 printk(", irq %d", link->irq.AssignedIRQ);
 369         if (link->io.NumPorts1)
 370                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 371                        link->io.BasePort1+link->io.NumPorts1-1);
 372         if (link->io.NumPorts2)
 373                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 374                        link->io.BasePort2+link->io.NumPorts2-1);
 375         if (link->win)
 376                 printk(", mem 0x%06lx-0x%06lx", req.Base,
 377                        req.Base+req.Size-1);
 378         printk("\n");
 379         return 0;
 380
 381  cs_failed:
 382         cs_error(link, last_fn, last_ret);
 383         airo_release(link);
 384         return -ENODEV;
 385 } /* airo_config */
 386
 387 /*======================================================================
 388
 389   After a card is removed, airo_release() will unregister the
 390   device, and release the PCMCIA configuration.  If the device is
 391   still open, this will be postponed until it is closed.
 392
 393   ======================================================================*/
 394
 395 static void airo_release(struct pcmcia_device *link)
 396 {
 397         DEBUG(0, "airo_release(0x%p)\n", link);
 398         pcmcia_disable_device(link);
 399 }
 400
 401 static int airo_suspend(struct pcmcia_device *link)
 402 {
 403         local_info_t *local = link->priv;
 404
 405         netif_device_detach(local->eth_dev);
 406
 407         return 0;
 408 }
 409
 410 static int airo_resume(struct pcmcia_device *link)
 411 {
 412         local_info_t *local = link->priv;
 413
 414         if (link->open) {
 415                 reset_airo_card(local->eth_dev);
 416                 netif_device_attach(local->eth_dev);
 417         }
 418
 419         return 0;
 420 }
 421
 422 static struct pcmcia_device_id airo_ids[] = {
 423         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
 424         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
 425         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
 426         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
 427         PCMCIA_DEVICE_NULL,
 428 };
 429 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
 430
 431 static struct pcmcia_driver airo_driver = {
 432         .owner          = THIS_MODULE,
 433         .drv            = {
 434                 .name   = "airo_cs",
 435         },
 436         .probe          = airo_probe,
 437         .remove         = airo_detach,
 438         .id_table       = airo_ids,
 439         .suspend        = airo_suspend,
 440         .resume         = airo_resume,
 441 };
 442
 443 static int airo_cs_init(void)
 444 {
 445         return pcmcia_register_driver(&airo_driver);
 446 }
 447
 448 static void airo_cs_cleanup(void)
 449 {
 450         pcmcia_unregister_driver(&airo_driver);
 451 }
 452
 453 /*
 454     This program is free software; you can redistribute it and/or
 455     modify it under the terms of the GNU General Public License
 456     as published by the Free Software Foundation; either version 2
 457     of the License, or (at your option) any later version.
 458
 459     This program is distributed in the hope that it will be useful,
 460     but WITHOUT ANY WARRANTY; without even the implied warranty of
 461     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 462     GNU General Public License for more details.
 463
 464     In addition:
 465
 466     Redistribution and use in source and binary forms, with or without
 467     modification, are permitted provided that the following conditions
 468     are met:
 469
 470     1. Redistributions of source code must retain the above copyright
 471        notice, this list of conditions and the following disclaimer.
 472     2. Redistributions in binary form must reproduce the above copyright
 473        notice, this list of conditions and the following disclaimer in the
 474        documentation and/or other materials provided with the distribution.
 475     3. The name of the author may not be used to endorse or promote
 476        products derived from this software without specific prior written
 477        permission.
 478
 479     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 480     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 481     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 482     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 483     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 484     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 485     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 486     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 487     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 488     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 489     POSSIBILITY OF SUCH DAMAGE.
 490 */
 491
 492 module_init(airo_cs_init);
 493 module_exit(airo_cs_cleanup);