drivers/pcmcia/cs.c

   1 /*======================================================================
   2
   3     Kernel Card Services -- core services
   4
   5     cs.c 1.271 2000/10/02 20:27:49
   6
   7     The contents of this file are subject to the Mozilla Public
   8     License Version 1.1 (the "License"); you may not use this file
   9     except in compliance with the License. You may obtain a copy of
  10     the License at http://www.mozilla.org/MPL/
  11
  12     Software distributed under the License is distributed on an "AS
  13     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14     implied. See the License for the specific language governing
  15     rights and limitations under the License.
  16
  17     The initial developer of the original code 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     Alternatively, the contents of this file may be used under the
  22     terms of the GNU General Public License version 2 (the "GPL"), in which
  23     case the provisions of the GPL are applicable instead of the
  24     above.  If you wish to allow the use of your version of this file
  25     only under the terms of the GPL and not to allow others to use
  26     your version of this file under the MPL, indicate your decision
  27     by deleting the provisions above and replace them with the notice
  28     and other provisions required by the GPL.  If you do not delete
  29     the provisions above, a recipient may use your version of this
  30     file under either the MPL or the GPL.
  31
  32 ======================================================================*/
  33
  34 #include <linux/module.h>
  35 #include <linux/moduleparam.h>
  36 #include <linux/init.h>
  37 #include <linux/kernel.h>
  38 #include <linux/config.h>
  39 #include <linux/string.h>
  40 #include <linux/major.h>
  41 #include <linux/errno.h>
  42 #include <linux/slab.h>
  43 #include <linux/mm.h>
  44 #include <linux/interrupt.h>
  45 #include <linux/timer.h>
  46 #include <linux/ioport.h>
  47 #include <linux/delay.h>
  48 #include <linux/pm.h>
  49 #include <linux/pci.h>
  50 #include <linux/device.h>
  51 #include <linux/suspend.h>
  52 #include <asm/system.h>
  53 #include <asm/irq.h>
  54
  55 #define IN_CARD_SERVICES
  56 #include <pcmcia/version.h>
  57 #include <pcmcia/cs_types.h>
  58 #include <pcmcia/ss.h>
  59 #include <pcmcia/cs.h>
  60 #include <pcmcia/bulkmem.h>
  61 #include <pcmcia/cistpl.h>
  62 #include <pcmcia/cisreg.h>
  63 #include "cs_internal.h"
  64
  65 #ifdef CONFIG_PCI
  66 #define PCI_OPT " [pci]"
  67 #else
  68 #define PCI_OPT ""
  69 #endif
  70 #ifdef CONFIG_CARDBUS
  71 #define CB_OPT " [cardbus]"
  72 #else
  73 #define CB_OPT ""
  74 #endif
  75 #ifdef CONFIG_PM
  76 #define PM_OPT " [pm]"
  77 #else
  78 #define PM_OPT ""
  79 #endif
  80 #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
  81 #define OPTIONS " none"
  82 #else
  83 #define OPTIONS PCI_OPT CB_OPT PM_OPT
  84 #endif
  85
  86 static const char *release = "Linux Kernel Card Services";
  87 static const char *options = "options: " OPTIONS;
  88
  89 /*====================================================================*/
  90
  91 /* Module parameters */
  92
  93 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  94 MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
  95 MODULE_LICENSE("Dual MPL/GPL");
  96
  97 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
  98
  99 INT_MODULE_PARM(setup_delay,    10);            /* centiseconds */
 100 INT_MODULE_PARM(resume_delay,   20);            /* centiseconds */
 101 INT_MODULE_PARM(shutdown_delay, 3);             /* centiseconds */
 102 INT_MODULE_PARM(vcc_settle,     40);            /* centiseconds */
 103 INT_MODULE_PARM(reset_time,     10);            /* usecs */
 104 INT_MODULE_PARM(unreset_delay,  10);            /* centiseconds */
 105 INT_MODULE_PARM(unreset_check,  10);            /* centiseconds */
 106 INT_MODULE_PARM(unreset_limit,  30);            /* unreset_check's */
 107
 108 /* Access speed for attribute memory windows */
 109 INT_MODULE_PARM(cis_speed,      300);           /* ns */
 110
 111 /* Access speed for IO windows */
 112 INT_MODULE_PARM(io_speed,       0);             /* ns */
 113
 114 #ifdef DEBUG
 115 static int pc_debug;
 116
 117 module_param(pc_debug, int, 0644);
 118
 119 int cs_debug_level(int level)
 120 {
 121         return pc_debug > level;
 122 }
 123 #endif
 124
 125 /*====================================================================*/
 126
 127 socket_state_t dead_socket = {
 128         .csc_mask       = SS_DETECT,
 129 };
 130
 131
 132 /* List of all sockets, protected by a rwsem */
 133 LIST_HEAD(pcmcia_socket_list);
 134 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
 135
 136
 137 /*====================================================================
 138
 139     Low-level PC Card interface drivers need to register with Card
 140     Services using these calls.
 141
 142 ======================================================================*/
 143
 144 /**
 145  * socket drivers are expected to use the following callbacks in their
 146  * .drv struct:
 147  *  - pcmcia_socket_dev_suspend
 148  *  - pcmcia_socket_dev_resume
 149  * These functions check for the appropriate struct pcmcia_soket arrays,
 150  * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
 151  */
 152 static int socket_resume(struct pcmcia_socket *skt);
 153 static int socket_suspend(struct pcmcia_socket *skt);
 154
 155 int pcmcia_socket_dev_suspend(struct device *dev, u32 state)
 156 {
 157         struct pcmcia_socket *socket;
 158
 159         down_read(&pcmcia_socket_list_rwsem);
 160         list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
 161                 if (socket->dev.dev != dev)
 162                         continue;
 163                 down(&socket->skt_sem);
 164                 socket_suspend(socket);
 165                 up(&socket->skt_sem);
 166         }
 167         up_read(&pcmcia_socket_list_rwsem);
 168
 169         return 0;
 170 }
 171 EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
 172
 173 int pcmcia_socket_dev_resume(struct device *dev)
 174 {
 175         struct pcmcia_socket *socket;
 176
 177         down_read(&pcmcia_socket_list_rwsem);
 178         list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
 179                 if (socket->dev.dev != dev)
 180                         continue;
 181                 down(&socket->skt_sem);
 182                 socket_resume(socket);
 183                 up(&socket->skt_sem);
 184         }
 185         up_read(&pcmcia_socket_list_rwsem);
 186
 187         return 0;
 188 }
 189 EXPORT_SYMBOL(pcmcia_socket_dev_resume);
 190
 191
 192 static void pcmcia_release_socket(struct class_device *class_dev)
 193 {
 194         struct pcmcia_socket *socket = class_get_devdata(class_dev);
 195         client_t *client;
 196
 197         while (socket->clients) {
 198                 client = socket->clients;
 199                 socket->clients = socket->clients->next;
 200                 kfree(client);
 201         }
 202
 203         complete(&socket->socket_released);
 204 }
 205
 206 static int pccardd(void *__skt);
 207
 208 /**
 209  * pcmcia_register_socket - add a new pcmcia socket device
 210  */
 211 int pcmcia_register_socket(struct pcmcia_socket *socket)
 212 {
 213         int ret;
 214
 215         if (!socket || !socket->ops || !socket->dev.dev)
 216                 return -EINVAL;
 217
 218         cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
 219
 220         /* try to obtain a socket number [yes, it gets ugly if we
 221          * register more than 2^sizeof(unsigned int) pcmcia
 222          * sockets... but the socket number is deprecated
 223          * anyways, so I don't care] */
 224         down_write(&pcmcia_socket_list_rwsem);
 225         if (list_empty(&pcmcia_socket_list))
 226                 socket->sock = 0;
 227         else {
 228                 unsigned int found, i = 1;
 229                 struct pcmcia_socket *tmp;
 230                 do {
 231                         found = 1;
 232                         list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
 233                                 if (tmp->sock == i)
 234                                         found = 0;
 235                         }
 236                         i++;
 237                 } while (!found);
 238                 socket->sock = i - 1;
 239         }
 240         list_add_tail(&socket->socket_list, &pcmcia_socket_list);
 241         up_write(&pcmcia_socket_list_rwsem);
 242
 243
 244         /* set proper values in socket->dev */
 245         socket->dev.class_data = socket;
 246         socket->dev.class = &pcmcia_socket_class;
 247         snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
 248
 249         /* base address = 0, map = 0 */
 250         socket->cis_mem.flags = 0;
 251         socket->cis_mem.speed = cis_speed;
 252
 253         INIT_LIST_HEAD(&socket->cis_cache);
 254         spin_lock_init(&socket->lock);
 255
 256         init_completion(&socket->socket_released);
 257         init_completion(&socket->thread_done);
 258         init_waitqueue_head(&socket->thread_wait);
 259         init_MUTEX(&socket->skt_sem);
 260         spin_lock_init(&socket->thread_lock);
 261
 262         ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
 263         if (ret < 0)
 264                 goto err;
 265
 266         wait_for_completion(&socket->thread_done);
 267         if(!socket->thread) {
 268                 printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
 269                 return -EIO;
 270         }
 271         pcmcia_parse_events(socket, SS_DETECT);
 272
 273         return 0;
 274
 275  err:
 276         down_write(&pcmcia_socket_list_rwsem);
 277         list_del(&socket->socket_list);
 278         up_write(&pcmcia_socket_list_rwsem);
 279         return ret;
 280 } /* pcmcia_register_socket */
 281 EXPORT_SYMBOL(pcmcia_register_socket);
 282
 283
 284 /**
 285  * pcmcia_unregister_socket - remove a pcmcia socket device
 286  */
 287 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
 288 {
 289         if (!socket)
 290                 return;
 291
 292         cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
 293
 294         if (socket->thread) {
 295                 init_completion(&socket->thread_done);
 296                 socket->thread = NULL;
 297                 wake_up(&socket->thread_wait);
 298                 wait_for_completion(&socket->thread_done);
 299         }
 300         release_cis_mem(socket);
 301
 302         /* remove from our own list */
 303         down_write(&pcmcia_socket_list_rwsem);
 304         list_del(&socket->socket_list);
 305         up_write(&pcmcia_socket_list_rwsem);
 306
 307         /* wait for sysfs to drop all references */
 308         wait_for_completion(&socket->socket_released);
 309 } /* pcmcia_unregister_socket */
 310 EXPORT_SYMBOL(pcmcia_unregister_socket);
 311
 312
 313 struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
 314 {
 315         struct pcmcia_socket *s;
 316
 317         down_read(&pcmcia_socket_list_rwsem);
 318         list_for_each_entry(s, &pcmcia_socket_list, socket_list)
 319                 if (s->sock == nr) {
 320                         up_read(&pcmcia_socket_list_rwsem);
 321                         return s;
 322                 }
 323         up_read(&pcmcia_socket_list_rwsem);
 324
 325         return NULL;
 326
 327 }
 328 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
 329
 330
 331 /*======================================================================
 332
 333     Shutdown_Socket() and setup_socket() are scheduled using add_timer
 334     calls by the main event handler when card insertion and removal
 335     events are received.  Shutdown_Socket() unconfigures a socket and
 336     turns off socket power.  Setup_socket() turns on socket power
 337     and resets the socket, in two stages.
 338
 339 ======================================================================*/
 340
 341 static void free_regions(memory_handle_t *list)
 342 {
 343     memory_handle_t tmp;
 344     while (*list != NULL) {
 345         tmp = *list;
 346         *list = tmp->info.next;
 347         tmp->region_magic = 0;
 348         kfree(tmp);
 349     }
 350 }
 351
 352 static int send_event(struct pcmcia_socket *s, event_t event, int priority);
 353
 354 static void shutdown_socket(struct pcmcia_socket *s)
 355 {
 356     client_t **c;
 357
 358     cs_dbg(s, 1, "shutdown_socket\n");
 359
 360     /* Blank out the socket state */
 361     s->socket = dead_socket;
 362     s->ops->init(s);
 363     s->ops->set_socket(s, &s->socket);
 364     s->irq.AssignedIRQ = s->irq.Config = 0;
 365     s->lock_count = 0;
 366     destroy_cis_cache(s);
 367 #ifdef CONFIG_CARDBUS
 368     cb_free(s);
 369 #endif
 370     s->functions = 0;
 371     if (s->config) {
 372         kfree(s->config);
 373         s->config = NULL;
 374     }
 375     for (c = &s->clients; *c; ) {
 376         if ((*c)->state & CLIENT_UNBOUND) {
 377             client_t *d = *c;
 378             *c = (*c)->next;
 379             kfree(d);
 380         } else {
 381             c = &((*c)->next);
 382         }
 383     }
 384     free_regions(&s->a_region);
 385     free_regions(&s->c_region);
 386
 387     {
 388         int status;
 389         s->ops->get_status(s, &status);
 390         if (status & SS_POWERON) {
 391                 printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
 392         }
 393     }
 394 } /* shutdown_socket */
 395
 396 /*======================================================================
 397
 398     The central event handler.  Send_event() sends an event to all
 399     valid clients.  Parse_events() interprets the event bits from
 400     a card status change report.  Do_shutdown() handles the high
 401     priority stuff associated with a card removal.
 402
 403 ======================================================================*/
 404
 405 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
 406 {
 407     client_t *client = s->clients;
 408     int ret;
 409     cs_dbg(s, 1, "send_event(event %d, pri %d)\n",
 410            event, priority);
 411     ret = 0;
 412     if (s->state & SOCKET_CARDBUS)
 413             return 0;
 414     for (; client; client = client->next) {
 415         if (client->state & (CLIENT_UNBOUND|CLIENT_STALE))
 416             continue;
 417         if (client->EventMask & event) {
 418             ret = EVENT(client, event, priority);
 419             if (ret != 0)
 420                 return ret;
 421         }
 422     }
 423     return ret;
 424 } /* send_event */
 425
 426 static void socket_remove_drivers(struct pcmcia_socket *skt)
 427 {
 428         client_t *client;
 429
 430         cs_dbg(skt, 4, "remove_drivers\n");
 431
 432         send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
 433
 434         for (client = skt->clients; client; client = client->next)
 435                 if (!(client->Attributes & INFO_MASTER_CLIENT))
 436                         client->state |= CLIENT_STALE;
 437 }
 438
 439 static void socket_shutdown(struct pcmcia_socket *skt)
 440 {
 441         cs_dbg(skt, 4, "shutdown\n");
 442
 443         socket_remove_drivers(skt);
 444         skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
 445         msleep(shutdown_delay * 10);
 446         skt->state &= SOCKET_INUSE;
 447         shutdown_socket(skt);
 448 }
 449
 450 static int socket_reset(struct pcmcia_socket *skt)
 451 {
 452         int status, i;
 453
 454         cs_dbg(skt, 4, "reset\n");
 455
 456         skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
 457         skt->ops->set_socket(skt, &skt->socket);
 458         udelay((long)reset_time);
 459
 460         skt->socket.flags &= ~SS_RESET;
 461         skt->ops->set_socket(skt, &skt->socket);
 462
 463         msleep(unreset_delay * 10);
 464         for (i = 0; i < unreset_limit; i++) {
 465                 skt->ops->get_status(skt, &status);
 466
 467                 if (!(status & SS_DETECT))
 468                         return CS_NO_CARD;
 469
 470                 if (status & SS_READY)
 471                         return CS_SUCCESS;
 472
 473                 msleep(unreset_check * 10);
 474         }
 475
 476         cs_err(skt, "time out after reset.\n");
 477         return CS_GENERAL_FAILURE;
 478 }
 479
 480 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
 481 {
 482         int status, i;
 483
 484         cs_dbg(skt, 4, "setup\n");
 485
 486         skt->ops->get_status(skt, &status);
 487         if (!(status & SS_DETECT))
 488                 return CS_NO_CARD;
 489
 490         msleep(initial_delay * 10);
 491
 492         for (i = 0; i < 100; i++) {
 493                 skt->ops->get_status(skt, &status);
 494                 if (!(status & SS_DETECT))
 495                         return CS_NO_CARD;
 496
 497                 if (!(status & SS_PENDING))
 498                         break;
 499
 500                 msleep(100);
 501         }
 502
 503         if (status & SS_PENDING) {
 504                 cs_err(skt, "voltage interrogation timed out.\n");
 505                 return CS_GENERAL_FAILURE;
 506         }
 507
 508         if (status & SS_CARDBUS) {
 509                 skt->state |= SOCKET_CARDBUS;
 510 #ifndef CONFIG_CARDBUS
 511                 cs_err(skt, "cardbus cards are not supported.\n");
 512                 return CS_BAD_TYPE;
 513 #endif
 514         }
 515
 516         /*
 517          * Decode the card voltage requirements, and apply power to the card.
 518          */
 519         if (status & SS_3VCARD)
 520                 skt->socket.Vcc = skt->socket.Vpp = 33;
 521         else if (!(status & SS_XVCARD))
 522                 skt->socket.Vcc = skt->socket.Vpp = 50;
 523         else {
 524                 cs_err(skt, "unsupported voltage key.\n");
 525                 return CS_BAD_TYPE;
 526         }
 527         skt->socket.flags = 0;
 528         skt->ops->set_socket(skt, &skt->socket);
 529
 530         /*
 531          * Wait "vcc_settle" for the supply to stabilise.
 532          */
 533         msleep(vcc_settle * 10);
 534
 535         skt->ops->get_status(skt, &status);
 536         if (!(status & SS_POWERON)) {
 537                 cs_err(skt, "unable to apply power.\n");
 538                 return CS_BAD_TYPE;
 539         }
 540
 541         return socket_reset(skt);
 542 }
 543
 544 /*
 545  * Handle card insertion.  Setup the socket, reset the card,
 546  * and then tell the rest of PCMCIA that a card is present.
 547  */
 548 static int socket_insert(struct pcmcia_socket *skt)
 549 {
 550         int ret;
 551
 552         cs_dbg(skt, 4, "insert\n");
 553
 554         if (!cs_socket_get(skt))
 555                 return CS_NO_CARD;
 556
 557         ret = socket_setup(skt, setup_delay);
 558         if (ret == CS_SUCCESS) {
 559                 skt->state |= SOCKET_PRESENT;
 560 #ifdef CONFIG_CARDBUS
 561                 if (skt->state & SOCKET_CARDBUS) {
 562                         cb_alloc(skt);
 563                         skt->state |= SOCKET_CARDBUS_CONFIG;
 564                 }
 565 #endif
 566                 cs_dbg(skt, 4, "insert done\n");
 567
 568                 send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
 569         } else {
 570                 socket_shutdown(skt);
 571                 cs_socket_put(skt);
 572         }
 573
 574         return ret;
 575 }
 576
 577 static int socket_suspend(struct pcmcia_socket *skt)
 578 {
 579         if (skt->state & SOCKET_SUSPEND)
 580                 return CS_IN_USE;
 581
 582         send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
 583         skt->socket = dead_socket;
 584         skt->ops->suspend(skt);
 585         skt->state |= SOCKET_SUSPEND;
 586
 587         return CS_SUCCESS;
 588 }
 589
 590 /*
 591  * Resume a socket.  If a card is present, verify its CIS against
 592  * our cached copy.  If they are different, the card has been
 593  * replaced, and we need to tell the drivers.
 594  */
 595 static int socket_resume(struct pcmcia_socket *skt)
 596 {
 597         int ret;
 598
 599         if (!(skt->state & SOCKET_SUSPEND))
 600                 return CS_IN_USE;
 601
 602         skt->socket = dead_socket;
 603         skt->ops->init(skt);
 604         skt->ops->set_socket(skt, &skt->socket);
 605
 606         ret = socket_setup(skt, resume_delay);
 607         if (ret == CS_SUCCESS) {
 608                 /*
 609                  * FIXME: need a better check here for cardbus cards.
 610                  */
 611                 if (verify_cis_cache(skt) != 0) {
 612                         cs_dbg(skt, 4, "cis mismatch - different card\n");
 613                         socket_remove_drivers(skt);
 614                         destroy_cis_cache(skt);
 615                         /*
 616                          * Workaround: give DS time to schedule removal.
 617                          * Remove me once the 100ms delay is eliminated
 618                          * in ds.c
 619                          */
 620                         msleep(200);
 621                         send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
 622                 } else {
 623                         cs_dbg(skt, 4, "cis matches cache\n");
 624                         send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
 625                 }
 626         } else {
 627                 socket_shutdown(skt);
 628                 cs_socket_put(skt);
 629         }
 630
 631         skt->state &= ~SOCKET_SUSPEND;
 632
 633         return CS_SUCCESS;
 634 }
 635
 636 static void socket_remove(struct pcmcia_socket *skt)
 637 {
 638         socket_shutdown(skt);
 639         cs_socket_put(skt);
 640 }
 641
 642 /*
 643  * Process a socket card detect status change.
 644  *
 645  * If we don't have a card already present, delay the detect event for
 646  * about 20ms (to be on the safe side) before reading the socket status.
 647  *
 648  * Some i82365-based systems send multiple SS_DETECT events during card
 649  * insertion, and the "card present" status bit seems to bounce.  This
 650  * will probably be true with GPIO-based card detection systems after
 651  * the product has aged.
 652  */
 653 static void socket_detect_change(struct pcmcia_socket *skt)
 654 {
 655         if (!(skt->state & SOCKET_SUSPEND)) {
 656                 int status;
 657
 658                 if (!(skt->state & SOCKET_PRESENT))
 659                         msleep(20);
 660
 661                 skt->ops->get_status(skt, &status);
 662                 if ((skt->state & SOCKET_PRESENT) &&
 663                      !(status & SS_DETECT))
 664                         socket_remove(skt);
 665                 if (!(skt->state & SOCKET_PRESENT) &&
 666                     (status & SS_DETECT))
 667                         socket_insert(skt);
 668         }
 669 }
 670
 671 static int pccardd(void *__skt)
 672 {
 673         struct pcmcia_socket *skt = __skt;
 674         DECLARE_WAITQUEUE(wait, current);
 675         int ret;
 676
 677         daemonize("pccardd");
 678
 679         skt->thread = current;
 680         skt->socket = dead_socket;
 681         skt->ops->init(skt);
 682         skt->ops->set_socket(skt, &skt->socket);
 683
 684         /* register with the device core */
 685         ret = class_device_register(&skt->dev);
 686         if (ret) {
 687                 printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
 688                         skt);
 689                 skt->thread = NULL;
 690                 complete_and_exit(&skt->thread_done, 0);
 691         }
 692         complete(&skt->thread_done);
 693
 694         add_wait_queue(&skt->thread_wait, &wait);
 695         for (;;) {
 696                 unsigned long flags;
 697                 unsigned int events;
 698
 699                 set_current_state(TASK_INTERRUPTIBLE);
 700
 701                 spin_lock_irqsave(&skt->thread_lock, flags);
 702                 events = skt->thread_events;
 703                 skt->thread_events = 0;
 704                 spin_unlock_irqrestore(&skt->thread_lock, flags);
 705
 706                 if (events) {
 707                         down(&skt->skt_sem);
 708                         if (events & SS_DETECT)
 709                                 socket_detect_change(skt);
 710                         if (events & SS_BATDEAD)
 711                                 send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
 712                         if (events & SS_BATWARN)
 713                                 send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
 714                         if (events & SS_READY)
 715                                 send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
 716                         up(&skt->skt_sem);
 717                         continue;
 718                 }
 719
 720                 schedule();
 721                 if (current->flags & PF_FREEZE)
 722                         refrigerator(PF_FREEZE);
 723
 724                 if (!skt->thread)
 725                         break;
 726         }
 727         remove_wait_queue(&skt->thread_wait, &wait);
 728
 729         /* remove from the device core */
 730         class_device_unregister(&skt->dev);
 731
 732         complete_and_exit(&skt->thread_done, 0);
 733 }
 734
 735 /*
 736  * Yenta (at least) probes interrupts before registering the socket and
 737  * starting the handler thread.
 738  */
 739 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
 740 {
 741         cs_dbg(s, 4, "parse_events: events %08x\n", events);
 742         if (s->thread) {
 743                 spin_lock(&s->thread_lock);
 744                 s->thread_events |= events;
 745                 spin_unlock(&s->thread_lock);
 746
 747                 wake_up(&s->thread_wait);
 748         }
 749 } /* pcmcia_parse_events */
 750
 751
 752 /*======================================================================
 753
 754     Special stuff for managing IO windows, because they are scarce.
 755
 756 ======================================================================*/
 757
 758 static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
 759                           ioaddr_t num, u_int lines, char *name)
 760 {
 761     int i;
 762     ioaddr_t try, align;
 763
 764     align = (*base) ? (lines ? 1<<lines : 0) : 1;
 765     if (align && (align < num)) {
 766         if (*base) {
 767             cs_dbg(s, 0, "odd IO request: num %04x align %04x\n",
 768                    num, align);
 769             align = 0;
 770         } else
 771             while (align && (align < num)) align <<= 1;
 772     }
 773     if (*base & ~(align-1)) {
 774         cs_dbg(s, 0, "odd IO request: base %04x align %04x\n",
 775                *base, align);
 776         align = 0;
 777     }
 778     if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
 779         *base = s->io_offset | (*base & 0x0fff);
 780         return 0;
 781     }
 782     /* Check for an already-allocated window that must conflict with
 783        what was asked for.  It is a hack because it does not catch all
 784        potential conflicts, just the most obvious ones. */
 785     for (i = 0; i < MAX_IO_WIN; i++)
 786         if ((s->io[i].NumPorts != 0) &&
 787             ((s->io[i].BasePort & (align-1)) == *base))
 788             return 1;
 789     for (i = 0; i < MAX_IO_WIN; i++) {
 790         if (s->io[i].NumPorts == 0) {
 791             s->io[i].res = find_io_region(*base, num, align, name, s);
 792             if (s->io[i].res) {
 793                 s->io[i].Attributes = attr;
 794                 s->io[i].BasePort = *base = s->io[i].res->start;
 795                 s->io[i].NumPorts = s->io[i].InUse = num;
 796                 break;
 797             } else
 798                 return 1;
 799         } else if (s->io[i].Attributes != attr)
 800             continue;
 801         /* Try to extend top of window */
 802         try = s->io[i].BasePort + s->io[i].NumPorts;
 803         if ((*base == 0) || (*base == try))
 804             if (adjust_io_region(s->io[i].res, s->io[i].res->start,
 805                                  s->io[i].res->end + num, s) == 0) {
 806                 *base = try;
 807                 s->io[i].NumPorts += num;
 808                 s->io[i].InUse += num;
 809                 break;
 810             }
 811         /* Try to extend bottom of window */
 812         try = s->io[i].BasePort - num;
 813         if ((*base == 0) || (*base == try))
 814             if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
 815                                  s->io[i].res->end, s) == 0) {
 816                 s->io[i].BasePort = *base = try;
 817                 s->io[i].NumPorts += num;
 818                 s->io[i].InUse += num;
 819                 break;
 820             }
 821     }
 822     return (i == MAX_IO_WIN);
 823 } /* alloc_io_space */
 824
 825 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
 826                              ioaddr_t num)
 827 {
 828     int i;
 829
 830     for (i = 0; i < MAX_IO_WIN; i++) {
 831         if ((s->io[i].BasePort <= base) &&
 832             (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
 833             s->io[i].InUse -= num;
 834             /* Free the window if no one else is using it */
 835             if (s->io[i].InUse == 0) {
 836                 s->io[i].NumPorts = 0;
 837                 release_resource(s->io[i].res);
 838                 kfree(s->io[i].res);
 839                 s->io[i].res = NULL;
 840             }
 841         }
 842     }
 843 }
 844
 845 /*======================================================================
 846
 847     Access_configuration_register() reads and writes configuration
 848     registers in attribute memory.  Memory window 0 is reserved for
 849     this and the tuple reading services.
 850
 851 ======================================================================*/
 852
 853 int pccard_access_configuration_register(struct pcmcia_socket *s,
 854                                          unsigned int function,
 855                                          conf_reg_t *reg)
 856 {
 857     config_t *c;
 858     int addr;
 859     u_char val;
 860
 861     if (!s || !s->config)
 862         return CS_NO_CARD;
 863
 864     c = &s->config[function];
 865
 866     if (c == NULL)
 867         return CS_NO_CARD;
 868
 869     if (!(c->state & CONFIG_LOCKED))
 870         return CS_CONFIGURATION_LOCKED;
 871
 872     addr = (c->ConfigBase + reg->Offset) >> 1;
 873
 874     switch (reg->Action) {
 875     case CS_READ:
 876         read_cis_mem(s, 1, addr, 1, &val);
 877         reg->Value = val;
 878         break;
 879     case CS_WRITE:
 880         val = reg->Value;
 881         write_cis_mem(s, 1, addr, 1, &val);
 882         break;
 883     default:
 884         return CS_BAD_ARGS;
 885         break;
 886     }
 887     return CS_SUCCESS;
 888 } /* access_configuration_register */
 889 EXPORT_SYMBOL(pccard_access_configuration_register);
 890
 891 /*====================================================================*/
 892
 893 int pcmcia_deregister_client(client_handle_t handle)
 894 {
 895     client_t **client;
 896     struct pcmcia_socket *s;
 897     u_long flags;
 898     int i;
 899
 900     if (CHECK_HANDLE(handle))
 901         return CS_BAD_HANDLE;
 902
 903     s = SOCKET(handle);
 904     cs_dbg(s, 1, "deregister_client(%p)\n", handle);
 905
 906     if (handle->state &
 907         (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
 908         return CS_IN_USE;
 909     for (i = 0; i < MAX_WIN; i++)
 910         if (handle->state & CLIENT_WIN_REQ(i))
 911             return CS_IN_USE;
 912
 913     if ((handle->state & CLIENT_STALE) ||
 914         (handle->Attributes & INFO_MASTER_CLIENT)) {
 915         spin_lock_irqsave(&s->lock, flags);
 916         client = &s->clients;
 917         while ((*client) && ((*client) != handle))
 918             client = &(*client)->next;
 919         if (*client == NULL) {
 920             spin_unlock_irqrestore(&s->lock, flags);
 921             return CS_BAD_HANDLE;
 922         }
 923         *client = handle->next;
 924         handle->client_magic = 0;
 925         kfree(handle);
 926         spin_unlock_irqrestore(&s->lock, flags);
 927     } else {
 928         handle->state = CLIENT_UNBOUND;
 929         handle->event_handler = NULL;
 930     }
 931
 932     return CS_SUCCESS;
 933 } /* deregister_client */
 934
 935 /*====================================================================*/
 936
 937 int pccard_get_configuration_info(struct pcmcia_socket *s,
 938                                   unsigned int function,
 939                                   config_info_t *config)
 940 {
 941     config_t *c;
 942
 943     if (!(s->state & SOCKET_PRESENT))
 944         return CS_NO_CARD;
 945
 946     config->Function = function;
 947
 948 #ifdef CONFIG_CARDBUS
 949     if (s->state & SOCKET_CARDBUS) {
 950         memset(config, 0, sizeof(config_info_t));
 951         config->Vcc = s->socket.Vcc;
 952         config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 953         config->Option = s->cb_dev->subordinate->number;
 954         if (s->state & SOCKET_CARDBUS_CONFIG) {
 955             config->Attributes = CONF_VALID_CLIENT;
 956             config->IntType = INT_CARDBUS;
 957             config->AssignedIRQ = s->irq.AssignedIRQ;
 958             if (config->AssignedIRQ)
 959                 config->Attributes |= CONF_ENABLE_IRQ;
 960             config->BasePort1 = s->io[0].BasePort;
 961             config->NumPorts1 = s->io[0].NumPorts;
 962         }
 963         return CS_SUCCESS;
 964     }
 965 #endif
 966
 967     c = (s->config != NULL) ? &s->config[function] : NULL;
 968
 969     if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
 970         config->Attributes = 0;
 971         config->Vcc = s->socket.Vcc;
 972         config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 973         return CS_SUCCESS;
 974     }
 975
 976     /* !!! This is a hack !!! */
 977     memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
 978     config->Attributes |= CONF_VALID_CLIENT;
 979     config->CardValues = c->CardValues;
 980     config->IRQAttributes = c->irq.Attributes;
 981     config->AssignedIRQ = s->irq.AssignedIRQ;
 982     config->BasePort1 = c->io.BasePort1;
 983     config->NumPorts1 = c->io.NumPorts1;
 984     config->Attributes1 = c->io.Attributes1;
 985     config->BasePort2 = c->io.BasePort2;
 986     config->NumPorts2 = c->io.NumPorts2;
 987     config->Attributes2 = c->io.Attributes2;
 988     config->IOAddrLines = c->io.IOAddrLines;
 989
 990     return CS_SUCCESS;
 991 } /* get_configuration_info */
 992 EXPORT_SYMBOL(pccard_get_configuration_info);
 993
 994 /*======================================================================
 995
 996     Return information about this version of Card Services.
 997
 998 ======================================================================*/
 999
1000 int pcmcia_get_card_services_info(servinfo_t *info)
1001 {
1002     unsigned int socket_count = 0;
1003     struct list_head *tmp;
1004     info->Signature[0] = 'C';
1005     info->Signature[1] = 'S';
1006     down_read(&pcmcia_socket_list_rwsem);
1007     list_for_each(tmp, &pcmcia_socket_list)
1008             socket_count++;
1009     up_read(&pcmcia_socket_list_rwsem);
1010     info->Count = socket_count;
1011     info->Revision = CS_RELEASE_CODE;
1012     info->CSLevel = 0x0210;
1013     info->VendorString = (char *)release;
1014     return CS_SUCCESS;
1015 } /* get_card_services_info */
1016
1017 #ifdef CONFIG_PCMCIA_OBSOLETE
1018
1019 /*======================================================================
1020
1021     Note that get_first_client() *does* recognize the Socket field
1022     in the request structure.
1023
1024 ======================================================================*/
1025
1026 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1027 {
1028     socket_t s;
1029     struct pcmcia_socket *socket;
1030     if (req->Attributes & CLIENT_THIS_SOCKET)
1031         s = req->Socket;
1032     else
1033         s = 0;
1034     socket = pcmcia_get_socket_by_nr(s);
1035     if (!socket)
1036         return CS_BAD_SOCKET;
1037     if (socket->clients == NULL)
1038         return CS_NO_MORE_ITEMS;
1039     *handle = socket->clients;
1040     return CS_SUCCESS;
1041 } /* get_first_client */
1042 EXPORT_SYMBOL(pcmcia_get_first_client);
1043
1044 /*====================================================================*/
1045
1046 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1047 {
1048     struct pcmcia_socket *s;
1049     if ((handle == NULL) || CHECK_HANDLE(*handle))
1050         return CS_BAD_HANDLE;
1051     if ((*handle)->next == NULL) {
1052         if (req->Attributes & CLIENT_THIS_SOCKET)
1053             return CS_NO_MORE_ITEMS;
1054         s = (*handle)->Socket;
1055         if (s->clients == NULL)
1056             return CS_NO_MORE_ITEMS;
1057         *handle = s->clients;
1058     } else
1059         *handle = (*handle)->next;
1060     return CS_SUCCESS;
1061 } /* get_next_client */
1062 EXPORT_SYMBOL(pcmcia_get_next_client);
1063 #endif /* CONFIG_PCMCIA_OBSOLETE */
1064
1065 /*====================================================================*/
1066
1067 int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
1068 {
1069     window_t *win;
1070     int w;
1071
1072     if (!s || !(s->state & SOCKET_PRESENT))
1073         return CS_NO_CARD;
1074     for (w = idx; w < MAX_WIN; w++)
1075         if (s->state & SOCKET_WIN_REQ(w)) break;
1076     if (w == MAX_WIN)
1077         return CS_NO_MORE_ITEMS;
1078     win = &s->win[w];
1079     req->Base = win->ctl.res->start;
1080     req->Size = win->ctl.res->end - win->ctl.res->start + 1;
1081     req->AccessSpeed = win->ctl.speed;
1082     req->Attributes = 0;
1083     if (win->ctl.flags & MAP_ATTRIB)
1084         req->Attributes |= WIN_MEMORY_TYPE_AM;
1085     if (win->ctl.flags & MAP_ACTIVE)
1086         req->Attributes |= WIN_ENABLE;
1087     if (win->ctl.flags & MAP_16BIT)
1088         req->Attributes |= WIN_DATA_WIDTH_16;
1089     if (win->ctl.flags & MAP_USE_WAIT)
1090         req->Attributes |= WIN_USE_WAIT;
1091     *handle = win;
1092     return CS_SUCCESS;
1093 } /* get_window */
1094 EXPORT_SYMBOL(pcmcia_get_window);
1095
1096 /*=====================================================================
1097
1098     Return the PCI device associated with a card..
1099
1100 ======================================================================*/
1101
1102 #ifdef CONFIG_CARDBUS
1103
1104 struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
1105 {
1106         if (!s || !(s->state & SOCKET_CARDBUS))
1107                 return NULL;
1108
1109         return s->cb_dev->subordinate;
1110 }
1111
1112 EXPORT_SYMBOL(pcmcia_lookup_bus);
1113
1114 #endif
1115
1116 /*======================================================================
1117
1118     Get the current socket state bits.  We don't support the latched
1119     SocketState yet: I haven't seen any point for it.
1120
1121 ======================================================================*/
1122
1123 int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
1124 {
1125     config_t *c;
1126     int val;
1127
1128     s->ops->get_status(s, &val);
1129     status->CardState = status->SocketState = 0;
1130     status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1131     status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1132     status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1133     status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1134     if (s->state & SOCKET_SUSPEND)
1135         status->CardState |= CS_EVENT_PM_SUSPEND;
1136     if (!(s->state & SOCKET_PRESENT))
1137         return CS_NO_CARD;
1138
1139     c = (s->config != NULL) ? &s->config[function] : NULL;
1140     if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1141         (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1142         u_char reg;
1143         if (c->Present & PRESENT_PIN_REPLACE) {
1144             read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
1145             status->CardState |=
1146                 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1147             status->CardState |=
1148                 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1149             status->CardState |=
1150                 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1151             status->CardState |=
1152                 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1153         } else {
1154             /* No PRR?  Then assume we're always ready */
1155             status->CardState |= CS_EVENT_READY_CHANGE;
1156         }
1157         if (c->Present & PRESENT_EXT_STATUS) {
1158             read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
1159             status->CardState |=
1160                 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1161         }
1162         return CS_SUCCESS;
1163     }
1164     status->CardState |=
1165         (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1166     status->CardState |=
1167         (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1168     status->CardState |=
1169         (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1170     status->CardState |=
1171         (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1172     return CS_SUCCESS;
1173 } /* get_status */
1174 EXPORT_SYMBOL(pccard_get_status);
1175
1176 /*======================================================================
1177
1178     Change the card address of an already open memory window.
1179
1180 ======================================================================*/
1181
1182 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1183 {
1184     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1185         return CS_BAD_HANDLE;
1186     req->Page = 0;
1187     req->CardOffset = win->ctl.card_start;
1188     return CS_SUCCESS;
1189 } /* get_mem_page */
1190
1191 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1192 {
1193     struct pcmcia_socket *s;
1194     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1195         return CS_BAD_HANDLE;
1196     if (req->Page != 0)
1197         return CS_BAD_PAGE;
1198     s = win->sock;
1199     win->ctl.card_start = req->CardOffset;
1200     if (s->ops->set_mem_map(s, &win->ctl) != 0)
1201         return CS_BAD_OFFSET;
1202     return CS_SUCCESS;
1203 } /* map_mem_page */
1204
1205 /*======================================================================
1206
1207     Modify a locked socket configuration
1208
1209 ======================================================================*/
1210
1211 int pcmcia_modify_configuration(client_handle_t handle,
1212                                 modconf_t *mod)
1213 {
1214     struct pcmcia_socket *s;
1215     config_t *c;
1216
1217     if (CHECK_HANDLE(handle))
1218         return CS_BAD_HANDLE;
1219     s = SOCKET(handle); c = CONFIG(handle);
1220     if (!(s->state & SOCKET_PRESENT))
1221         return CS_NO_CARD;
1222     if (!(c->state & CONFIG_LOCKED))
1223         return CS_CONFIGURATION_LOCKED;
1224
1225     if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1226         if (mod->Attributes & CONF_ENABLE_IRQ) {
1227             c->Attributes |= CONF_ENABLE_IRQ;
1228             s->socket.io_irq = s->irq.AssignedIRQ;
1229         } else {
1230             c->Attributes &= ~CONF_ENABLE_IRQ;
1231             s->socket.io_irq = 0;
1232         }
1233         s->ops->set_socket(s, &s->socket);
1234     }
1235
1236     if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1237         return CS_BAD_VCC;
1238
1239     /* We only allow changing Vpp1 and Vpp2 to the same value */
1240     if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1241         (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1242         if (mod->Vpp1 != mod->Vpp2)
1243             return CS_BAD_VPP;
1244         c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1245         if (s->ops->set_socket(s, &s->socket))
1246             return CS_BAD_VPP;
1247     } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1248                (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1249         return CS_BAD_VPP;
1250
1251     return CS_SUCCESS;
1252 } /* modify_configuration */
1253
1254 #ifdef CONFIG_PCMCIA_OBSOLETE
1255
1256 /*======================================================================
1257
1258     Modify the attributes of a window returned by RequestWindow.
1259
1260 ======================================================================*/
1261
1262 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1263 {
1264     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1265         return CS_BAD_HANDLE;
1266
1267     win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1268     if (req->Attributes & WIN_MEMORY_TYPE)
1269         win->ctl.flags |= MAP_ATTRIB;
1270     if (req->Attributes & WIN_ENABLE)
1271         win->ctl.flags |= MAP_ACTIVE;
1272     if (req->Attributes & WIN_DATA_WIDTH_16)
1273         win->ctl.flags |= MAP_16BIT;
1274     if (req->Attributes & WIN_USE_WAIT)
1275         win->ctl.flags |= MAP_USE_WAIT;
1276     win->ctl.speed = req->AccessSpeed;
1277     win->sock->ops->set_mem_map(win->sock, &win->ctl);
1278
1279     return CS_SUCCESS;
1280 } /* modify_window */
1281 EXPORT_SYMBOL(pcmcia_modify_window);
1282
1283 #endif /* CONFIG_PCMCIA_OBSOLETE */
1284
1285
1286 /*======================================================================
1287
1288     Register_client() uses the dev_info_t handle to match the
1289     caller with a socket.  The driver must have already been bound
1290     to a socket with bind_device() -- in fact, bind_device()
1291     allocates the client structure that will be used.
1292
1293 ======================================================================*/
1294
1295 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1296 {
1297     client_t *client = NULL;
1298     struct pcmcia_socket *s;
1299
1300     /* Look for unbound client with matching dev_info */
1301     down_read(&pcmcia_socket_list_rwsem);
1302     list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1303         client = s->clients;
1304         while (client != NULL) {
1305             if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1306                 && (client->state & CLIENT_UNBOUND)) break;
1307             client = client->next;
1308         }
1309         if (client != NULL) break;
1310     }
1311     up_read(&pcmcia_socket_list_rwsem);
1312     if (client == NULL)
1313         return CS_OUT_OF_RESOURCE;
1314
1315     /*
1316      * Prevent this racing with a card insertion.
1317      */
1318     down(&s->skt_sem);
1319     *handle = client;
1320     client->state &= ~CLIENT_UNBOUND;
1321     client->Socket = s;
1322     client->Attributes = req->Attributes;
1323     client->EventMask = req->EventMask;
1324     client->event_handler = req->event_handler;
1325     client->event_callback_args = req->event_callback_args;
1326     client->event_callback_args.client_handle = client;
1327
1328     if (s->state & SOCKET_CARDBUS)
1329         client->state |= CLIENT_CARDBUS;
1330
1331     if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1332         (client->Function != BIND_FN_ALL)) {
1333         cistpl_longlink_mfc_t mfc;
1334         if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1335             == CS_SUCCESS)
1336             s->functions = mfc.nfn;
1337         else
1338             s->functions = 1;
1339         s->config = kmalloc(sizeof(config_t) * s->functions,
1340                             GFP_KERNEL);
1341         if (!s->config)
1342                 goto out_no_resource;
1343         memset(s->config, 0, sizeof(config_t) * s->functions);
1344     }
1345
1346     cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1347            client, client->dev_info);
1348     if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1349         EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1350
1351     if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1352         if (client->EventMask & CS_EVENT_CARD_INSERTION)
1353             EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1354         else
1355             client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1356     }
1357
1358     up(&s->skt_sem);
1359     return CS_SUCCESS;
1360
1361  out_no_resource:
1362     up(&s->skt_sem);
1363     return CS_OUT_OF_RESOURCE;
1364 } /* register_client */
1365
1366 /*====================================================================*/
1367
1368 int pcmcia_release_configuration(client_handle_t handle)
1369 {
1370     pccard_io_map io = { 0, 0, 0, 0, 1 };
1371     struct pcmcia_socket *s;
1372     int i;
1373
1374     if (CHECK_HANDLE(handle) ||
1375         !(handle->state & CLIENT_CONFIG_LOCKED))
1376         return CS_BAD_HANDLE;
1377     handle->state &= ~CLIENT_CONFIG_LOCKED;
1378     s = SOCKET(handle);
1379
1380 #ifdef CONFIG_CARDBUS
1381     if (handle->state & CLIENT_CARDBUS)
1382         return CS_SUCCESS;
1383 #endif
1384
1385     if (!(handle->state & CLIENT_STALE)) {
1386         config_t *c = CONFIG(handle);
1387         if (--(s->lock_count) == 0) {
1388             s->socket.flags = SS_OUTPUT_ENA;   /* Is this correct? */
1389             s->socket.Vpp = 0;
1390             s->socket.io_irq = 0;
1391             s->ops->set_socket(s, &s->socket);
1392         }
1393         if (c->state & CONFIG_IO_REQ)
1394             for (i = 0; i < MAX_IO_WIN; i++) {
1395                 if (s->io[i].NumPorts == 0)
1396                     continue;
1397                 s->io[i].Config--;
1398                 if (s->io[i].Config != 0)
1399                     continue;
1400                 io.map = i;
1401                 s->ops->set_io_map(s, &io);
1402             }
1403         c->state &= ~CONFIG_LOCKED;
1404     }
1405
1406     return CS_SUCCESS;
1407 } /* release_configuration */
1408
1409 /*======================================================================
1410
1411     Release_io() releases the I/O ranges allocated by a client.  This
1412     may be invoked some time after a card ejection has already dumped
1413     the actual socket configuration, so if the client is "stale", we
1414     don't bother checking the port ranges against the current socket
1415     values.
1416
1417 ======================================================================*/
1418
1419 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1420 {
1421     struct pcmcia_socket *s;
1422
1423     if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1424         return CS_BAD_HANDLE;
1425     handle->state &= ~CLIENT_IO_REQ;
1426     s = SOCKET(handle);
1427
1428 #ifdef CONFIG_CARDBUS
1429     if (handle->state & CLIENT_CARDBUS)
1430         return CS_SUCCESS;
1431 #endif
1432
1433     if (!(handle->state & CLIENT_STALE)) {
1434         config_t *c = CONFIG(handle);
1435         if (c->state & CONFIG_LOCKED)
1436             return CS_CONFIGURATION_LOCKED;
1437         if ((c->io.BasePort1 != req->BasePort1) ||
1438             (c->io.NumPorts1 != req->NumPorts1) ||
1439             (c->io.BasePort2 != req->BasePort2) ||
1440             (c->io.NumPorts2 != req->NumPorts2))
1441             return CS_BAD_ARGS;
1442         c->state &= ~CONFIG_IO_REQ;
1443     }
1444
1445     release_io_space(s, req->BasePort1, req->NumPorts1);
1446     if (req->NumPorts2)
1447         release_io_space(s, req->BasePort2, req->NumPorts2);
1448
1449     return CS_SUCCESS;
1450 } /* release_io */
1451
1452 /*====================================================================*/
1453
1454 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1455 {
1456     struct pcmcia_socket *s;
1457     if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1458         return CS_BAD_HANDLE;
1459     handle->state &= ~CLIENT_IRQ_REQ;
1460     s = SOCKET(handle);
1461
1462     if (!(handle->state & CLIENT_STALE)) {
1463         config_t *c = CONFIG(handle);
1464         if (c->state & CONFIG_LOCKED)
1465             return CS_CONFIGURATION_LOCKED;
1466         if (c->irq.Attributes != req->Attributes)
1467             return CS_BAD_ATTRIBUTE;
1468         if (s->irq.AssignedIRQ != req->AssignedIRQ)
1469             return CS_BAD_IRQ;
1470         if (--s->irq.Config == 0) {
1471             c->state &= ~CONFIG_IRQ_REQ;
1472             s->irq.AssignedIRQ = 0;
1473         }
1474     }
1475
1476     if (req->Attributes & IRQ_HANDLE_PRESENT) {
1477         free_irq(req->AssignedIRQ, req->Instance);
1478     }
1479
1480 #ifdef CONFIG_PCMCIA_PROBE
1481     if (req->AssignedIRQ != s->pci_irq)
1482         undo_irq(req->Attributes, req->AssignedIRQ);
1483 #endif
1484
1485     return CS_SUCCESS;
1486 } /* cs_release_irq */
1487
1488 /*====================================================================*/
1489
1490 int pcmcia_release_window(window_handle_t win)
1491 {
1492     struct pcmcia_socket *s;
1493
1494     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1495         return CS_BAD_HANDLE;
1496     s = win->sock;
1497     if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1498         return CS_BAD_HANDLE;
1499
1500     /* Shut down memory window */
1501     win->ctl.flags &= ~MAP_ACTIVE;
1502     s->ops->set_mem_map(s, &win->ctl);
1503     s->state &= ~SOCKET_WIN_REQ(win->index);
1504
1505     /* Release system memory */
1506     if (win->ctl.res) {
1507         release_resource(win->ctl.res);
1508         kfree(win->ctl.res);
1509         win->ctl.res = NULL;
1510     }
1511     win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1512
1513     win->magic = 0;
1514
1515     return CS_SUCCESS;
1516 } /* release_window */
1517
1518 /*====================================================================*/
1519
1520 int pcmcia_request_configuration(client_handle_t handle,
1521                                  config_req_t *req)
1522 {
1523     int i;
1524     u_int base;
1525     struct pcmcia_socket *s;
1526     config_t *c;
1527     pccard_io_map iomap;
1528
1529     if (CHECK_HANDLE(handle))
1530         return CS_BAD_HANDLE;
1531     s = SOCKET(handle);
1532     if (!(s->state & SOCKET_PRESENT))
1533         return CS_NO_CARD;
1534
1535 #ifdef CONFIG_CARDBUS
1536     if (handle->state & CLIENT_CARDBUS)
1537         return CS_UNSUPPORTED_MODE;
1538 #endif
1539
1540     if (req->IntType & INT_CARDBUS)
1541         return CS_UNSUPPORTED_MODE;
1542     c = CONFIG(handle);
1543     if (c->state & CONFIG_LOCKED)
1544         return CS_CONFIGURATION_LOCKED;
1545
1546     /* Do power control.  We don't allow changes in Vcc. */
1547     if (s->socket.Vcc != req->Vcc)
1548         return CS_BAD_VCC;
1549     if (req->Vpp1 != req->Vpp2)
1550         return CS_BAD_VPP;
1551     s->socket.Vpp = req->Vpp1;
1552     if (s->ops->set_socket(s, &s->socket))
1553         return CS_BAD_VPP;
1554
1555     c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1556
1557     /* Pick memory or I/O card, DMA mode, interrupt */
1558     c->IntType = req->IntType;
1559     c->Attributes = req->Attributes;
1560     if (req->IntType & INT_MEMORY_AND_IO)
1561         s->socket.flags |= SS_IOCARD;
1562     if (req->IntType & INT_ZOOMED_VIDEO)
1563         s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1564     if (req->Attributes & CONF_ENABLE_DMA)
1565         s->socket.flags |= SS_DMA_MODE;
1566     if (req->Attributes & CONF_ENABLE_SPKR)
1567         s->socket.flags |= SS_SPKR_ENA;
1568     if (req->Attributes & CONF_ENABLE_IRQ)
1569         s->socket.io_irq = s->irq.AssignedIRQ;
1570     else
1571         s->socket.io_irq = 0;
1572     s->ops->set_socket(s, &s->socket);
1573     s->lock_count++;
1574
1575     /* Set up CIS configuration registers */
1576     base = c->ConfigBase = req->ConfigBase;
1577     c->Present = c->CardValues = req->Present;
1578     if (req->Present & PRESENT_COPY) {
1579         c->Copy = req->Copy;
1580         write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1581     }
1582     if (req->Present & PRESENT_OPTION) {
1583         if (s->functions == 1) {
1584             c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1585         } else {
1586             c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1587             c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1588             if (req->Present & PRESENT_IOBASE_0)
1589                 c->Option |= COR_ADDR_DECODE;
1590         }
1591         if (c->state & CONFIG_IRQ_REQ)
1592             if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1593                 c->Option |= COR_LEVEL_REQ;
1594         write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1595         mdelay(40);
1596     }
1597     if (req->Present & PRESENT_STATUS) {
1598         c->Status = req->Status;
1599         write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1600     }
1601     if (req->Present & PRESENT_PIN_REPLACE) {
1602         c->Pin = req->Pin;
1603         write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1604     }
1605     if (req->Present & PRESENT_EXT_STATUS) {
1606         c->ExtStatus = req->ExtStatus;
1607         write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1608     }
1609     if (req->Present & PRESENT_IOBASE_0) {
1610         u_char b = c->io.BasePort1 & 0xff;
1611         write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1612         b = (c->io.BasePort1 >> 8) & 0xff;
1613         write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1614     }
1615     if (req->Present & PRESENT_IOSIZE) {
1616         u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1617         write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1618     }
1619
1620     /* Configure I/O windows */
1621     if (c->state & CONFIG_IO_REQ) {
1622         iomap.speed = io_speed;
1623         for (i = 0; i < MAX_IO_WIN; i++)
1624             if (s->io[i].NumPorts != 0) {
1625                 iomap.map = i;
1626                 iomap.flags = MAP_ACTIVE;
1627                 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1628                 case IO_DATA_PATH_WIDTH_16:
1629                     iomap.flags |= MAP_16BIT; break;
1630                 case IO_DATA_PATH_WIDTH_AUTO:
1631                     iomap.flags |= MAP_AUTOSZ; break;
1632                 default:
1633                     break;
1634                 }
1635                 iomap.start = s->io[i].BasePort;
1636                 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1637                 s->ops->set_io_map(s, &iomap);
1638                 s->io[i].Config++;
1639             }
1640     }
1641
1642     c->state |= CONFIG_LOCKED;
1643     handle->state |= CLIENT_CONFIG_LOCKED;
1644     return CS_SUCCESS;
1645 } /* request_configuration */
1646
1647 /*======================================================================
1648
1649     Request_io() reserves ranges of port addresses for a socket.
1650     I have not implemented range sharing or alias addressing.
1651
1652 ======================================================================*/
1653
1654 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1655 {
1656     struct pcmcia_socket *s;
1657     config_t *c;
1658
1659     if (CHECK_HANDLE(handle))
1660         return CS_BAD_HANDLE;
1661     s = SOCKET(handle);
1662     if (!(s->state & SOCKET_PRESENT))
1663         return CS_NO_CARD;
1664
1665     if (handle->state & CLIENT_CARDBUS) {
1666 #ifdef CONFIG_CARDBUS
1667         handle->state |= CLIENT_IO_REQ;
1668         return CS_SUCCESS;
1669 #else
1670         return CS_UNSUPPORTED_FUNCTION;
1671 #endif
1672     }
1673
1674     if (!req)
1675         return CS_UNSUPPORTED_MODE;
1676     c = CONFIG(handle);
1677     if (c->state & CONFIG_LOCKED)
1678         return CS_CONFIGURATION_LOCKED;
1679     if (c->state & CONFIG_IO_REQ)
1680         return CS_IN_USE;
1681     if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1682         return CS_BAD_ATTRIBUTE;
1683     if ((req->NumPorts2 > 0) &&
1684         (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1685         return CS_BAD_ATTRIBUTE;
1686
1687     if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1688                        req->NumPorts1, req->IOAddrLines,
1689                        handle->dev_info))
1690         return CS_IN_USE;
1691
1692     if (req->NumPorts2) {
1693         if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1694                            req->NumPorts2, req->IOAddrLines,
1695                            handle->dev_info)) {
1696             release_io_space(s, req->BasePort1, req->NumPorts1);
1697             return CS_IN_USE;
1698         }
1699     }
1700
1701     c->io = *req;
1702     c->state |= CONFIG_IO_REQ;
1703     handle->state |= CLIENT_IO_REQ;
1704     return CS_SUCCESS;
1705 } /* request_io */
1706
1707 /*======================================================================
1708
1709     Request_irq() reserves an irq for this client.
1710
1711     Also, since Linux only reserves irq's when they are actually
1712     hooked, we don't guarantee that an irq will still be available
1713     when the configuration is locked.  Now that I think about it,
1714     there might be a way to fix this using a dummy handler.
1715
1716 ======================================================================*/
1717
1718 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1719 {
1720     struct pcmcia_socket *s;
1721     config_t *c;
1722     int ret = CS_IN_USE, irq = 0;
1723
1724     if (CHECK_HANDLE(handle))
1725         return CS_BAD_HANDLE;
1726     s = SOCKET(handle);
1727     if (!(s->state & SOCKET_PRESENT))
1728         return CS_NO_CARD;
1729     c = CONFIG(handle);
1730     if (c->state & CONFIG_LOCKED)
1731         return CS_CONFIGURATION_LOCKED;
1732     if (c->state & CONFIG_IRQ_REQ)
1733         return CS_IN_USE;
1734
1735 #ifdef CONFIG_PCMCIA_PROBE
1736     if (s->irq.AssignedIRQ != 0) {
1737         /* If the interrupt is already assigned, it must match */
1738         irq = s->irq.AssignedIRQ;
1739         if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1740             u_int mask = req->IRQInfo2 & s->irq_mask;
1741             ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1742         } else
1743             ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1744     } else {
1745         if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1746             u_int try, mask = req->IRQInfo2 & s->irq_mask;
1747             for (try = 0; try < 2; try++) {
1748                 for (irq = 0; irq < 32; irq++)
1749                     if ((mask >> irq) & 1) {
1750                         ret = try_irq(req->Attributes, irq, try);
1751                         if (ret == 0) break;
1752                     }
1753                 if (ret == 0) break;
1754             }
1755         } else {
1756             irq = req->IRQInfo1 & IRQ_MASK;
1757             ret = try_irq(req->Attributes, irq, 1);
1758         }
1759     }
1760 #endif
1761     if (ret != 0) {
1762         if (!s->pci_irq)
1763             return ret;
1764         irq = s->pci_irq;
1765     }
1766
1767     if (req->Attributes & IRQ_HANDLE_PRESENT) {
1768         if (request_irq(irq, req->Handler,
1769                             ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1770                              (s->functions > 1) ||
1771                              (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1772                             handle->dev_info, req->Instance))
1773             return CS_IN_USE;
1774     }
1775
1776     c->irq.Attributes = req->Attributes;
1777     s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1778     s->irq.Config++;
1779
1780     c->state |= CONFIG_IRQ_REQ;
1781     handle->state |= CLIENT_IRQ_REQ;
1782     return CS_SUCCESS;
1783 } /* pcmcia_request_irq */
1784
1785 /*======================================================================
1786
1787     Request_window() establishes a mapping between card memory space
1788     and system memory space.
1789
1790 ======================================================================*/
1791
1792 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1793 {
1794     struct pcmcia_socket *s;
1795     window_t *win;
1796     u_long align;
1797     int w;
1798
1799     if (CHECK_HANDLE(*handle))
1800         return CS_BAD_HANDLE;
1801     s = (*handle)->Socket;
1802     if (!(s->state & SOCKET_PRESENT))
1803         return CS_NO_CARD;
1804     if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1805         return CS_BAD_ATTRIBUTE;
1806
1807     /* Window size defaults to smallest available */
1808     if (req->Size == 0)
1809         req->Size = s->map_size;
1810     align = (((s->features & SS_CAP_MEM_ALIGN) ||
1811               (req->Attributes & WIN_STRICT_ALIGN)) ?
1812              req->Size : s->map_size);
1813     if (req->Size & (s->map_size-1))
1814         return CS_BAD_SIZE;
1815     if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1816         (req->Base & (align-1)))
1817         return CS_BAD_BASE;
1818     if (req->Base)
1819         align = 0;
1820
1821     /* Allocate system memory window */
1822     for (w = 0; w < MAX_WIN; w++)
1823         if (!(s->state & SOCKET_WIN_REQ(w))) break;
1824     if (w == MAX_WIN)
1825         return CS_OUT_OF_RESOURCE;
1826
1827     win = &s->win[w];
1828     win->magic = WINDOW_MAGIC;
1829     win->index = w;
1830     win->handle = *handle;
1831     win->sock = s;
1832
1833     if (!(s->features & SS_CAP_STATIC_MAP)) {
1834         win->ctl.res = find_mem_region(req->Base, req->Size, align,
1835                                        (req->Attributes & WIN_MAP_BELOW_1MB),
1836                                        (*handle)->dev_info, s);
1837         if (!win->ctl.res)
1838             return CS_IN_USE;
1839     }
1840     (*handle)->state |= CLIENT_WIN_REQ(w);
1841
1842     /* Configure the socket controller */
1843     win->ctl.map = w+1;
1844     win->ctl.flags = 0;
1845     win->ctl.speed = req->AccessSpeed;
1846     if (req->Attributes & WIN_MEMORY_TYPE)
1847         win->ctl.flags |= MAP_ATTRIB;
1848     if (req->Attributes & WIN_ENABLE)
1849         win->ctl.flags |= MAP_ACTIVE;
1850     if (req->Attributes & WIN_DATA_WIDTH_16)
1851         win->ctl.flags |= MAP_16BIT;
1852     if (req->Attributes & WIN_USE_WAIT)
1853         win->ctl.flags |= MAP_USE_WAIT;
1854     win->ctl.card_start = 0;
1855     if (s->ops->set_mem_map(s, &win->ctl) != 0)
1856         return CS_BAD_ARGS;
1857     s->state |= SOCKET_WIN_REQ(w);
1858
1859     /* Return window handle */
1860     if (s->features & SS_CAP_STATIC_MAP) {
1861         req->Base = win->ctl.static_start;
1862     } else {
1863         req->Base = win->ctl.res->start;
1864     }
1865     *wh = win;
1866
1867     return CS_SUCCESS;
1868 } /* request_window */
1869
1870 /*======================================================================
1871
1872     I'm not sure which "reset" function this is supposed to use,
1873     but for now, it uses the low-level interface's reset, not the
1874     CIS register.
1875
1876 ======================================================================*/
1877
1878 int pccard_reset_card(struct pcmcia_socket *skt)
1879 {
1880         int ret;
1881
1882         cs_dbg(skt, 1, "resetting socket\n");
1883
1884         down(&skt->skt_sem);
1885         do {
1886                 if (!(skt->state & SOCKET_PRESENT)) {
1887                         ret = CS_NO_CARD;
1888                         break;
1889                 }
1890                 if (skt->state & SOCKET_SUSPEND) {
1891                         ret = CS_IN_USE;
1892                         break;
1893                 }
1894                 if (skt->state & SOCKET_CARDBUS) {
1895                         ret = CS_UNSUPPORTED_FUNCTION;
1896                         break;
1897                 }
1898
1899                 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1900                 if (ret == 0) {
1901                         send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1902                         if (socket_reset(skt) == CS_SUCCESS)
1903                                 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1904                 }
1905
1906                 ret = CS_SUCCESS;
1907         } while (0);
1908         up(&skt->skt_sem);
1909
1910         return ret;
1911 } /* reset_card */
1912 EXPORT_SYMBOL(pccard_reset_card);
1913
1914 /*======================================================================
1915
1916     These shut down or wake up a socket.  They are sort of user
1917     initiated versions of the APM suspend and resume actions.
1918
1919 ======================================================================*/
1920
1921 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1922 {
1923         int ret;
1924
1925         cs_dbg(skt, 1, "suspending socket\n");
1926
1927         down(&skt->skt_sem);
1928         do {
1929                 if (!(skt->state & SOCKET_PRESENT)) {
1930                         ret = CS_NO_CARD;
1931                         break;
1932                 }
1933                 if (skt->state & SOCKET_CARDBUS) {
1934                         ret = CS_UNSUPPORTED_FUNCTION;
1935                         break;
1936                 }
1937                 ret = socket_suspend(skt);
1938         } while (0);
1939         up(&skt->skt_sem);
1940
1941         return ret;
1942 } /* suspend_card */
1943
1944 int pcmcia_resume_card(struct pcmcia_socket *skt)
1945 {
1946         int ret;
1947
1948         cs_dbg(skt, 1, "waking up socket\n");
1949
1950         down(&skt->skt_sem);
1951         do {
1952                 if (!(skt->state & SOCKET_PRESENT)) {
1953                         ret = CS_NO_CARD;
1954                         break;
1955                 }
1956                 if (skt->state & SOCKET_CARDBUS) {
1957                         ret = CS_UNSUPPORTED_FUNCTION;
1958                         break;
1959                 }
1960                 ret = socket_resume(skt);
1961         } while (0);
1962         up(&skt->skt_sem);
1963
1964         return ret;
1965 } /* resume_card */
1966
1967 /*======================================================================
1968
1969     These handle user requests to eject or insert a card.
1970
1971 ======================================================================*/
1972
1973 int pcmcia_eject_card(struct pcmcia_socket *skt)
1974 {
1975         int ret;
1976
1977         cs_dbg(skt, 1, "user eject request\n");
1978
1979         down(&skt->skt_sem);
1980         do {
1981                 if (!(skt->state & SOCKET_PRESENT)) {
1982                         ret = -ENODEV;
1983                         break;
1984                 }
1985
1986                 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
1987                 if (ret != 0) {
1988                         ret = -EINVAL;
1989                         break;
1990                 }
1991
1992                 socket_remove(skt);
1993                 ret = 0;
1994         } while (0);
1995         up(&skt->skt_sem);
1996
1997         return ret;
1998 } /* eject_card */
1999
2000 int pcmcia_insert_card(struct pcmcia_socket *skt)
2001 {
2002         int ret;
2003
2004         cs_dbg(skt, 1, "user insert request\n");
2005
2006         down(&skt->skt_sem);
2007         do {
2008                 if (skt->state & SOCKET_PRESENT) {
2009                         ret = -EBUSY;
2010                         break;
2011                 }
2012                 if (socket_insert(skt) == CS_NO_CARD) {
2013                         ret = -ENODEV;
2014                         break;
2015                 }
2016                 ret = 0;
2017         } while (0);
2018         up(&skt->skt_sem);
2019
2020         return ret;
2021 } /* insert_card */
2022
2023 /*======================================================================
2024
2025     Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2026     haven't sent one to this client yet?
2027
2028 ======================================================================*/
2029
2030 #ifdef CONFIG_PCMCIA_OBSOLETE
2031 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2032 {
2033     u_int events, bit;
2034     if (CHECK_HANDLE(handle))
2035         return CS_BAD_HANDLE;
2036     if (handle->Attributes & CONF_EVENT_MASK_VALID)
2037         return CS_BAD_SOCKET;
2038     handle->EventMask = mask->EventMask;
2039     events = handle->PendingEvents & handle->EventMask;
2040     handle->PendingEvents -= events;
2041     while (events != 0) {
2042         bit = ((events ^ (events-1)) + 1) >> 1;
2043         EVENT(handle, bit, CS_EVENT_PRI_LOW);
2044         events -= bit;
2045     }
2046     return CS_SUCCESS;
2047 } /* set_event_mask */
2048 EXPORT_SYMBOL(pcmcia_set_event_mask);
2049
2050 #endif /* CONFIG_PCMCIA_OBSOLETE */
2051
2052 /*======================================================================
2053
2054     OS-specific module glue goes here
2055
2056 ======================================================================*/
2057 /* in alpha order */
2058 EXPORT_SYMBOL(pcmcia_deregister_client);
2059 EXPORT_SYMBOL(pcmcia_eject_card);
2060 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2061 EXPORT_SYMBOL(pcmcia_get_mem_page);
2062 EXPORT_SYMBOL(pcmcia_insert_card);
2063 EXPORT_SYMBOL(pcmcia_map_mem_page);
2064 EXPORT_SYMBOL(pcmcia_modify_configuration);
2065 EXPORT_SYMBOL(pcmcia_register_client);
2066 EXPORT_SYMBOL(pcmcia_release_configuration);
2067 EXPORT_SYMBOL(pcmcia_release_io);
2068 EXPORT_SYMBOL(pcmcia_release_irq);
2069 EXPORT_SYMBOL(pcmcia_release_window);
2070 EXPORT_SYMBOL(pcmcia_replace_cis);
2071 EXPORT_SYMBOL(pcmcia_request_configuration);
2072 EXPORT_SYMBOL(pcmcia_request_io);
2073 EXPORT_SYMBOL(pcmcia_request_irq);
2074 EXPORT_SYMBOL(pcmcia_request_window);
2075 EXPORT_SYMBOL(pcmcia_resume_card);
2076 EXPORT_SYMBOL(pcmcia_suspend_card);
2077
2078 EXPORT_SYMBOL(dead_socket);
2079 EXPORT_SYMBOL(pcmcia_parse_events);
2080
2081 struct class pcmcia_socket_class = {
2082         .name = "pcmcia_socket",
2083         .release = pcmcia_release_socket,
2084 };
2085 EXPORT_SYMBOL(pcmcia_socket_class);
2086
2087
2088 static int __init init_pcmcia_cs(void)
2089 {
2090         int ret;
2091         printk(KERN_INFO "%s\n", release);
2092         printk(KERN_INFO "  %s\n", options);
2093
2094         ret = class_register(&pcmcia_socket_class);
2095         if (ret)
2096                 return (ret);
2097         return class_interface_register(&pccard_sysfs_interface);
2098 }
2099
2100 static void __exit exit_pcmcia_cs(void)
2101 {
2102     printk(KERN_INFO "unloading Kernel Card Services\n");
2103     release_resource_db();
2104     class_interface_unregister(&pccard_sysfs_interface);
2105     class_unregister(&pcmcia_socket_class);
2106 }
2107
2108 subsys_initcall(init_pcmcia_cs);
2109 module_exit(exit_pcmcia_cs);
2110
2111 /*====================================================================*/
2112