drivers/net/wireless/atmel_cs.c

   1 /*** -*- linux-c -*- **********************************************************
   2
   3      Driver for Atmel at76c502 at76c504 and at76c506 wireless cards.
   4
   5         Copyright 2000-2001 ATMEL Corporation.
   6         Copyright 2003 Simon Kelley.
   7
   8     This code was developed from version 2.1.1 of the Atmel drivers,
   9     released by Atmel corp. under the GPL in December 2002. It also
  10     includes code from the Linux aironet drivers (C) Benjamin Reed,
  11     and the Linux PCMCIA package, (C) David Hinds.
  12
  13     For all queries about this code, please contact the current author,
  14     Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation.
  15
  16     This program is free software; you can redistribute it and/or modify
  17     it under the terms of the GNU General Public License as published by
  18     the Free Software Foundation; either version 2 of the License, or
  19     (at your option) any later version.
  20
  21     This software is distributed in the hope that it will be useful,
  22     but WITHOUT ANY WARRANTY; without even the implied warranty of
  23     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24     GNU General Public License for more details.
  25
  26     You should have received a copy of the GNU General Public License
  27     along with Atmel wireless lan drivers; if not, write to the Free Software
  28     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29
  30 ******************************************************************************/
  31
  32 #include <linux/config.h>
  33 #ifdef __IN_PCMCIA_PACKAGE__
  34 #include <pcmcia/k_compat.h>
  35 #endif
  36 #include <linux/init.h>
  37 #include <linux/kernel.h>
  38 #include <linux/module.h>
  39 #include <linux/ptrace.h>
  40 #include <linux/slab.h>
  41 #include <linux/string.h>
  42 #include <linux/netdevice.h>
  43 #include <linux/moduleparam.h>
  44 #include <linux/device.h>
  45
  46 #include <pcmcia/cs_types.h>
  47 #include <pcmcia/cs.h>
  48 #include <pcmcia/cistpl.h>
  49 #include <pcmcia/cisreg.h>
  50 #include <pcmcia/ds.h>
  51 #include <pcmcia/ciscode.h>
  52
  53 #include <asm/io.h>
  54 #include <asm/system.h>
  55 #include <linux/wireless.h>
  56
  57 #include "atmel.h"
  58
  59 /*
  60    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
  61    you do not define PCMCIA_DEBUG at all, all the debug code will be
  62    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
  63    be present but disabled -- but it can then be enabled for specific
  64    modules at load time with a 'pc_debug=#' option to insmod.
  65 */
  66
  67 #ifdef PCMCIA_DEBUG
  68 static int pc_debug = PCMCIA_DEBUG;
  69 module_param(pc_debug, int, 0);
  70 static char *version = "$Revision: 1.2 $";
  71 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
  72 #else
  73 #define DEBUG(n, args...)
  74 #endif
  75
  76 /*====================================================================*/
  77
  78 MODULE_AUTHOR("Simon Kelley");
  79 MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
  80 MODULE_LICENSE("GPL");
  81 MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
  82
  83 /*====================================================================*/
  84
  85 /*
  86    The event() function is this driver's Card Services event handler.
  87    It will be called by Card Services when an appropriate card status
  88    event is received.  The config() and release() entry points are
  89    used to configure or release a socket, in response to card
  90    insertion and ejection events.  They are invoked from the atmel_cs
  91    event handler.
  92 */
  93
  94 static void atmel_config(dev_link_t *link);
  95 static void atmel_release(dev_link_t *link);
  96 static int atmel_event(event_t event, int priority,
  97                        event_callback_args_t *args);
  98
  99 /*
 100    The attach() and detach() entry points are used to create and destroy
 101    "instances" of the driver, where each instance represents everything
 102    needed to manage one actual PCMCIA card.
 103 */
 104
 105 static dev_link_t *atmel_attach(void);
 106 static void atmel_detach(struct pcmcia_device *p_dev);
 107
 108 /*
 109    You'll also need to prototype all the functions that will actually
 110    be used to talk to your device.  See 'pcmem_cs' for a good example
 111    of a fully self-sufficient driver; the other drivers rely more or
 112    less on other parts of the kernel.
 113 */
 114
 115 /*
 116    The dev_info variable is the "key" that is used to match up this
 117    device driver with appropriate cards, through the card configuration
 118    database.
 119 */
 120
 121 static dev_info_t dev_info = "atmel_cs";
 122
 123 /*
 124    A linked list of "instances" of the  atmelnet device.  Each actual
 125    PCMCIA card corresponds to one device instance, and is described
 126    by one dev_link_t structure (defined in ds.h).
 127
 128    You may not want to use a linked list for this -- for example, the
 129    memory card driver uses an array of dev_link_t pointers, where minor
 130    device numbers are used to derive the corresponding array index.
 131 */
 132
 133 /*
 134    A driver needs to provide a dev_node_t structure for each device
 135    on a card.  In some cases, there is only one device per card (for
 136    example, ethernet cards, modems).  In other cases, there may be
 137    many actual or logical devices (SCSI adapters, memory cards with
 138    multiple partitions).  The dev_node_t structures need to be kept
 139    in a linked list starting at the 'dev' field of a dev_link_t
 140    structure.  We allocate them in the card's private data structure,
 141    because they generally shouldn't be allocated dynamically.
 142
 143    In this case, we also provide a flag to indicate if a device is
 144    "stopped" due to a power management event, or card ejection.  The
 145    device IO routines can use a flag like this to throttle IO to a
 146    card that is not ready to accept it.
 147 */
 148
 149 typedef struct local_info_t {
 150         dev_node_t      node;
 151         struct net_device *eth_dev;
 152 } local_info_t;
 153
 154 /*======================================================================
 155
 156   atmel_attach() creates an "instance" of the driver, allocating
 157   local data structures for one device.  The device is registered
 158   with Card Services.
 159
 160   The dev_link structure is initialized, but we don't actually
 161   configure the card at this point -- we wait until we receive a
 162   card insertion event.
 163
 164   ======================================================================*/
 165
 166 static dev_link_t *atmel_attach(void)
 167 {
 168         client_reg_t client_reg;
 169         dev_link_t *link;
 170         local_info_t *local;
 171         int ret;
 172
 173         DEBUG(0, "atmel_attach()\n");
 174
 175         /* Initialize the dev_link_t structure */
 176         link = kzalloc(sizeof(struct dev_link_t), GFP_KERNEL);
 177         if (!link) {
 178                 printk(KERN_ERR "atmel_cs: no memory for new device\n");
 179                 return NULL;
 180         }
 181
 182         /* Interrupt setup */
 183         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 184         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 185         link->irq.Handler = NULL;
 186
 187         /*
 188           General socket configuration defaults can go here.  In this
 189           client, we assume very little, and rely on the CIS for almost
 190           everything.  In most clients, many details (i.e., number, sizes,
 191           and attributes of IO windows) are fixed by the nature of the
 192           device, and can be hard-wired here.
 193         */
 194         link->conf.Attributes = 0;
 195         link->conf.Vcc = 50;
 196         link->conf.IntType = INT_MEMORY_AND_IO;
 197
 198         /* Allocate space for private device-specific data */
 199         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
 200         if (!local) {
 201                 printk(KERN_ERR "atmel_cs: no memory for new device\n");
 202                 kfree (link);
 203                 return NULL;
 204         }
 205         link->priv = local;
 206
 207         /* Register with Card Services */
 208         link->next = NULL;
 209         client_reg.dev_info = &dev_info;
 210         client_reg.Version = 0x0210;
 211         client_reg.event_callback_args.client_data = link;
 212         ret = pcmcia_register_client(&link->handle, &client_reg);
 213         if (ret != 0) {
 214                 cs_error(link->handle, RegisterClient, ret);
 215                 atmel_detach(link->handle);
 216                 return NULL;
 217         }
 218
 219         return link;
 220 } /* atmel_attach */
 221
 222 /*======================================================================
 223
 224   This deletes a driver "instance".  The device is de-registered
 225   with Card Services.  If it has been released, all local data
 226   structures are freed.  Otherwise, the structures will be freed
 227   when the device is released.
 228
 229   ======================================================================*/
 230
 231 static void atmel_detach(struct pcmcia_device *p_dev)
 232 {
 233         dev_link_t *link = dev_to_instance(p_dev);
 234
 235         DEBUG(0, "atmel_detach(0x%p)\n", link);
 236
 237         if (link->state & DEV_CONFIG)
 238                 atmel_release(link);
 239
 240         kfree(link->priv);
 241         kfree(link);
 242 }
 243
 244 /*======================================================================
 245
 246   atmel_config() is scheduled to run after a CARD_INSERTION event
 247   is received, to configure the PCMCIA socket, and to make the
 248   device available to the system.
 249
 250   ======================================================================*/
 251
 252 #define CS_CHECK(fn, ret) \
 253 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 254
 255 /* Call-back function to interrogate PCMCIA-specific information
 256    about the current existance of the card */
 257 static int card_present(void *arg)
 258 {
 259         dev_link_t *link = (dev_link_t *)arg;
 260         if (link->state & DEV_SUSPEND)
 261                 return 0;
 262         else if (link->state & DEV_PRESENT)
 263                 return 1;
 264
 265         return 0;
 266 }
 267
 268 static void atmel_config(dev_link_t *link)
 269 {
 270         client_handle_t handle;
 271         tuple_t tuple;
 272         cisparse_t parse;
 273         local_info_t *dev;
 274         int last_fn, last_ret;
 275         u_char buf[64];
 276         struct pcmcia_device_id *did;
 277
 278         handle = link->handle;
 279         dev = link->priv;
 280         did = handle_to_dev(handle).driver_data;
 281
 282         DEBUG(0, "atmel_config(0x%p)\n", link);
 283
 284         tuple.Attributes = 0;
 285         tuple.TupleData = buf;
 286         tuple.TupleDataMax = sizeof(buf);
 287         tuple.TupleOffset = 0;
 288
 289         /*
 290           This reads the card's CONFIG tuple to find its configuration
 291           registers.
 292         */
 293         tuple.DesiredTuple = CISTPL_CONFIG;
 294         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 295         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 296         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 297         link->conf.ConfigBase = parse.config.base;
 298         link->conf.Present = parse.config.rmask[0];
 299
 300         /* Configure card */
 301         link->state |= DEV_CONFIG;
 302
 303         /*
 304           In this loop, we scan the CIS for configuration table entries,
 305           each of which describes a valid card configuration, including
 306           voltage, IO window, memory window, and interrupt settings.
 307
 308           We make no assumptions about the card to be configured: we use
 309           just the information available in the CIS.  In an ideal world,
 310           this would work for any PCMCIA card, but it requires a complete
 311           and accurate CIS.  In practice, a driver usually "knows" most of
 312           these things without consulting the CIS, and most client drivers
 313           will only use the CIS to fill in implementation-defined details.
 314         */
 315         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 316         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 317         while (1) {
 318                 cistpl_cftable_entry_t dflt = { 0 };
 319                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 320                 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
 321                                 pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
 322                         goto next_entry;
 323
 324                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
 325                 if (cfg->index == 0) goto next_entry;
 326                 link->conf.ConfigIndex = cfg->index;
 327
 328                 /* Does this card need audio output? */
 329                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
 330                         link->conf.Attributes |= CONF_ENABLE_SPKR;
 331                         link->conf.Status = CCSR_AUDIO_ENA;
 332                 }
 333
 334                 /* Use power settings for Vcc and Vpp if present */
 335                 /*  Note that the CIS values need to be rescaled */
 336                 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM))
 337                         link->conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000;
 338                 else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM))
 339                         link->conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000;
 340
 341                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
 342                         link->conf.Vpp1 = link->conf.Vpp2 =
 343                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
 344                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
 345                         link->conf.Vpp1 = link->conf.Vpp2 =
 346                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
 347
 348                 /* Do we need to allocate an interrupt? */
 349                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
 350                         link->conf.Attributes |= CONF_ENABLE_IRQ;
 351
 352                 /* IO window settings */
 353                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
 354                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
 355                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
 356                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 357                         if (!(io->flags & CISTPL_IO_8BIT))
 358                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 359                         if (!(io->flags & CISTPL_IO_16BIT))
 360                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 361                         link->io.BasePort1 = io->win[0].base;
 362                         link->io.NumPorts1 = io->win[0].len;
 363                         if (io->nwin > 1) {
 364                                 link->io.Attributes2 = link->io.Attributes1;
 365                                 link->io.BasePort2 = io->win[1].base;
 366                                 link->io.NumPorts2 = io->win[1].len;
 367                         }
 368                 }
 369
 370                 /* This reserves IO space but doesn't actually enable it */
 371                 if (pcmcia_request_io(link->handle, &link->io) != 0)
 372                         goto next_entry;
 373
 374                 /* If we got this far, we're cool! */
 375                 break;
 376
 377         next_entry:
 378                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
 379         }
 380
 381         /*
 382           Allocate an interrupt line.  Note that this does not assign a
 383           handler to the interrupt, unless the 'Handler' member of the
 384           irq structure is initialized.
 385         */
 386         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 387                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 388
 389         /*
 390           This actually configures the PCMCIA socket -- setting up
 391           the I/O windows and the interrupt mapping, and putting the
 392           card and host interface into "Memory and IO" mode.
 393         */
 394         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 395
 396         if (link->irq.AssignedIRQ == 0) {
 397                 printk(KERN_ALERT
 398                        "atmel: cannot assign IRQ: check that CONFIG_ISA is set in kernel config.");
 399                 goto cs_failed;
 400         }
 401
 402         ((local_info_t*)link->priv)->eth_dev =
 403                 init_atmel_card(link->irq.AssignedIRQ,
 404                                 link->io.BasePort1,
 405                                 did ? did->driver_info : ATMEL_FW_TYPE_NONE,
 406                                 &handle_to_dev(handle),
 407                                 card_present,
 408                                 link);
 409         if (!((local_info_t*)link->priv)->eth_dev)
 410                         goto cs_failed;
 411
 412
 413         /*
 414           At this point, the dev_node_t structure(s) need to be
 415           initialized and arranged in a linked list at link->dev.
 416         */
 417         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
 418         dev->node.major = dev->node.minor = 0;
 419         link->dev = &dev->node;
 420
 421         link->state &= ~DEV_CONFIG_PENDING;
 422         return;
 423
 424  cs_failed:
 425         cs_error(link->handle, last_fn, last_ret);
 426         atmel_release(link);
 427 }
 428
 429 /*======================================================================
 430
 431   After a card is removed, atmel_release() will unregister the
 432   device, and release the PCMCIA configuration.  If the device is
 433   still open, this will be postponed until it is closed.
 434
 435   ======================================================================*/
 436
 437 static void atmel_release(dev_link_t *link)
 438 {
 439         struct net_device *dev = ((local_info_t*)link->priv)->eth_dev;
 440
 441         DEBUG(0, "atmel_release(0x%p)\n", link);
 442
 443         /* Unlink the device chain */
 444         link->dev = NULL;
 445
 446         if (dev)
 447                 stop_atmel_card(dev);
 448         ((local_info_t*)link->priv)->eth_dev = NULL;
 449
 450         /* Don't bother checking to see if these succeed or not */
 451         pcmcia_release_configuration(link->handle);
 452         if (link->io.NumPorts1)
 453                 pcmcia_release_io(link->handle, &link->io);
 454         if (link->irq.AssignedIRQ)
 455                 pcmcia_release_irq(link->handle, &link->irq);
 456         link->state &= ~DEV_CONFIG;
 457 }
 458
 459 static int atmel_suspend(struct pcmcia_device *dev)
 460 {
 461         dev_link_t *link = dev_to_instance(dev);
 462         local_info_t *local = link->priv;
 463
 464         link->state |= DEV_SUSPEND;
 465         if (link->state & DEV_CONFIG) {
 466                 netif_device_detach(local->eth_dev);
 467                 pcmcia_release_configuration(link->handle);
 468         }
 469
 470         return 0;
 471 }
 472
 473 static int atmel_resume(struct pcmcia_device *dev)
 474 {
 475         dev_link_t *link = dev_to_instance(dev);
 476         local_info_t *local = link->priv;
 477
 478         link->state &= ~DEV_SUSPEND;
 479         if (link->state & DEV_CONFIG) {
 480                 pcmcia_request_configuration(link->handle, &link->conf);
 481                 atmel_open(local->eth_dev);
 482                 netif_device_attach(local->eth_dev);
 483         }
 484
 485         return 0;
 486 }
 487
 488 /*======================================================================
 489
 490   The card status event handler.  Mostly, this schedules other
 491   stuff to run after an event is received.
 492
 493   When a CARD_REMOVAL event is received, we immediately set a
 494   private flag to block future accesses to this device.  All the
 495   functions that actually access the device should check this flag
 496   to make sure the card is still present.
 497
 498   ======================================================================*/
 499
 500 static int atmel_event(event_t event, int priority,
 501                       event_callback_args_t *args)
 502 {
 503         dev_link_t *link = args->client_data;
 504
 505         DEBUG(1, "atmel_event(0x%06x)\n", event);
 506
 507         switch (event) {
 508         case CS_EVENT_CARD_INSERTION:
 509                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 510                 atmel_config(link);
 511                 break;
 512         }
 513         return 0;
 514 } /* atmel_event */
 515
 516 /*====================================================================*/
 517 /* We use the driver_info field to store the correct firmware type for a card. */
 518
 519 #define PCMCIA_DEVICE_MANF_CARD_INFO(manf, card, info) { \
 520         .match_flags = PCMCIA_DEV_ID_MATCH_MANF_ID| \
 521                         PCMCIA_DEV_ID_MATCH_CARD_ID, \
 522         .manf_id = (manf), \
 523         .card_id = (card), \
 524         .driver_info = (kernel_ulong_t)(info), }
 525
 526 #define PCMCIA_DEVICE_PROD_ID12_INFO(v1, v2, vh1, vh2, info) { \
 527         .match_flags = PCMCIA_DEV_ID_MATCH_PROD_ID1| \
 528                         PCMCIA_DEV_ID_MATCH_PROD_ID2, \
 529         .prod_id = { (v1), (v2), NULL, NULL }, \
 530         .prod_id_hash = { (vh1), (vh2), 0, 0 }, \
 531         .driver_info = (kernel_ulong_t)(info), }
 532
 533 static struct pcmcia_device_id atmel_ids[] = {
 534         PCMCIA_DEVICE_MANF_CARD_INFO(0x0101, 0x0620, ATMEL_FW_TYPE_502_3COM),
 535         PCMCIA_DEVICE_MANF_CARD_INFO(0x0101, 0x0696, ATMEL_FW_TYPE_502_3COM),
 536         PCMCIA_DEVICE_MANF_CARD_INFO(0x01bf, 0x3302, ATMEL_FW_TYPE_502E),
 537         PCMCIA_DEVICE_MANF_CARD_INFO(0xd601, 0x0007, ATMEL_FW_TYPE_502),
 538         PCMCIA_DEVICE_PROD_ID12_INFO("11WAVE", "11WP611AL-E", 0x9eb2da1f, 0xc9a0d3f9, ATMEL_FW_TYPE_502E),
 539         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR", 0xabda4164, 0x41b37e1f, ATMEL_FW_TYPE_502),
 540         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR_D", 0xabda4164, 0x3675d704, ATMEL_FW_TYPE_502D),
 541         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C502AR_E", 0xabda4164, 0x4172e792, ATMEL_FW_TYPE_502E),
 542         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504_R", 0xabda4164, 0x917f3d72, ATMEL_FW_TYPE_504_2958),
 543         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504", 0xabda4164, 0x5040670a, ATMEL_FW_TYPE_504),
 544         PCMCIA_DEVICE_PROD_ID12_INFO("ATMEL", "AT76C504A", 0xabda4164, 0xe15ed87f, ATMEL_FW_TYPE_504A_2958),
 545         PCMCIA_DEVICE_PROD_ID12_INFO("BT", "Voyager 1020 Laptop Adapter", 0xae49b86a, 0x1e957cd5, ATMEL_FW_TYPE_502),
 546         PCMCIA_DEVICE_PROD_ID12_INFO("CNet", "CNWLC 11Mbps Wireless PC Card V-5", 0xbc477dde, 0x502fae6b, ATMEL_FW_TYPE_502E),
 547         PCMCIA_DEVICE_PROD_ID12_INFO("IEEE 802.11b", "Wireless LAN PC Card", 0x5b878724, 0x122f1df6, ATMEL_FW_TYPE_502),
 548         PCMCIA_DEVICE_PROD_ID12_INFO("IEEE 802.11b", "Wireless LAN Card S", 0x5b878724, 0x5fba533a, ATMEL_FW_TYPE_504_2958),
 549         PCMCIA_DEVICE_PROD_ID12_INFO("OEM", "11Mbps Wireless LAN PC Card V-3", 0xfea54c90, 0x1c5b0f68, ATMEL_FW_TYPE_502),
 550         PCMCIA_DEVICE_PROD_ID12_INFO("SMC", "2632W", 0xc4f8b18b, 0x30f38774, ATMEL_FW_TYPE_502D),
 551         PCMCIA_DEVICE_PROD_ID12_INFO("SMC", "2632W-V2", 0xc4f8b18b, 0x172d1377, ATMEL_FW_TYPE_502),
 552         PCMCIA_DEVICE_PROD_ID12_INFO("Wireless", "PC_CARD", 0xa407ecdd, 0x119f6314, ATMEL_FW_TYPE_502D),
 553         PCMCIA_DEVICE_PROD_ID12_INFO("WLAN", "802.11b PC CARD", 0x575c516c, 0xb1f6dbc4, ATMEL_FW_TYPE_502D),
 554         PCMCIA_DEVICE_PROD_ID12_INFO("LG", "LW2100N", 0xb474d43a, 0x6b1fec94, ATMEL_FW_TYPE_502E),
 555         PCMCIA_DEVICE_NULL
 556 };
 557
 558 MODULE_DEVICE_TABLE(pcmcia, atmel_ids);
 559
 560 static struct pcmcia_driver atmel_driver = {
 561         .owner          = THIS_MODULE,
 562         .drv            = {
 563                 .name   = "atmel_cs",
 564         },
 565         .attach         = atmel_attach,
 566         .event          = atmel_event,
 567         .remove         = atmel_detach,
 568         .id_table       = atmel_ids,
 569         .suspend        = atmel_suspend,
 570         .resume         = atmel_resume,
 571 };
 572
 573 static int atmel_cs_init(void)
 574 {
 575         return pcmcia_register_driver(&atmel_driver);
 576 }
 577
 578 static void atmel_cs_cleanup(void)
 579 {
 580         pcmcia_unregister_driver(&atmel_driver);
 581 }
 582
 583 /*
 584     This program is free software; you can redistribute it and/or
 585     modify it under the terms of the GNU General Public License
 586     as published by the Free Software Foundation; either version 2
 587     of the License, or (at your option) any later version.
 588
 589     This program is distributed in the hope that it will be useful,
 590     but WITHOUT ANY WARRANTY; without even the implied warranty of
 591     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 592     GNU General Public License for more details.
 593
 594     In addition:
 595
 596     Redistribution and use in source and binary forms, with or without
 597     modification, are permitted provided that the following conditions
 598     are met:
 599
 600     1. Redistributions of source code must retain the above copyright
 601        notice, this list of conditions and the following disclaimer.
 602     2. Redistributions in binary form must reproduce the above copyright
 603        notice, this list of conditions and the following disclaimer in the
 604        documentation and/or other materials provided with the distribution.
 605     3. The name of the author may not be used to endorse or promote
 606        products derived from this software without specific prior written
 607        permission.
 608
 609     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 610     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 611     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 612     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 613     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 614     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 615     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 616     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 617     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 618     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 619     POSSIBILITY OF SUCH DAMAGE.
 620 */
 621
 622 module_init(atmel_cs_init);
 623 module_exit(atmel_cs_cleanup);