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 <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
  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,
 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
 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_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
 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_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
 290 static 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
 387 static void airo_release(struct pcmcia_device *link)
 388 {
 389         DEBUG(0, "airo_release(0x%p)\n", link);
 390         pcmcia_disable_device(link);
 391 }
 392
 393 static 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
 402 static 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
 414 static 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 };
 421 MODULE_DEVICE_TABLE(pcmcia, airo_ids);
 422
 423 static 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
 435 static int airo_cs_init(void)
 436 {
 437         return pcmcia_register_driver(&airo_driver);
 438 }
 439
 440 static 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
 484 module_init(airo_cs_init);
 485 module_exit(airo_cs_cleanup);