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/version.h>
  47 #include <pcmcia/cs_types.h>
  48 #include <pcmcia/cs.h>
  49 #include <pcmcia/cistpl.h>
  50 #include <pcmcia/cisreg.h>
  51 #include <pcmcia/ds.h>
  52 #include <pcmcia/ciscode.h>
  53
  54 #include <asm/io.h>
  55 #include <asm/system.h>
  56 #include <linux/wireless.h>
  57
  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 #ifdef PCMCIA_DEBUG
  67 static int pc_debug = PCMCIA_DEBUG;
  68 MODULE_PARM(pc_debug, "i");
  69 static char *version = "$Revision: 1.2 $";
  70 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args);
  71 #else
  72 #define DEBUG(n, args...)
  73 #endif
  74
  75 /*====================================================================*/
  76
  77 /* Parameters that can be set with 'insmod' */
  78
  79 /* The old way: bit map of interrupts to choose from */
  80 /* This means pick from 15, 14, 12, 11, 10, 9, 7, 5, 4, and 3 */
  81 static u_int irq_mask = 0xdeb8;
  82 /* Newer, simpler way of listing specific interrupts */
  83 static int irq_list[4] = { -1 };
  84
  85 MODULE_AUTHOR("Simon Kelley");
  86 MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
  87 MODULE_LICENSE("GPL");
  88 MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
  89 MODULE_PARM(irq_mask, "i");
  90 MODULE_PARM(irq_list, "1-4i");
  91
  92 /*====================================================================*/
  93
  94 /*
  95    The event() function is this driver's Card Services event handler.
  96    It will be called by Card Services when an appropriate card status
  97    event is received.  The config() and release() entry points are
  98    used to configure or release a socket, in response to card
  99    insertion and ejection events.  They are invoked from the atmel_cs
 100    event handler.
 101 */
 102
 103 struct net_device *init_atmel_card(int, int, char *, struct device *,
 104                                     int (*present_func)(void *), void * );
 105 void stop_atmel_card( struct net_device *, int );
 106 int atmel_open( struct net_device * );
 107
 108 static void atmel_config(dev_link_t *link);
 109 static void atmel_release(dev_link_t *link);
 110 static int atmel_event(event_t event, int priority,
 111                        event_callback_args_t *args);
 112
 113 /*
 114    The attach() and detach() entry points are used to create and destroy
 115    "instances" of the driver, where each instance represents everything
 116    needed to manage one actual PCMCIA card.
 117 */
 118
 119 static dev_link_t *atmel_attach(void);
 120 static void atmel_detach(dev_link_t *);
 121
 122 /*
 123    You'll also need to prototype all the functions that will actually
 124    be used to talk to your device.  See 'pcmem_cs' for a good example
 125    of a fully self-sufficient driver; the other drivers rely more or
 126    less on other parts of the kernel.
 127 */
 128
 129 /*
 130    The dev_info variable is the "key" that is used to match up this
 131    device driver with appropriate cards, through the card configuration
 132    database.
 133 */
 134
 135 static dev_info_t dev_info = "atmel_cs";
 136
 137 /*
 138    A linked list of "instances" of the  atmelnet device.  Each actual
 139    PCMCIA card corresponds to one device instance, and is described
 140    by one dev_link_t structure (defined in ds.h).
 141
 142    You may not want to use a linked list for this -- for example, the
 143    memory card driver uses an array of dev_link_t pointers, where minor
 144    device numbers are used to derive the corresponding array index.
 145 */
 146
 147 static dev_link_t *dev_list = NULL;
 148
 149 /*
 150    A dev_link_t structure has fields for most things that are needed
 151    to keep track of a socket, but there will usually be some device
 152    specific information that also needs to be kept track of.  The
 153    'priv' pointer in a dev_link_t structure can be used to point to
 154    a device-specific private data structure, like this.
 155
 156    A driver needs to provide a dev_node_t structure for each device
 157    on a card.  In some cases, there is only one device per card (for
 158    example, ethernet cards, modems).  In other cases, there may be
 159    many actual or logical devices (SCSI adapters, memory cards with
 160    multiple partitions).  The dev_node_t structures need to be kept
 161    in a linked list starting at the 'dev' field of a dev_link_t
 162    structure.  We allocate them in the card's private data structure,
 163    because they generally shouldn't be allocated dynamically.
 164
 165    In this case, we also provide a flag to indicate if a device is
 166    "stopped" due to a power management event, or card ejection.  The
 167    device IO routines can use a flag like this to throttle IO to a
 168    card that is not ready to accept it.
 169 */
 170
 171 typedef struct local_info_t {
 172         dev_node_t      node;
 173         struct net_device *eth_dev;
 174 } local_info_t;
 175
 176 /*======================================================================
 177
 178   atmel_attach() creates an "instance" of the driver, allocating
 179   local data structures for one device.  The device is registered
 180   with Card Services.
 181
 182   The dev_link structure is initialized, but we don't actually
 183   configure the card at this point -- we wait until we receive a
 184   card insertion event.
 185
 186   ======================================================================*/
 187
 188 static dev_link_t *atmel_attach(void)
 189 {
 190         client_reg_t client_reg;
 191         dev_link_t *link;
 192         local_info_t *local;
 193         int ret, i;
 194
 195         DEBUG(0, "atmel_attach()\n");
 196
 197         /* Initialize the dev_link_t structure */
 198         link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL);
 199         if (!link) {
 200                 printk(KERN_ERR "atmel_cs: no memory for new device\n");
 201                 return NULL;
 202         }
 203         memset(link, 0, sizeof(struct dev_link_t));
 204
 205         /* Interrupt setup */
 206         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 207         link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
 208         if (irq_list[0] == -1)
 209                 link->irq.IRQInfo2 = irq_mask;
 210         else
 211                 for (i = 0; i < 4; i++)
 212                         link->irq.IRQInfo2 |= 1 << irq_list[i];
 213         link->irq.Handler = NULL;
 214
 215         /*
 216           General socket configuration defaults can go here.  In this
 217           client, we assume very little, and rely on the CIS for almost
 218           everything.  In most clients, many details (i.e., number, sizes,
 219           and attributes of IO windows) are fixed by the nature of the
 220           device, and can be hard-wired here.
 221         */
 222         link->conf.Attributes = 0;
 223         link->conf.Vcc = 50;
 224         link->conf.IntType = INT_MEMORY_AND_IO;
 225
 226         /* Allocate space for private device-specific data */
 227         local = kmalloc(sizeof(local_info_t), GFP_KERNEL);
 228         if (!local) {
 229                 printk(KERN_ERR "atmel_cs: no memory for new device\n");
 230                 kfree (link);
 231                 return NULL;
 232         }
 233         memset(local, 0, sizeof(local_info_t));
 234         link->priv = local;
 235
 236         /* Register with Card Services */
 237         link->next = dev_list;
 238         dev_list = link;
 239         client_reg.dev_info = &dev_info;
 240         client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
 241         client_reg.EventMask =
 242                 CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
 243                 CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
 244                 CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
 245         client_reg.event_handler = &atmel_event;
 246         client_reg.Version = 0x0210;
 247         client_reg.event_callback_args.client_data = link;
 248         ret = pcmcia_register_client(&link->handle, &client_reg);
 249         if (ret != 0) {
 250                 cs_error(link->handle, RegisterClient, ret);
 251                 atmel_detach(link);
 252                 return NULL;
 253         }
 254
 255         return link;
 256 } /* atmel_attach */
 257
 258 /*======================================================================
 259
 260   This deletes a driver "instance".  The device is de-registered
 261   with Card Services.  If it has been released, all local data
 262   structures are freed.  Otherwise, the structures will be freed
 263   when the device is released.
 264
 265   ======================================================================*/
 266
 267 static void atmel_detach(dev_link_t *link)
 268 {
 269         dev_link_t **linkp;
 270
 271         DEBUG(0, "atmel_detach(0x%p)\n", link);
 272
 273         /* Locate device structure */
 274         for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 275                 if (*linkp == link) break;
 276         if (*linkp == NULL)
 277                 return;
 278
 279         if (link->state & DEV_CONFIG)
 280                 atmel_release(link);
 281
 282         /* Break the link with Card Services */
 283         if (link->handle)
 284                 pcmcia_deregister_client(link->handle);
 285
 286         /* Unlink device structure, free pieces */
 287         *linkp = link->next;
 288         if (link->priv)
 289                 kfree(link->priv);
 290         kfree(link);
 291 }
 292
 293 /*======================================================================
 294
 295   atmel_config() is scheduled to run after a CARD_INSERTION event
 296   is received, to configure the PCMCIA socket, and to make the
 297   device available to the system.
 298
 299   ======================================================================*/
 300
 301 #define CS_CHECK(fn, ret) \
 302 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 303
 304 /* Call-back function to interrogate PCMCIA-specific information
 305    about the current existance of the card */
 306 static int card_present(void *arg)
 307 {
 308         dev_link_t *link = (dev_link_t *)arg;
 309         if (link->state & DEV_SUSPEND)
 310                 return 0;
 311         else if (link->state & DEV_PRESENT)
 312                 return 1;
 313
 314         return 0;
 315 }
 316
 317 /* list of cards we know about and their firmware requirements.
 318    Go either by Manfid or version strings.
 319    Cards not in this list will need a firmware parameter to the module
 320    in all probability. Note that the SMC 2632 V2 and V3 have the same
 321    manfids, so we ignore those and use the version1 strings. */
 322
 323 static struct {
 324         int manf, card;
 325         char *ver1;
 326         char *firmware;
 327         char *name;
 328 } card_table[] = {
 329         { 0, 0, "WLAN/802.11b PC CARD", "atmel_at76c502d%s.bin", "Actiontec 802CAT1" },
 330         { 0, 0, "ATMEL/AT76C502AR", "atmel_at76c502%s.bin", "NoName-RFMD" },
 331         { 0, 0, "ATMEL/AT76C502AR_D", "atmel_at76c502d%s.bin", "NoName-revD" },
 332         { 0, 0, "ATMEL/AT76C502AR_E", "atmel_at76c502e%s.bin", "NoName-revE" },
 333         { 0, 0, "ATMEL/AT76C504", "atmel_at76c504%s.bin", "NoName-504" },
 334         { 0, 0, "ATMEL/AT76C504A", "atmel_at76c504a_2958%s.bin", "NoName-504a-2958" },
 335         { 0, 0, "ATMEL/AT76C504_R", "atmel_at76c504_2958%s.bin", "NoName-504-2958" },
 336         { MANFID_3COM, 0x0620, NULL, "atmel_at76c502_3com%s.bin", "3com 3CRWE62092B" },
 337         { MANFID_3COM, 0x0696, NULL, "atmel_at76c502_3com%s.bin", "3com 3CRSHPW196" },
 338         { 0, 0, "SMC/2632W-V2", "atmel_at76c502%s.bin", "SMC 2632W-V2" },
 339         { 0, 0, "SMC/2632W", "atmel_at76c502d%s.bin", "SMC 2632W-V3" },
 340         { 0xd601, 0x0007, NULL, "atmel_at76c502%s.bin", "Sitecom WLAN-011" },
 341         { 0x01bf, 0x3302, NULL, "atmel_at76c502e%s.bin", "Belkin F5D6020-V2" },
 342         { 0, 0, "BT/Voyager 1020 Laptop Adapter", "atmel_at76c502%s.bin", "BT Voyager 1020" },
 343         { 0, 0, "IEEE 802.11b/Wireless LAN PC Card", "atmel_at76c502%s.bin", "Siemens Gigaset PC Card II" },
 344         { 0, 0, "CNet/CNWLC 11Mbps Wireless PC Card V-5", "atmel_at76c502e%s.bin", "CNet CNWLC-811ARL" },
 345         { 0, 0, "Wireless/PC_CARD", "atmel_at76c502d%s.bin", "Planet WL-3552" },
 346         { 0, 0, "OEM/11Mbps Wireless LAN PC Card V-3", "atmel_at76c502%s.bin", "OEM 11Mbps WLAN PCMCIA Card" },
 347         { 0, 0, "11WAVE/11WP611AL-E", "atmel_at76c502e%s.bin", "11WAVE WaveBuddy" }
 348 };
 349
 350 /* This is strictly temporary, until PCMCIA devices get integrated into the device model. */
 351 static struct device *atmel_device(void)
 352 {
 353         static struct device dev = {
 354                 .bus_id    = "pcmcia",
 355         };
 356         kobject_set_name(&dev.kobj, "atmel_cs");
 357         kobject_init(&dev.kobj);
 358
 359         return &dev;
 360 }
 361
 362 static void atmel_config(dev_link_t *link)
 363 {
 364         client_handle_t handle;
 365         tuple_t tuple;
 366         cisparse_t parse;
 367         local_info_t *dev;
 368         int last_fn, last_ret;
 369         u_char buf[64];
 370         int card_index = -1, done = 0;
 371
 372         handle = link->handle;
 373         dev = link->priv;
 374
 375         DEBUG(0, "atmel_config(0x%p)\n", link);
 376
 377         tuple.Attributes = 0;
 378         tuple.TupleData = buf;
 379         tuple.TupleDataMax = sizeof(buf);
 380         tuple.TupleOffset = 0;
 381
 382         tuple.DesiredTuple = CISTPL_MANFID;
 383         if (pcmcia_get_first_tuple(handle, &tuple) == 0) {
 384                 int i;
 385                 cistpl_manfid_t *manfid;
 386                 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 387                 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 388                 manfid = &(parse.manfid);
 389                 for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) {
 390                         if (!card_table[i].ver1 &&
 391                             manfid->manf == card_table[i].manf &&
 392                             manfid->card == card_table[i].card) {
 393                                 card_index = i;
 394                                 done = 1;
 395                         }
 396                 }
 397         }
 398
 399         tuple.DesiredTuple = CISTPL_VERS_1;
 400         if (!done && (pcmcia_get_first_tuple(handle, &tuple) == 0)) {
 401                 int i, j, k;
 402                 cistpl_vers_1_t *ver1;
 403                 CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 404                 CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 405                 ver1 = &(parse.version_1);
 406
 407                 for (i = 0; i < sizeof(card_table)/sizeof(card_table[0]); i++) {
 408                         for (j = 0; j < ver1->ns; j++) {
 409                                 char *p = card_table[i].ver1;
 410                                 char *q = &ver1->str[ver1->ofs[j]];
 411                                 if (!p)
 412                                         goto mismatch;
 413                                 for (k = 0; k < j; k++) {
 414                                         while ((*p != '\0') && (*p != '/')) p++;
 415                                         if (*p == '\0') {
 416                                                 if (*q != '\0')
 417                                                         goto mismatch;
 418                                         } else {
 419                                                 p++;
 420                                         }
 421                                 }
 422                                 while((*q != '\0') && (*p != '\0') &&
 423                                       (*p != '/') && (*p == *q)) p++, q++;
 424                                 if (((*p != '\0') && *p != '/') || *q != '\0')
 425                                         goto mismatch;
 426                         }
 427                         card_index = i;
 428                         break;  /* done */
 429
 430                 mismatch:
 431                         j = 0; /* dummy stmt to shut up compiler */
 432                 }
 433         }
 434
 435         /*
 436           This reads the card's CONFIG tuple to find its configuration
 437           registers.
 438         */
 439         tuple.DesiredTuple = CISTPL_CONFIG;
 440         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 441         CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 442         CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 443         link->conf.ConfigBase = parse.config.base;
 444         link->conf.Present = parse.config.rmask[0];
 445
 446         /* Configure card */
 447         link->state |= DEV_CONFIG;
 448
 449         /*
 450           In this loop, we scan the CIS for configuration table entries,
 451           each of which describes a valid card configuration, including
 452           voltage, IO window, memory window, and interrupt settings.
 453
 454           We make no assumptions about the card to be configured: we use
 455           just the information available in the CIS.  In an ideal world,
 456           this would work for any PCMCIA card, but it requires a complete
 457           and accurate CIS.  In practice, a driver usually "knows" most of
 458           these things without consulting the CIS, and most client drivers
 459           will only use the CIS to fill in implementation-defined details.
 460         */
 461         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 462         CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 463         while (1) {
 464                 cistpl_cftable_entry_t dflt = { 0 };
 465                 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
 466                 if (pcmcia_get_tuple_data(handle, &tuple) != 0 ||
 467                                 pcmcia_parse_tuple(handle, &tuple, &parse) != 0)
 468                         goto next_entry;
 469
 470                 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg;
 471                 if (cfg->index == 0) goto next_entry;
 472                 link->conf.ConfigIndex = cfg->index;
 473
 474                 /* Does this card need audio output? */
 475                 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
 476                         link->conf.Attributes |= CONF_ENABLE_SPKR;
 477                         link->conf.Status = CCSR_AUDIO_ENA;
 478                 }
 479
 480                 /* Use power settings for Vcc and Vpp if present */
 481                 /*  Note that the CIS values need to be rescaled */
 482                 if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM))
 483                         link->conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000;
 484                 else if (dflt.vcc.present & (1<<CISTPL_POWER_VNOM))
 485                         link->conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000;
 486
 487                 if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
 488                         link->conf.Vpp1 = link->conf.Vpp2 =
 489                                 cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
 490                 else if (dflt.vpp1.present & (1<<CISTPL_POWER_VNOM))
 491                         link->conf.Vpp1 = link->conf.Vpp2 =
 492                                 dflt.vpp1.param[CISTPL_POWER_VNOM]/10000;
 493
 494                 /* Do we need to allocate an interrupt? */
 495                 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
 496                         link->conf.Attributes |= CONF_ENABLE_IRQ;
 497
 498                 /* IO window settings */
 499                 link->io.NumPorts1 = link->io.NumPorts2 = 0;
 500                 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
 501                         cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
 502                         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 503                         if (!(io->flags & CISTPL_IO_8BIT))
 504                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 505                         if (!(io->flags & CISTPL_IO_16BIT))
 506                                 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 507                         link->io.BasePort1 = io->win[0].base;
 508                         link->io.NumPorts1 = io->win[0].len;
 509                         if (io->nwin > 1) {
 510                                 link->io.Attributes2 = link->io.Attributes1;
 511                                 link->io.BasePort2 = io->win[1].base;
 512                                 link->io.NumPorts2 = io->win[1].len;
 513                         }
 514                 }
 515
 516                 /* This reserves IO space but doesn't actually enable it */
 517                 if (pcmcia_request_io(link->handle, &link->io) != 0)
 518                         goto next_entry;
 519
 520                 /* If we got this far, we're cool! */
 521                 break;
 522
 523         next_entry:
 524                 CS_CHECK(GetNextTuple, pcmcia_get_next_tuple(handle, &tuple));
 525         }
 526
 527         /*
 528           Allocate an interrupt line.  Note that this does not assign a
 529           handler to the interrupt, unless the 'Handler' member of the
 530           irq structure is initialized.
 531         */
 532         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 533                 CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 534
 535         /*
 536           This actually configures the PCMCIA socket -- setting up
 537           the I/O windows and the interrupt mapping, and putting the
 538           card and host interface into "Memory and IO" mode.
 539         */
 540         CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 541
 542         if (link->irq.AssignedIRQ == 0) {
 543                 printk(KERN_ALERT
 544                        "atmel: cannot assign IRQ: check that CONFIG_ISA is set in kernel config.");
 545                 goto cs_failed;
 546         }
 547
 548         ((local_info_t*)link->priv)->eth_dev =
 549                 init_atmel_card(link->irq.AssignedIRQ,
 550                                 link->io.BasePort1,
 551                                 card_index == -1 ? NULL :  card_table[card_index].firmware,
 552                                 atmel_device(),
 553                                 card_present,
 554                                 link);
 555         if (!((local_info_t*)link->priv)->eth_dev)
 556                 goto cs_failed;
 557
 558         /*
 559           At this point, the dev_node_t structure(s) need to be
 560           initialized and arranged in a linked list at link->dev.
 561         */
 562         strcpy(dev->node.dev_name, ((local_info_t*)link->priv)->eth_dev->name );
 563         dev->node.major = dev->node.minor = 0;
 564         link->dev = &dev->node;
 565
 566         /* Finally, report what we've done */
 567         printk(KERN_INFO "%s: %s%sindex 0x%02x: Vcc %d.%d",
 568                dev->node.dev_name,
 569                card_index == -1 ? "" :  card_table[card_index].name,
 570                card_index == -1 ? "" : " ",
 571                link->conf.ConfigIndex,
 572                link->conf.Vcc/10, link->conf.Vcc%10);
 573         if (link->conf.Vpp1)
 574                 printk(", Vpp %d.%d", link->conf.Vpp1/10, link->conf.Vpp1%10);
 575         if (link->conf.Attributes & CONF_ENABLE_IRQ)
 576                 printk(", irq %d", link->irq.AssignedIRQ);
 577         if (link->io.NumPorts1)
 578                 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
 579                        link->io.BasePort1+link->io.NumPorts1-1);
 580         if (link->io.NumPorts2)
 581                 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
 582                        link->io.BasePort2+link->io.NumPorts2-1);
 583         printk("\n");
 584
 585         link->state &= ~DEV_CONFIG_PENDING;
 586         return;
 587
 588  cs_failed:
 589         cs_error(link->handle, last_fn, last_ret);
 590         atmel_release(link);
 591 }
 592
 593 /*======================================================================
 594
 595   After a card is removed, atmel_release() will unregister the
 596   device, and release the PCMCIA configuration.  If the device is
 597   still open, this will be postponed until it is closed.
 598
 599   ======================================================================*/
 600
 601 static void atmel_release(dev_link_t *link)
 602 {
 603         struct net_device *dev = ((local_info_t*)link->priv)->eth_dev;
 604
 605         DEBUG(0, "atmel_release(0x%p)\n", link);
 606
 607         /* Unlink the device chain */
 608         link->dev = NULL;
 609
 610         if (dev)
 611                 stop_atmel_card(dev, 0);
 612         ((local_info_t*)link->priv)->eth_dev = NULL;
 613
 614         /* Don't bother checking to see if these succeed or not */
 615         pcmcia_release_configuration(link->handle);
 616         if (link->io.NumPorts1)
 617                 pcmcia_release_io(link->handle, &link->io);
 618         if (link->irq.AssignedIRQ)
 619                 pcmcia_release_irq(link->handle, &link->irq);
 620         link->state &= ~DEV_CONFIG;
 621 }
 622
 623 /*======================================================================
 624
 625   The card status event handler.  Mostly, this schedules other
 626   stuff to run after an event is received.
 627
 628   When a CARD_REMOVAL event is received, we immediately set a
 629   private flag to block future accesses to this device.  All the
 630   functions that actually access the device should check this flag
 631   to make sure the card is still present.
 632
 633   ======================================================================*/
 634
 635 static int atmel_event(event_t event, int priority,
 636                       event_callback_args_t *args)
 637 {
 638         dev_link_t *link = args->client_data;
 639         local_info_t *local = link->priv;
 640
 641         DEBUG(1, "atmel_event(0x%06x)\n", event);
 642
 643         switch (event) {
 644         case CS_EVENT_CARD_REMOVAL:
 645                 link->state &= ~DEV_PRESENT;
 646                 if (link->state & DEV_CONFIG) {
 647                         netif_device_detach(local->eth_dev);
 648                         atmel_release(link);
 649                 }
 650                 break;
 651         case CS_EVENT_CARD_INSERTION:
 652                 link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 653                 atmel_config(link);
 654                 break;
 655         case CS_EVENT_PM_SUSPEND:
 656                 link->state |= DEV_SUSPEND;
 657                 /* Fall through... */
 658         case CS_EVENT_RESET_PHYSICAL:
 659                 if (link->state & DEV_CONFIG) {
 660                         netif_device_detach(local->eth_dev);
 661                         pcmcia_release_configuration(link->handle);
 662                 }
 663                 break;
 664         case CS_EVENT_PM_RESUME:
 665                 link->state &= ~DEV_SUSPEND;
 666                 /* Fall through... */
 667         case CS_EVENT_CARD_RESET:
 668                 if (link->state & DEV_CONFIG) {
 669                         pcmcia_request_configuration(link->handle, &link->conf);
 670                         atmel_open(local->eth_dev);
 671                         netif_device_attach(local->eth_dev);
 672                 }
 673                 break;
 674         }
 675         return 0;
 676 } /* atmel_event */
 677
 678 /*====================================================================*/
 679 static struct pcmcia_driver atmel_driver = {
 680         .owner          = THIS_MODULE,
 681         .drv            = {
 682                 .name   = "atmel_cs",
 683         },
 684         .attach         = atmel_attach,
 685         .detach         = atmel_detach,
 686 };
 687
 688 static int atmel_cs_init(void)
 689 {
 690         return pcmcia_register_driver(&atmel_driver);
 691 }
 692
 693 static void atmel_cs_cleanup(void)
 694 {
 695         pcmcia_unregister_driver(&atmel_driver);
 696
 697         /* XXX: this really needs to move into generic code.. */
 698         while (dev_list != NULL) {
 699                 if (dev_list->state & DEV_CONFIG)
 700                         atmel_release(dev_list);
 701                 atmel_detach(dev_list);
 702         }
 703 }
 704
 705 /*
 706     This program is free software; you can redistribute it and/or
 707     modify it under the terms of the GNU General Public License
 708     as published by the Free Software Foundation; either version 2
 709     of the License, or (at your option) any later version.
 710
 711     This program is distributed in the hope that it will be useful,
 712     but WITHOUT ANY WARRANTY; without even the implied warranty of
 713     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 714     GNU General Public License for more details.
 715
 716     In addition:
 717
 718     Redistribution and use in source and binary forms, with or without
 719     modification, are permitted provided that the following conditions
 720     are met:
 721
 722     1. Redistributions of source code must retain the above copyright
 723        notice, this list of conditions and the following disclaimer.
 724     2. Redistributions in binary form must reproduce the above copyright
 725        notice, this list of conditions and the following disclaimer in the
 726        documentation and/or other materials provided with the distribution.
 727     3. The name of the author may not be used to endorse or promote
 728        products derived from this software without specific prior written
 729        permission.
 730
 731     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 732     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 733     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 734     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 735     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 736     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 737     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 738     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 739     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 740     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 741     POSSIBILITY OF SUCH DAMAGE.
 742 */
 743
 744 module_init(atmel_cs_init);
 745 module_exit(atmel_cs_cleanup);