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