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 int airo_config(struct pcmcia_device *link);
  84 static void airo_release(struct pcmcia_device *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 struct pcmcia_device 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 struct pcmcia_device 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 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
 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_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_EXCLUSIVE;
 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
 185 static 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) \
 208 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 209
 210 static int airo_config(struct pcmcia_device *link)
 211 {
 212         tuple_t tuple;
 213         cisparse_t parse;
 214         local_info_t *dev;
 215         int last_fn, last_ret;
 216         u_char buf[64];
 217         win_req_t req;
 218         memreq_t map;
 219
 220         dev = link->priv;
 221
 222         DEBUG(0, "airo_config(0x%p)\n", link);
 223
 224         /*
 225           This reads the card's CONFIG tuple to find its configuration
 226           registers.
 227         */
 228         tuple.DesiredTuple = CISTPL_CONFIG;
 229         tuple.Attributes = 0;
 230         tuple.TupleData = buf;
 231         tuple.TupleDataMax = sizeof(buf);
 232         tuple.TupleOffset = 0;
 233         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 234         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(link, &tuple));
 235         CS_CHECK(ParseTuple, pcmcia_parse_tuple(link, &tuple, &parse));
 236         link->conf.ConfigBase = parse.config.base;
 237         link->conf.Present = parse.config.rmask[0];
 238
 239         /*
 240           In this loop, we scan the CIS for configuration table entries,
 241           each of which describes a valid card configuration, including
 242           voltage, IO window, memory window, and interrupt settings.
 243
 244           We make no assumptions about the card to be configured: we use
 245           just the information available in the CIS.  In an ideal world,
 246           this would work for any PCMCIA card, but it requires a complete
 247           and accurate CIS.  In practice, a driver usually "knows" most of
 248           these things without consulting the CIS, and most client drivers
 249           will only use the CIS to fill in implementation-defined details.
 250         */
 251         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 252         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
 253         while (1) {
 254                 cistpl_cftable_entry_t dflt = { 0 };
 255                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 256                 if (pcmcia_get_tuple_data(link, &tuple) != 0 ||
 257                                 pcmcia_parse_tuple(link, &tuple, &parse) != 0)
 258                         goto next_entry;
 259
 260                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
 261                 if (cfg->index == 0) goto next_entry;
 262                 link->conf.ConfigIndex = cfg->index;
 263
 264                 /* Does this card need audio output? */
 265                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
 266                         link->conf.Attributes |= CONF_ENABLE_SPKR;
 267                         link->conf.Status = CCSR_AUDIO_ENA;
 268                 }
 269
 270                 /* Use power settings for Vcc and Vpp if present */
 271                 /*  Note that the CIS values need to be rescaled */
 272                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
 273                         link->conf.Vpp =
 274                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
 275                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
 276                         link->conf.Vpp =
 277                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
 278
 279                 /* Do we need to allocate an interrupt? */
 280                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
 281                         link->conf.Attributes |= CONF_ENABLE_IRQ;
 282
 283                 /* IO window settings */
 284                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
 285                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
 286                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
 287                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 288                         if (!(io->flags & CISTPL_IO_8BIT))
 289                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 290                         if (!(io->flags & CISTPL_IO_16BIT))
 291                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 292                         link->io.BasePort1 = io->win[0].base;
 293                         link->io.NumPorts1 = io->win[0].len;
 294                         if (io->nwin > 1) {
 295                                 link->io.Attributes2 = link->io.Attributes1;
 296                                 link->io.BasePort2 = io->win[1].base;
 297                                 link->io.NumPorts2 = io->win[1].len;
 298                         }
 299                 }
 300
 301                 /* This reserves IO space but doesn't actually enable it */
 302                 if (pcmcia_request_io(link, &link->io) != 0)
 303                         goto next_entry;
 304
 305                 /*
 306                   Now set up a common memory window, if needed.  There is room
 307                   in the struct pcmcia_device structure for one memory window handle,
 308                   but if the base addresses need to be saved, or if multiple
 309                   windows are needed, the info should go in the private data
 310                   structure for this device.
 311
 312                   Note that the memory window base is a physical address, and
 313                   needs to be mapped to virtual space with ioremap() before it
 314                   is used.
 315                 */
 316                 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
 317                         cistpl_mem_t *mem =
 318                                 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
 319                         req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
 320                         req.Base = mem->win[0].host_addr;
 321                         req.Size = mem->win[0].len;
 322                         req.AccessSpeed = 0;
 323                         if (pcmcia_request_window(&link, &req, &link->win) != 0)
 324                                 goto next_entry;
 325                         map.Page = 0; map.CardOffset = mem->win[0].card_addr;
 326                         if (pcmcia_map_mem_page(link->win, &map) != 0)
 327                                 goto next_entry;
 328                 }
 329                 /* If we got this far, we're cool! */
 330                 break;
 331
 332         next_entry:
 333                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(link, &tuple));
 334         }
 335
 336     /*
 337       Allocate an interrupt line.  Note that this does not assign a
 338       handler to the interrupt, unless the 'Handler' member of the
 339       irq structure is initialized.
 340     */
 341         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 342                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
 343
 344         /*
 345           This actually configures the PCMCIA socket -- setting up
 346           the I/O windows and the interrupt mapping, and putting the
 347           card and host interface into "Memory and IO" mode.
 348         */
 349         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
 350         ((local_info_t*)link->priv)->eth_dev =
 351                 init_airo_card( link->irq.AssignedIRQ,
 352                                 link->io.BasePort1, 1, &handle_to_dev(link) );
 353         if (!((local_info_t*)link->priv)->eth_dev) goto cs_failed;
 354
 355         /*
 356           At this point, the dev_node_t structure(s) need to be
 357           initialized and arranged in a linked list at link->dev_node.
 358         */
 359         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
 360         dev->node.major = dev->node.minor = 0;
 361         link->dev_node = &dev->node;
 362
 363         /* Finally, report what we've done */
 364         printk(KERN_INFO "%s: index 0x%02x: ",
 365                dev->node.dev_name, link->conf.ConfigIndex);
 366         if (link->conf.Vpp)
 367                 printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
 368         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 369                 printk(", irq %d", link->irq.AssignedIRQ);
 370         if (link->io.NumPorts1)
 371                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 372                        link->io.BasePort1+link->io.NumPorts1-1);
 373         if (link->io.NumPorts2)
 374                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 375                        link->io.BasePort2+link->io.NumPorts2-1);
 376         if (link->win)
 377                 printk(", mem 0x%06lx-0x%06lx", req.Base,
 378                        req.Base+req.Size-1);
 379         printk("\n");
 380         return 0;
 381
 382  cs_failed:
 383         cs_error(link, last_fn, last_ret);
 384         airo_release(link);
 385         return -ENODEV;
 386 } /* airo_config */
 387
 388 /*======================================================================
 389
 390   After a card is removed, airo_release() will unregister the
 391   device, and release the PCMCIA configuration.  If the device is
 392   still open, this will be postponed until it is closed.
 393
 394   ======================================================================*/
 395
 396 static void airo_release(struct pcmcia_device *link)
 397 {
 398         DEBUG(0, "airo_release(0x%p)\n", link);
 399         pcmcia_disable_device(link);
 400 }
 401
 402 static int airo_suspend(struct pcmcia_device *link)
 403 {
 404         local_info_t *local = link->priv;
 405
 406         netif_device_detach(local->eth_dev);
 407
 408         return 0;
 409 }
 410
 411 static int airo_resume(struct pcmcia_device *link)
 412 {
 413         local_info_t *local = link->priv;
 414
 415         if (link->open) {
 416                 reset_airo_card(local->eth_dev);
 417                 netif_device_attach(local->eth_dev);
 418         }
 419
 420         return 0;
 421 }
 422
 423 static struct pcmcia_device_id airo_ids[] = {
 424         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x000a),
 425         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0005),
 426         PCMCIA_DEVICE_MANF_CARD(0x015f, 0x0007),
 427         PCMCIA_DEVICE_MANF_CARD(0x0105, 0x0007),
 428         PCMCIA_DEVICE_NULL,
 429 };
 430 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
 431
 432 static struct pcmcia_driver airo_driver = {
 433         .owner          = THIS_MODULE,
 434         .drv            = {
 435                 .name   = "airo_cs",
 436         },
 437         .probe          = airo_probe,
 438         .remove         = airo_detach,
 439         .id_table       = airo_ids,
 440         .suspend        = airo_suspend,
 441         .resume         = airo_resume,
 442 };
 443
 444 static int airo_cs_init(void)
 445 {
 446         return pcmcia_register_driver(&airo_driver);
 447 }
 448
 449 static void airo_cs_cleanup(void)
 450 {
 451         pcmcia_unregister_driver(&airo_driver);
 452 }
 453
 454 /*
 455     This program is free software; you can redistribute it and/or
 456     modify it under the terms of the GNU General Public License
 457     as published by the Free Software Foundation; either version 2
 458     of the License, or (at your option) any later version.
 459
 460     This program is distributed in the hope that it will be useful,
 461     but WITHOUT ANY WARRANTY; without even the implied warranty of
 462     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 463     GNU General Public License for more details.
 464
 465     In addition:
 466
 467     Redistribution and use in source and binary forms, with or without
 468     modification, are permitted provided that the following conditions
 469     are met:
 470
 471     1. Redistributions of source code must retain the above copyright
 472        notice, this list of conditions and the following disclaimer.
 473     2. Redistributions in binary form must reproduce the above copyright
 474        notice, this list of conditions and the following disclaimer in the
 475        documentation and/or other materials provided with the distribution.
 476     3. The name of the author may not be used to endorse or promote
 477        products derived from this software without specific prior written
 478        permission.
 479
 480     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 481     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 482     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 483     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 484     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 485     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 486     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 487     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 488     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 489     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 490     POSSIBILITY OF SUCH DAMAGE.
 491 */
 492
 493 module_init(airo_cs_init);
 494 module_exit(airo_cs_cleanup);