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