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             s->io[i].res = find_io_region(*base, num, align, name, s);
 793             if (s->io[i].res) {
 794                 s->io[i].Attributes = attr;
 795                 s->io[i].BasePort = *base = s->io[i].res->start;
 796                 s->io[i].NumPorts = s->io[i].InUse = num;
 797                 break;
 798             } else
 799                 return 1;
 800         } else if (s->io[i].Attributes != attr)
 801             continue;
 802         /* Try to extend top of window */
 803         try = s->io[i].BasePort + s->io[i].NumPorts;
 804         if ((*base == 0) || (*base == try))
 805             if (adjust_io_region(s->io[i].res, s->io[i].res->start,
 806                                  s->io[i].res->end + num, s) == 0) {
 807                 *base = try;
 808                 s->io[i].NumPorts += num;
 809                 s->io[i].InUse += num;
 810                 break;
 811             }
 812         /* Try to extend bottom of window */
 813         try = s->io[i].BasePort - num;
 814         if ((*base == 0) || (*base == try))
 815             if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
 816                                  s->io[i].res->end, s) == 0) {
 817                 s->io[i].BasePort = *base = try;
 818                 s->io[i].NumPorts += num;
 819                 s->io[i].InUse += num;
 820                 break;
 821             }
 822     }
 823     return (i == MAX_IO_WIN);
 824 } /* alloc_io_space */
 825
 826 static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
 827                              ioaddr_t num)
 828 {
 829     int i;
 830
 831     for (i = 0; i < MAX_IO_WIN; i++) {
 832         if ((s->io[i].BasePort <= base) &&
 833             (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
 834             s->io[i].InUse -= num;
 835             /* Free the window if no one else is using it */
 836             if (s->io[i].InUse == 0) {
 837                 s->io[i].NumPorts = 0;
 838                 release_resource(s->io[i].res);
 839                 kfree(s->io[i].res);
 840                 s->io[i].res = NULL;
 841             }
 842         }
 843     }
 844 }
 845
 846 /*======================================================================
 847
 848     Access_configuration_register() reads and writes configuration
 849     registers in attribute memory.  Memory window 0 is reserved for
 850     this and the tuple reading services.
 851
 852 ======================================================================*/
 853
 854 int pcmcia_access_configuration_register(client_handle_t handle,
 855                                          conf_reg_t *reg)
 856 {
 857     struct pcmcia_socket *s;
 858     config_t *c;
 859     int addr;
 860     u_char val;
 861
 862     if (CHECK_HANDLE(handle))
 863         return CS_BAD_HANDLE;
 864     s = SOCKET(handle);
 865     if (handle->Function == BIND_FN_ALL) {
 866         if (reg->Function >= s->functions)
 867             return CS_BAD_ARGS;
 868         c = &s->config[reg->Function];
 869     } else
 870         c = CONFIG(handle);
 871
 872     if (c == NULL)
 873         return CS_NO_CARD;
 874
 875     if (!(c->state & CONFIG_LOCKED))
 876         return CS_CONFIGURATION_LOCKED;
 877
 878     addr = (c->ConfigBase + reg->Offset) >> 1;
 879
 880     switch (reg->Action) {
 881     case CS_READ:
 882         read_cis_mem(s, 1, addr, 1, &val);
 883         reg->Value = val;
 884         break;
 885     case CS_WRITE:
 886         val = reg->Value;
 887         write_cis_mem(s, 1, addr, 1, &val);
 888         break;
 889     default:
 890         return CS_BAD_ARGS;
 891         break;
 892     }
 893     return CS_SUCCESS;
 894 } /* access_configuration_register */
 895
 896
 897 /*====================================================================*/
 898
 899 int pcmcia_deregister_client(client_handle_t handle)
 900 {
 901     client_t **client;
 902     struct pcmcia_socket *s;
 903     memory_handle_t region;
 904     u_long flags;
 905     int i;
 906
 907     if (CHECK_HANDLE(handle))
 908         return CS_BAD_HANDLE;
 909
 910     s = SOCKET(handle);
 911     cs_dbg(s, 1, "deregister_client(%p)\n", handle);
 912
 913     if (handle->state &
 914         (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
 915         return CS_IN_USE;
 916     for (i = 0; i < MAX_WIN; i++)
 917         if (handle->state & CLIENT_WIN_REQ(i))
 918             return CS_IN_USE;
 919
 920     /* Disconnect all MTD links */
 921     if (handle->mtd_count) {
 922         for (region = s->a_region; region; region = region->info.next)
 923             if (region->mtd == handle) region->mtd = NULL;
 924         for (region = s->c_region; region; region = region->info.next)
 925             if (region->mtd == handle) region->mtd = NULL;
 926     }
 927
 928     if ((handle->state & CLIENT_STALE) ||
 929         (handle->Attributes & INFO_MASTER_CLIENT)) {
 930         spin_lock_irqsave(&s->lock, flags);
 931         client = &s->clients;
 932         while ((*client) && ((*client) != handle))
 933             client = &(*client)->next;
 934         if (*client == NULL) {
 935             spin_unlock_irqrestore(&s->lock, flags);
 936             return CS_BAD_HANDLE;
 937         }
 938         *client = handle->next;
 939         handle->client_magic = 0;
 940         kfree(handle);
 941         spin_unlock_irqrestore(&s->lock, flags);
 942     } else {
 943         handle->state = CLIENT_UNBOUND;
 944         handle->mtd_count = 0;
 945         handle->event_handler = NULL;
 946     }
 947
 948     return CS_SUCCESS;
 949 } /* deregister_client */
 950
 951 /*====================================================================*/
 952
 953 int pcmcia_get_configuration_info(client_handle_t handle,
 954                                   config_info_t *config)
 955 {
 956     struct pcmcia_socket *s;
 957     config_t *c;
 958
 959     if (CHECK_HANDLE(handle))
 960         return CS_BAD_HANDLE;
 961     s = SOCKET(handle);
 962     if (!(s->state & SOCKET_PRESENT))
 963         return CS_NO_CARD;
 964
 965     if (handle->Function == BIND_FN_ALL) {
 966         if (config->Function && (config->Function >= s->functions))
 967             return CS_BAD_ARGS;
 968     } else
 969         config->Function = handle->Function;
 970
 971 #ifdef CONFIG_CARDBUS
 972     if (s->state & SOCKET_CARDBUS) {
 973         u_char fn = config->Function;
 974         memset(config, 0, sizeof(config_info_t));
 975         config->Function = fn;
 976         config->Vcc = s->socket.Vcc;
 977         config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 978         config->Option = s->cb_dev->subordinate->number;
 979         if (s->state & SOCKET_CARDBUS_CONFIG) {
 980             config->Attributes = CONF_VALID_CLIENT;
 981             config->IntType = INT_CARDBUS;
 982             config->AssignedIRQ = s->irq.AssignedIRQ;
 983             if (config->AssignedIRQ)
 984                 config->Attributes |= CONF_ENABLE_IRQ;
 985             config->BasePort1 = s->io[0].BasePort;
 986             config->NumPorts1 = s->io[0].NumPorts;
 987         }
 988         return CS_SUCCESS;
 989     }
 990 #endif
 991
 992     c = (s->config != NULL) ? &s->config[config->Function] : NULL;
 993
 994     if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
 995         config->Attributes = 0;
 996         config->Vcc = s->socket.Vcc;
 997         config->Vpp1 = config->Vpp2 = s->socket.Vpp;
 998         return CS_SUCCESS;
 999     }
1000
1001     /* !!! This is a hack !!! */
1002     memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
1003     config->Attributes |= CONF_VALID_CLIENT;
1004     config->CardValues = c->CardValues;
1005     config->IRQAttributes = c->irq.Attributes;
1006     config->AssignedIRQ = s->irq.AssignedIRQ;
1007     config->BasePort1 = c->io.BasePort1;
1008     config->NumPorts1 = c->io.NumPorts1;
1009     config->Attributes1 = c->io.Attributes1;
1010     config->BasePort2 = c->io.BasePort2;
1011     config->NumPorts2 = c->io.NumPorts2;
1012     config->Attributes2 = c->io.Attributes2;
1013     config->IOAddrLines = c->io.IOAddrLines;
1014
1015     return CS_SUCCESS;
1016 } /* get_configuration_info */
1017
1018 /*======================================================================
1019
1020     Return information about this version of Card Services.
1021
1022 ======================================================================*/
1023
1024 int pcmcia_get_card_services_info(servinfo_t *info)
1025 {
1026     unsigned int socket_count = 0;
1027     struct list_head *tmp;
1028     info->Signature[0] = 'C';
1029     info->Signature[1] = 'S';
1030     down_read(&pcmcia_socket_list_rwsem);
1031     list_for_each(tmp, &pcmcia_socket_list)
1032             socket_count++;
1033     up_read(&pcmcia_socket_list_rwsem);
1034     info->Count = socket_count;
1035     info->Revision = CS_RELEASE_CODE;
1036     info->CSLevel = 0x0210;
1037     info->VendorString = (char *)release;
1038     return CS_SUCCESS;
1039 } /* get_card_services_info */
1040
1041 /*======================================================================
1042
1043     Note that get_first_client() *does* recognize the Socket field
1044     in the request structure.
1045
1046 ======================================================================*/
1047
1048 int pcmcia_get_first_client(client_handle_t *handle, client_req_t *req)
1049 {
1050     socket_t s;
1051     struct pcmcia_socket *socket;
1052     if (req->Attributes & CLIENT_THIS_SOCKET)
1053         s = req->Socket;
1054     else
1055         s = 0;
1056     socket = pcmcia_get_socket_by_nr(s);
1057     if (!socket)
1058         return CS_BAD_SOCKET;
1059     if (socket->clients == NULL)
1060         return CS_NO_MORE_ITEMS;
1061     *handle = socket->clients;
1062     return CS_SUCCESS;
1063 } /* get_first_client */
1064
1065 /*====================================================================*/
1066
1067 int pcmcia_get_next_client(client_handle_t *handle, client_req_t *req)
1068 {
1069     struct pcmcia_socket *s;
1070     if ((handle == NULL) || CHECK_HANDLE(*handle))
1071         return CS_BAD_HANDLE;
1072     if ((*handle)->next == NULL) {
1073         if (req->Attributes & CLIENT_THIS_SOCKET)
1074             return CS_NO_MORE_ITEMS;
1075         s = (*handle)->Socket;
1076         if (s->clients == NULL)
1077             return CS_NO_MORE_ITEMS;
1078         *handle = s->clients;
1079     } else
1080         *handle = (*handle)->next;
1081     return CS_SUCCESS;
1082 } /* get_next_client */
1083
1084 /*====================================================================*/
1085
1086 int pcmcia_get_window(window_handle_t *handle, int idx, win_req_t *req)
1087 {
1088     struct pcmcia_socket *s;
1089     window_t *win;
1090     int w;
1091
1092     if (idx == 0)
1093         s = ((client_handle_t)*handle)->Socket;
1094     else
1095         s = (*handle)->sock;
1096     if (!(s->state & SOCKET_PRESENT))
1097         return CS_NO_CARD;
1098     for (w = idx; w < MAX_WIN; w++)
1099         if (s->state & SOCKET_WIN_REQ(w)) break;
1100     if (w == MAX_WIN)
1101         return CS_NO_MORE_ITEMS;
1102     win = &s->win[w];
1103     req->Base = win->ctl.sys_start;
1104     req->Size = win->ctl.sys_stop - win->ctl.sys_start + 1;
1105     req->AccessSpeed = win->ctl.speed;
1106     req->Attributes = 0;
1107     if (win->ctl.flags & MAP_ATTRIB)
1108         req->Attributes |= WIN_MEMORY_TYPE_AM;
1109     if (win->ctl.flags & MAP_ACTIVE)
1110         req->Attributes |= WIN_ENABLE;
1111     if (win->ctl.flags & MAP_16BIT)
1112         req->Attributes |= WIN_DATA_WIDTH_16;
1113     if (win->ctl.flags & MAP_USE_WAIT)
1114         req->Attributes |= WIN_USE_WAIT;
1115     *handle = win;
1116     return CS_SUCCESS;
1117 } /* get_window */
1118
1119 int pcmcia_get_first_window(window_handle_t *win, win_req_t *req)
1120 {
1121     if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1122         return CS_BAD_HANDLE;
1123     return pcmcia_get_window(win, 0, req);
1124 }
1125
1126 int pcmcia_get_next_window(window_handle_t *win, win_req_t *req)
1127 {
1128     if ((win == NULL) || ((*win)->magic != WINDOW_MAGIC))
1129         return CS_BAD_HANDLE;
1130     return pcmcia_get_window(win, (*win)->index+1, req);
1131 }
1132
1133 /*=====================================================================
1134
1135     Return the PCI device associated with a card..
1136
1137 ======================================================================*/
1138
1139 #ifdef CONFIG_CARDBUS
1140
1141 struct pci_bus *pcmcia_lookup_bus(client_handle_t handle)
1142 {
1143         struct pcmcia_socket *s;
1144
1145         if (CHECK_HANDLE(handle))
1146                 return NULL;
1147         s = SOCKET(handle);
1148         if (!(s->state & SOCKET_CARDBUS))
1149                 return NULL;
1150
1151         return s->cb_dev->subordinate;
1152 }
1153
1154 EXPORT_SYMBOL(pcmcia_lookup_bus);
1155
1156 #endif
1157
1158 /*======================================================================
1159
1160     Get the current socket state bits.  We don't support the latched
1161     SocketState yet: I haven't seen any point for it.
1162
1163 ======================================================================*/
1164
1165 int pcmcia_get_status(client_handle_t handle, cs_status_t *status)
1166 {
1167     struct pcmcia_socket *s;
1168     config_t *c;
1169     int val;
1170
1171     if (CHECK_HANDLE(handle))
1172         return CS_BAD_HANDLE;
1173     s = SOCKET(handle);
1174     s->ops->get_status(s, &val);
1175     status->CardState = status->SocketState = 0;
1176     status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
1177     status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
1178     status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
1179     status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
1180     if (s->state & SOCKET_SUSPEND)
1181         status->CardState |= CS_EVENT_PM_SUSPEND;
1182     if (!(s->state & SOCKET_PRESENT))
1183         return CS_NO_CARD;
1184
1185     /* Get info from the PRR, if necessary */
1186     if (handle->Function == BIND_FN_ALL) {
1187         if (status->Function && (status->Function >= s->functions))
1188             return CS_BAD_ARGS;
1189         c = (s->config != NULL) ? &s->config[status->Function] : NULL;
1190     } else
1191         c = CONFIG(handle);
1192     if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
1193         (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
1194         u_char reg;
1195         if (c->Present & PRESENT_PIN_REPLACE) {
1196             read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
1197             status->CardState |=
1198                 (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
1199             status->CardState |=
1200                 (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
1201             status->CardState |=
1202                 (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
1203             status->CardState |=
1204                 (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
1205         } else {
1206             /* No PRR?  Then assume we're always ready */
1207             status->CardState |= CS_EVENT_READY_CHANGE;
1208         }
1209         if (c->Present & PRESENT_EXT_STATUS) {
1210             read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
1211             status->CardState |=
1212                 (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
1213         }
1214         return CS_SUCCESS;
1215     }
1216     status->CardState |=
1217         (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
1218     status->CardState |=
1219         (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
1220     status->CardState |=
1221         (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
1222     status->CardState |=
1223         (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
1224     return CS_SUCCESS;
1225 } /* get_status */
1226
1227 /*======================================================================
1228
1229     Change the card address of an already open memory window.
1230
1231 ======================================================================*/
1232
1233 int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
1234 {
1235     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1236         return CS_BAD_HANDLE;
1237     req->Page = 0;
1238     req->CardOffset = win->ctl.card_start;
1239     return CS_SUCCESS;
1240 } /* get_mem_page */
1241
1242 int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
1243 {
1244     struct pcmcia_socket *s;
1245     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1246         return CS_BAD_HANDLE;
1247     if (req->Page != 0)
1248         return CS_BAD_PAGE;
1249     s = win->sock;
1250     win->ctl.card_start = req->CardOffset;
1251     if (s->ops->set_mem_map(s, &win->ctl) != 0)
1252         return CS_BAD_OFFSET;
1253     return CS_SUCCESS;
1254 } /* map_mem_page */
1255
1256 /*======================================================================
1257
1258     Modify a locked socket configuration
1259
1260 ======================================================================*/
1261
1262 int pcmcia_modify_configuration(client_handle_t handle,
1263                                 modconf_t *mod)
1264 {
1265     struct pcmcia_socket *s;
1266     config_t *c;
1267
1268     if (CHECK_HANDLE(handle))
1269         return CS_BAD_HANDLE;
1270     s = SOCKET(handle); c = CONFIG(handle);
1271     if (!(s->state & SOCKET_PRESENT))
1272         return CS_NO_CARD;
1273     if (!(c->state & CONFIG_LOCKED))
1274         return CS_CONFIGURATION_LOCKED;
1275
1276     if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
1277         if (mod->Attributes & CONF_ENABLE_IRQ) {
1278             c->Attributes |= CONF_ENABLE_IRQ;
1279             s->socket.io_irq = s->irq.AssignedIRQ;
1280         } else {
1281             c->Attributes &= ~CONF_ENABLE_IRQ;
1282             s->socket.io_irq = 0;
1283         }
1284         s->ops->set_socket(s, &s->socket);
1285     }
1286
1287     if (mod->Attributes & CONF_VCC_CHANGE_VALID)
1288         return CS_BAD_VCC;
1289
1290     /* We only allow changing Vpp1 and Vpp2 to the same value */
1291     if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
1292         (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
1293         if (mod->Vpp1 != mod->Vpp2)
1294             return CS_BAD_VPP;
1295         c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
1296         if (s->ops->set_socket(s, &s->socket))
1297             return CS_BAD_VPP;
1298     } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
1299                (mod->Attributes & CONF_VPP2_CHANGE_VALID))
1300         return CS_BAD_VPP;
1301
1302     return CS_SUCCESS;
1303 } /* modify_configuration */
1304
1305 /*======================================================================
1306
1307     Modify the attributes of a window returned by RequestWindow.
1308
1309 ======================================================================*/
1310
1311 int pcmcia_modify_window(window_handle_t win, modwin_t *req)
1312 {
1313     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1314         return CS_BAD_HANDLE;
1315
1316     win->ctl.flags &= ~(MAP_ATTRIB|MAP_ACTIVE);
1317     if (req->Attributes & WIN_MEMORY_TYPE)
1318         win->ctl.flags |= MAP_ATTRIB;
1319     if (req->Attributes & WIN_ENABLE)
1320         win->ctl.flags |= MAP_ACTIVE;
1321     if (req->Attributes & WIN_DATA_WIDTH_16)
1322         win->ctl.flags |= MAP_16BIT;
1323     if (req->Attributes & WIN_USE_WAIT)
1324         win->ctl.flags |= MAP_USE_WAIT;
1325     win->ctl.speed = req->AccessSpeed;
1326     win->sock->ops->set_mem_map(win->sock, &win->ctl);
1327
1328     return CS_SUCCESS;
1329 } /* modify_window */
1330
1331 /*======================================================================
1332
1333     Register_client() uses the dev_info_t handle to match the
1334     caller with a socket.  The driver must have already been bound
1335     to a socket with bind_device() -- in fact, bind_device()
1336     allocates the client structure that will be used.
1337
1338 ======================================================================*/
1339
1340 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1341 {
1342     client_t *client = NULL;
1343     struct pcmcia_socket *s;
1344
1345     /* Look for unbound client with matching dev_info */
1346     down_read(&pcmcia_socket_list_rwsem);
1347     list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1348         client = s->clients;
1349         while (client != NULL) {
1350             if ((strcmp(client->dev_info, (char *)req->dev_info) == 0)
1351                 && (client->state & CLIENT_UNBOUND)) break;
1352             client = client->next;
1353         }
1354         if (client != NULL) break;
1355     }
1356     up_read(&pcmcia_socket_list_rwsem);
1357     if (client == NULL)
1358         return CS_OUT_OF_RESOURCE;
1359
1360     /*
1361      * Prevent this racing with a card insertion.
1362      */
1363     down(&s->skt_sem);
1364     *handle = client;
1365     client->state &= ~CLIENT_UNBOUND;
1366     client->Socket = s;
1367     client->Attributes = req->Attributes;
1368     client->EventMask = req->EventMask;
1369     client->event_handler = req->event_handler;
1370     client->event_callback_args = req->event_callback_args;
1371     client->event_callback_args.client_handle = client;
1372
1373     if (s->state & SOCKET_CARDBUS)
1374         client->state |= CLIENT_CARDBUS;
1375
1376     if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1377         (client->Function != BIND_FN_ALL)) {
1378         cistpl_longlink_mfc_t mfc;
1379         if (read_tuple(client, CISTPL_LONGLINK_MFC, &mfc)
1380             == CS_SUCCESS)
1381             s->functions = mfc.nfn;
1382         else
1383             s->functions = 1;
1384         s->config = kmalloc(sizeof(config_t) * s->functions,
1385                             GFP_KERNEL);
1386         if (!s->config)
1387                 goto out_no_resource;
1388         memset(s->config, 0, sizeof(config_t) * s->functions);
1389     }
1390
1391     cs_dbg(s, 1, "register_client(): client 0x%p, dev %s\n",
1392            client, client->dev_info);
1393     if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1394         EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1395
1396     if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1397         if (client->EventMask & CS_EVENT_CARD_INSERTION)
1398             EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1399         else
1400             client->PendingEvents |= CS_EVENT_CARD_INSERTION;
1401     }
1402
1403     up(&s->skt_sem);
1404     return CS_SUCCESS;
1405
1406  out_no_resource:
1407     up(&s->skt_sem);
1408     return CS_OUT_OF_RESOURCE;
1409 } /* register_client */
1410
1411 /*====================================================================*/
1412
1413 int pcmcia_release_configuration(client_handle_t handle)
1414 {
1415     pccard_io_map io = { 0, 0, 0, 0, 1 };
1416     struct pcmcia_socket *s;
1417     int i;
1418
1419     if (CHECK_HANDLE(handle) ||
1420         !(handle->state & CLIENT_CONFIG_LOCKED))
1421         return CS_BAD_HANDLE;
1422     handle->state &= ~CLIENT_CONFIG_LOCKED;
1423     s = SOCKET(handle);
1424
1425 #ifdef CONFIG_CARDBUS
1426     if (handle->state & CLIENT_CARDBUS)
1427         return CS_SUCCESS;
1428 #endif
1429
1430     if (!(handle->state & CLIENT_STALE)) {
1431         config_t *c = CONFIG(handle);
1432         if (--(s->lock_count) == 0) {
1433             s->socket.flags = SS_OUTPUT_ENA;   /* Is this correct? */
1434             s->socket.Vpp = 0;
1435             s->socket.io_irq = 0;
1436             s->ops->set_socket(s, &s->socket);
1437         }
1438         if (c->state & CONFIG_IO_REQ)
1439             for (i = 0; i < MAX_IO_WIN; i++) {
1440                 if (s->io[i].NumPorts == 0)
1441                     continue;
1442                 s->io[i].Config--;
1443                 if (s->io[i].Config != 0)
1444                     continue;
1445                 io.map = i;
1446                 s->ops->set_io_map(s, &io);
1447             }
1448         c->state &= ~CONFIG_LOCKED;
1449     }
1450
1451     return CS_SUCCESS;
1452 } /* release_configuration */
1453
1454 /*======================================================================
1455
1456     Release_io() releases the I/O ranges allocated by a client.  This
1457     may be invoked some time after a card ejection has already dumped
1458     the actual socket configuration, so if the client is "stale", we
1459     don't bother checking the port ranges against the current socket
1460     values.
1461
1462 ======================================================================*/
1463
1464 int pcmcia_release_io(client_handle_t handle, io_req_t *req)
1465 {
1466     struct pcmcia_socket *s;
1467
1468     if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
1469         return CS_BAD_HANDLE;
1470     handle->state &= ~CLIENT_IO_REQ;
1471     s = SOCKET(handle);
1472
1473 #ifdef CONFIG_CARDBUS
1474     if (handle->state & CLIENT_CARDBUS)
1475         return CS_SUCCESS;
1476 #endif
1477
1478     if (!(handle->state & CLIENT_STALE)) {
1479         config_t *c = CONFIG(handle);
1480         if (c->state & CONFIG_LOCKED)
1481             return CS_CONFIGURATION_LOCKED;
1482         if ((c->io.BasePort1 != req->BasePort1) ||
1483             (c->io.NumPorts1 != req->NumPorts1) ||
1484             (c->io.BasePort2 != req->BasePort2) ||
1485             (c->io.NumPorts2 != req->NumPorts2))
1486             return CS_BAD_ARGS;
1487         c->state &= ~CONFIG_IO_REQ;
1488     }
1489
1490     release_io_space(s, req->BasePort1, req->NumPorts1);
1491     if (req->NumPorts2)
1492         release_io_space(s, req->BasePort2, req->NumPorts2);
1493
1494     return CS_SUCCESS;
1495 } /* release_io */
1496
1497 /*====================================================================*/
1498
1499 int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
1500 {
1501     struct pcmcia_socket *s;
1502     if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
1503         return CS_BAD_HANDLE;
1504     handle->state &= ~CLIENT_IRQ_REQ;
1505     s = SOCKET(handle);
1506
1507     if (!(handle->state & CLIENT_STALE)) {
1508         config_t *c = CONFIG(handle);
1509         if (c->state & CONFIG_LOCKED)
1510             return CS_CONFIGURATION_LOCKED;
1511         if (c->irq.Attributes != req->Attributes)
1512             return CS_BAD_ATTRIBUTE;
1513         if (s->irq.AssignedIRQ != req->AssignedIRQ)
1514             return CS_BAD_IRQ;
1515         if (--s->irq.Config == 0) {
1516             c->state &= ~CONFIG_IRQ_REQ;
1517             s->irq.AssignedIRQ = 0;
1518         }
1519     }
1520
1521     if (req->Attributes & IRQ_HANDLE_PRESENT) {
1522         free_irq(req->AssignedIRQ, req->Instance);
1523     }
1524
1525 #ifdef CONFIG_PCMCIA_PROBE
1526     if (req->AssignedIRQ != s->pci_irq)
1527         undo_irq(req->Attributes, req->AssignedIRQ);
1528 #endif
1529
1530     return CS_SUCCESS;
1531 } /* cs_release_irq */
1532
1533 /*====================================================================*/
1534
1535 int pcmcia_release_window(window_handle_t win)
1536 {
1537     struct pcmcia_socket *s;
1538
1539     if ((win == NULL) || (win->magic != WINDOW_MAGIC))
1540         return CS_BAD_HANDLE;
1541     s = win->sock;
1542     if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
1543         return CS_BAD_HANDLE;
1544
1545     /* Shut down memory window */
1546     win->ctl.flags &= ~MAP_ACTIVE;
1547     s->ops->set_mem_map(s, &win->ctl);
1548     s->state &= ~SOCKET_WIN_REQ(win->index);
1549
1550     /* Release system memory */
1551     if(!(s->features & SS_CAP_STATIC_MAP))
1552         release_mem_region(win->base, win->size);
1553     win->handle->state &= ~CLIENT_WIN_REQ(win->index);
1554
1555     win->magic = 0;
1556
1557     return CS_SUCCESS;
1558 } /* release_window */
1559
1560 /*====================================================================*/
1561
1562 int pcmcia_request_configuration(client_handle_t handle,
1563                                  config_req_t *req)
1564 {
1565     int i;
1566     u_int base;
1567     struct pcmcia_socket *s;
1568     config_t *c;
1569     pccard_io_map iomap;
1570
1571     if (CHECK_HANDLE(handle))
1572         return CS_BAD_HANDLE;
1573     s = SOCKET(handle);
1574     if (!(s->state & SOCKET_PRESENT))
1575         return CS_NO_CARD;
1576
1577 #ifdef CONFIG_CARDBUS
1578     if (handle->state & CLIENT_CARDBUS)
1579         return CS_UNSUPPORTED_MODE;
1580 #endif
1581
1582     if (req->IntType & INT_CARDBUS)
1583         return CS_UNSUPPORTED_MODE;
1584     c = CONFIG(handle);
1585     if (c->state & CONFIG_LOCKED)
1586         return CS_CONFIGURATION_LOCKED;
1587
1588     /* Do power control.  We don't allow changes in Vcc. */
1589     if (s->socket.Vcc != req->Vcc)
1590         return CS_BAD_VCC;
1591     if (req->Vpp1 != req->Vpp2)
1592         return CS_BAD_VPP;
1593     s->socket.Vpp = req->Vpp1;
1594     if (s->ops->set_socket(s, &s->socket))
1595         return CS_BAD_VPP;
1596
1597     c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
1598
1599     /* Pick memory or I/O card, DMA mode, interrupt */
1600     c->IntType = req->IntType;
1601     c->Attributes = req->Attributes;
1602     if (req->IntType & INT_MEMORY_AND_IO)
1603         s->socket.flags |= SS_IOCARD;
1604     if (req->IntType & INT_ZOOMED_VIDEO)
1605         s->socket.flags |= SS_ZVCARD | SS_IOCARD;
1606     if (req->Attributes & CONF_ENABLE_DMA)
1607         s->socket.flags |= SS_DMA_MODE;
1608     if (req->Attributes & CONF_ENABLE_SPKR)
1609         s->socket.flags |= SS_SPKR_ENA;
1610     if (req->Attributes & CONF_ENABLE_IRQ)
1611         s->socket.io_irq = s->irq.AssignedIRQ;
1612     else
1613         s->socket.io_irq = 0;
1614     s->ops->set_socket(s, &s->socket);
1615     s->lock_count++;
1616
1617     /* Set up CIS configuration registers */
1618     base = c->ConfigBase = req->ConfigBase;
1619     c->Present = c->CardValues = req->Present;
1620     if (req->Present & PRESENT_COPY) {
1621         c->Copy = req->Copy;
1622         write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
1623     }
1624     if (req->Present & PRESENT_OPTION) {
1625         if (s->functions == 1) {
1626             c->Option = req->ConfigIndex & COR_CONFIG_MASK;
1627         } else {
1628             c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
1629             c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
1630             if (req->Present & PRESENT_IOBASE_0)
1631                 c->Option |= COR_ADDR_DECODE;
1632         }
1633         if (c->state & CONFIG_IRQ_REQ)
1634             if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
1635                 c->Option |= COR_LEVEL_REQ;
1636         write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
1637         mdelay(40);
1638     }
1639     if (req->Present & PRESENT_STATUS) {
1640         c->Status = req->Status;
1641         write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
1642     }
1643     if (req->Present & PRESENT_PIN_REPLACE) {
1644         c->Pin = req->Pin;
1645         write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
1646     }
1647     if (req->Present & PRESENT_EXT_STATUS) {
1648         c->ExtStatus = req->ExtStatus;
1649         write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
1650     }
1651     if (req->Present & PRESENT_IOBASE_0) {
1652         u_char b = c->io.BasePort1 & 0xff;
1653         write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
1654         b = (c->io.BasePort1 >> 8) & 0xff;
1655         write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
1656     }
1657     if (req->Present & PRESENT_IOSIZE) {
1658         u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
1659         write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
1660     }
1661
1662     /* Configure I/O windows */
1663     if (c->state & CONFIG_IO_REQ) {
1664         iomap.speed = io_speed;
1665         for (i = 0; i < MAX_IO_WIN; i++)
1666             if (s->io[i].NumPorts != 0) {
1667                 iomap.map = i;
1668                 iomap.flags = MAP_ACTIVE;
1669                 switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
1670                 case IO_DATA_PATH_WIDTH_16:
1671                     iomap.flags |= MAP_16BIT; break;
1672                 case IO_DATA_PATH_WIDTH_AUTO:
1673                     iomap.flags |= MAP_AUTOSZ; break;
1674                 default:
1675                     break;
1676                 }
1677                 iomap.start = s->io[i].BasePort;
1678                 iomap.stop = iomap.start + s->io[i].NumPorts - 1;
1679                 s->ops->set_io_map(s, &iomap);
1680                 s->io[i].Config++;
1681             }
1682     }
1683
1684     c->state |= CONFIG_LOCKED;
1685     handle->state |= CLIENT_CONFIG_LOCKED;
1686     return CS_SUCCESS;
1687 } /* request_configuration */
1688
1689 /*======================================================================
1690
1691     Request_io() reserves ranges of port addresses for a socket.
1692     I have not implemented range sharing or alias addressing.
1693
1694 ======================================================================*/
1695
1696 int pcmcia_request_io(client_handle_t handle, io_req_t *req)
1697 {
1698     struct pcmcia_socket *s;
1699     config_t *c;
1700
1701     if (CHECK_HANDLE(handle))
1702         return CS_BAD_HANDLE;
1703     s = SOCKET(handle);
1704     if (!(s->state & SOCKET_PRESENT))
1705         return CS_NO_CARD;
1706
1707     if (handle->state & CLIENT_CARDBUS) {
1708 #ifdef CONFIG_CARDBUS
1709         handle->state |= CLIENT_IO_REQ;
1710         return CS_SUCCESS;
1711 #else
1712         return CS_UNSUPPORTED_FUNCTION;
1713 #endif
1714     }
1715
1716     if (!req)
1717         return CS_UNSUPPORTED_MODE;
1718     c = CONFIG(handle);
1719     if (c->state & CONFIG_LOCKED)
1720         return CS_CONFIGURATION_LOCKED;
1721     if (c->state & CONFIG_IO_REQ)
1722         return CS_IN_USE;
1723     if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
1724         return CS_BAD_ATTRIBUTE;
1725     if ((req->NumPorts2 > 0) &&
1726         (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
1727         return CS_BAD_ATTRIBUTE;
1728
1729     if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
1730                        req->NumPorts1, req->IOAddrLines,
1731                        handle->dev_info))
1732         return CS_IN_USE;
1733
1734     if (req->NumPorts2) {
1735         if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
1736                            req->NumPorts2, req->IOAddrLines,
1737                            handle->dev_info)) {
1738             release_io_space(s, req->BasePort1, req->NumPorts1);
1739             return CS_IN_USE;
1740         }
1741     }
1742
1743     c->io = *req;
1744     c->state |= CONFIG_IO_REQ;
1745     handle->state |= CLIENT_IO_REQ;
1746     return CS_SUCCESS;
1747 } /* request_io */
1748
1749 /*======================================================================
1750
1751     Request_irq() reserves an irq for this client.
1752
1753     Also, since Linux only reserves irq's when they are actually
1754     hooked, we don't guarantee that an irq will still be available
1755     when the configuration is locked.  Now that I think about it,
1756     there might be a way to fix this using a dummy handler.
1757
1758 ======================================================================*/
1759
1760 int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
1761 {
1762     struct pcmcia_socket *s;
1763     config_t *c;
1764     int ret = CS_IN_USE, irq = 0;
1765
1766     if (CHECK_HANDLE(handle))
1767         return CS_BAD_HANDLE;
1768     s = SOCKET(handle);
1769     if (!(s->state & SOCKET_PRESENT))
1770         return CS_NO_CARD;
1771     c = CONFIG(handle);
1772     if (c->state & CONFIG_LOCKED)
1773         return CS_CONFIGURATION_LOCKED;
1774     if (c->state & CONFIG_IRQ_REQ)
1775         return CS_IN_USE;
1776
1777 #ifdef CONFIG_PCMCIA_PROBE
1778     if (s->irq.AssignedIRQ != 0) {
1779         /* If the interrupt is already assigned, it must match */
1780         irq = s->irq.AssignedIRQ;
1781         if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1782             u_int mask = req->IRQInfo2 & s->irq_mask;
1783             ret = ((mask >> irq) & 1) ? 0 : CS_BAD_ARGS;
1784         } else
1785             ret = ((req->IRQInfo1&IRQ_MASK) == irq) ? 0 : CS_BAD_ARGS;
1786     } else {
1787         if (req->IRQInfo1 & IRQ_INFO2_VALID) {
1788             u_int try, mask = req->IRQInfo2 & s->irq_mask;
1789             for (try = 0; try < 2; try++) {
1790                 for (irq = 0; irq < 32; irq++)
1791                     if ((mask >> irq) & 1) {
1792                         ret = try_irq(req->Attributes, irq, try);
1793                         if (ret == 0) break;
1794                     }
1795                 if (ret == 0) break;
1796             }
1797         } else {
1798             irq = req->IRQInfo1 & IRQ_MASK;
1799             ret = try_irq(req->Attributes, irq, 1);
1800         }
1801     }
1802 #endif
1803     if (ret != 0) {
1804         if (!s->pci_irq)
1805             return ret;
1806         irq = s->pci_irq;
1807     }
1808
1809     if (req->Attributes & IRQ_HANDLE_PRESENT) {
1810         if (request_irq(irq, req->Handler,
1811                             ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
1812                              (s->functions > 1) ||
1813                              (irq == s->pci_irq)) ? SA_SHIRQ : 0,
1814                             handle->dev_info, req->Instance))
1815             return CS_IN_USE;
1816     }
1817
1818     c->irq.Attributes = req->Attributes;
1819     s->irq.AssignedIRQ = req->AssignedIRQ = irq;
1820     s->irq.Config++;
1821
1822     c->state |= CONFIG_IRQ_REQ;
1823     handle->state |= CLIENT_IRQ_REQ;
1824     return CS_SUCCESS;
1825 } /* pcmcia_request_irq */
1826
1827 /*======================================================================
1828
1829     Request_window() establishes a mapping between card memory space
1830     and system memory space.
1831
1832 ======================================================================*/
1833
1834 int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
1835 {
1836     struct pcmcia_socket *s;
1837     window_t *win;
1838     u_long align;
1839     int w;
1840
1841     if (CHECK_HANDLE(*handle))
1842         return CS_BAD_HANDLE;
1843     s = (*handle)->Socket;
1844     if (!(s->state & SOCKET_PRESENT))
1845         return CS_NO_CARD;
1846     if (req->Attributes & (WIN_PAGED | WIN_SHARED))
1847         return CS_BAD_ATTRIBUTE;
1848
1849     /* Window size defaults to smallest available */
1850     if (req->Size == 0)
1851         req->Size = s->map_size;
1852     align = (((s->features & SS_CAP_MEM_ALIGN) ||
1853               (req->Attributes & WIN_STRICT_ALIGN)) ?
1854              req->Size : s->map_size);
1855     if (req->Size & (s->map_size-1))
1856         return CS_BAD_SIZE;
1857     if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
1858         (req->Base & (align-1)))
1859         return CS_BAD_BASE;
1860     if (req->Base)
1861         align = 0;
1862
1863     /* Allocate system memory window */
1864     for (w = 0; w < MAX_WIN; w++)
1865         if (!(s->state & SOCKET_WIN_REQ(w))) break;
1866     if (w == MAX_WIN)
1867         return CS_OUT_OF_RESOURCE;
1868
1869     win = &s->win[w];
1870     win->magic = WINDOW_MAGIC;
1871     win->index = w;
1872     win->handle = *handle;
1873     win->sock = s;
1874     win->base = req->Base;
1875     win->size = req->Size;
1876
1877     if (!(s->features & SS_CAP_STATIC_MAP) &&
1878         find_mem_region(&win->base, win->size, align,
1879                         (req->Attributes & WIN_MAP_BELOW_1MB),
1880                         (*handle)->dev_info, s))
1881         return CS_IN_USE;
1882     (*handle)->state |= CLIENT_WIN_REQ(w);
1883
1884     /* Configure the socket controller */
1885     win->ctl.map = w+1;
1886     win->ctl.flags = 0;
1887     win->ctl.speed = req->AccessSpeed;
1888     if (req->Attributes & WIN_MEMORY_TYPE)
1889         win->ctl.flags |= MAP_ATTRIB;
1890     if (req->Attributes & WIN_ENABLE)
1891         win->ctl.flags |= MAP_ACTIVE;
1892     if (req->Attributes & WIN_DATA_WIDTH_16)
1893         win->ctl.flags |= MAP_16BIT;
1894     if (req->Attributes & WIN_USE_WAIT)
1895         win->ctl.flags |= MAP_USE_WAIT;
1896     win->ctl.sys_start = win->base;
1897     win->ctl.sys_stop = win->base + win->size-1;
1898     win->ctl.card_start = 0;
1899     if (s->ops->set_mem_map(s, &win->ctl) != 0)
1900         return CS_BAD_ARGS;
1901     s->state |= SOCKET_WIN_REQ(w);
1902
1903     /* Return window handle */
1904     req->Base = win->ctl.sys_start;
1905     *wh = win;
1906
1907     return CS_SUCCESS;
1908 } /* request_window */
1909
1910 /*======================================================================
1911
1912     I'm not sure which "reset" function this is supposed to use,
1913     but for now, it uses the low-level interface's reset, not the
1914     CIS register.
1915
1916 ======================================================================*/
1917
1918 int pcmcia_reset_card(client_handle_t handle, client_req_t *req)
1919 {
1920         struct pcmcia_socket *skt;
1921         int ret;
1922
1923         if (CHECK_HANDLE(handle))
1924                 return CS_BAD_HANDLE;
1925         skt = SOCKET(handle);
1926         cs_dbg(skt, 1, "resetting socket\n");
1927
1928         down(&skt->skt_sem);
1929         do {
1930                 if (!(skt->state & SOCKET_PRESENT)) {
1931                         ret = CS_NO_CARD;
1932                         break;
1933                 }
1934                 if (skt->state & SOCKET_SUSPEND) {
1935                         ret = CS_IN_USE;
1936                         break;
1937                 }
1938                 if (skt->state & SOCKET_CARDBUS) {
1939                         ret = CS_UNSUPPORTED_FUNCTION;
1940                         break;
1941                 }
1942
1943                 ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
1944                 if (ret == 0) {
1945                         send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
1946                         if (socket_reset(skt) == CS_SUCCESS)
1947                                 send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
1948                 }
1949
1950                 handle->event_callback_args.info = (void *)(u_long)ret;
1951                 EVENT(handle, CS_EVENT_RESET_COMPLETE, CS_EVENT_PRI_LOW);
1952
1953                 ret = CS_SUCCESS;
1954         } while (0);
1955         up(&skt->skt_sem);
1956
1957         return ret;
1958 } /* reset_card */
1959
1960 /*======================================================================
1961
1962     These shut down or wake up a socket.  They are sort of user
1963     initiated versions of the APM suspend and resume actions.
1964
1965 ======================================================================*/
1966
1967 int pcmcia_suspend_card(struct pcmcia_socket *skt)
1968 {
1969         int ret;
1970
1971         cs_dbg(skt, 1, "suspending socket\n");
1972
1973         down(&skt->skt_sem);
1974         do {
1975                 if (!(skt->state & SOCKET_PRESENT)) {
1976                         ret = CS_NO_CARD;
1977                         break;
1978                 }
1979                 if (skt->state & SOCKET_CARDBUS) {
1980                         ret = CS_UNSUPPORTED_FUNCTION;
1981                         break;
1982                 }
1983                 ret = socket_suspend(skt);
1984         } while (0);
1985         up(&skt->skt_sem);
1986
1987         return ret;
1988 } /* suspend_card */
1989
1990 int pcmcia_resume_card(struct pcmcia_socket *skt)
1991 {
1992         int ret;
1993
1994         cs_dbg(skt, 1, "waking up socket\n");
1995
1996         down(&skt->skt_sem);
1997         do {
1998                 if (!(skt->state & SOCKET_PRESENT)) {
1999                         ret = CS_NO_CARD;
2000                         break;
2001                 }
2002                 if (skt->state & SOCKET_CARDBUS) {
2003                         ret = CS_UNSUPPORTED_FUNCTION;
2004                         break;
2005                 }
2006                 ret = socket_resume(skt);
2007         } while (0);
2008         up(&skt->skt_sem);
2009
2010         return ret;
2011 } /* resume_card */
2012
2013 /*======================================================================
2014
2015     These handle user requests to eject or insert a card.
2016
2017 ======================================================================*/
2018
2019 int pcmcia_eject_card(struct pcmcia_socket *skt)
2020 {
2021         int ret;
2022
2023         cs_dbg(skt, 1, "user eject request\n");
2024
2025         down(&skt->skt_sem);
2026         do {
2027                 if (!(skt->state & SOCKET_PRESENT)) {
2028                         ret = CS_NO_CARD;
2029                         break;
2030                 }
2031
2032                 ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
2033                 if (ret != 0)
2034                         break;
2035
2036                 socket_remove(skt);
2037                 ret = CS_SUCCESS;
2038         } while (0);
2039         up(&skt->skt_sem);
2040
2041         return ret;
2042 } /* eject_card */
2043
2044 int pcmcia_insert_card(struct pcmcia_socket *skt)
2045 {
2046         int ret;
2047
2048         cs_dbg(skt, 1, "user insert request\n");
2049
2050         down(&skt->skt_sem);
2051         do {
2052                 if (skt->state & SOCKET_PRESENT) {
2053                         ret = CS_IN_USE;
2054                         break;
2055                 }
2056                 if (socket_insert(skt) == CS_NO_CARD) {
2057                         ret = CS_NO_CARD;
2058                         break;
2059                 }
2060                 ret = CS_SUCCESS;
2061         } while (0);
2062         up(&skt->skt_sem);
2063
2064         return ret;
2065 } /* insert_card */
2066
2067 /*======================================================================
2068
2069     Maybe this should send a CS_EVENT_CARD_INSERTION event if we
2070     haven't sent one to this client yet?
2071
2072 ======================================================================*/
2073
2074 int pcmcia_set_event_mask(client_handle_t handle, eventmask_t *mask)
2075 {
2076     u_int events, bit;
2077     if (CHECK_HANDLE(handle))
2078         return CS_BAD_HANDLE;
2079     if (handle->Attributes & CONF_EVENT_MASK_VALID)
2080         return CS_BAD_SOCKET;
2081     handle->EventMask = mask->EventMask;
2082     events = handle->PendingEvents & handle->EventMask;
2083     handle->PendingEvents -= events;
2084     while (events != 0) {
2085         bit = ((events ^ (events-1)) + 1) >> 1;
2086         EVENT(handle, bit, CS_EVENT_PRI_LOW);
2087         events -= bit;
2088     }
2089     return CS_SUCCESS;
2090 } /* set_event_mask */
2091
2092 /*======================================================================
2093
2094     OS-specific module glue goes here
2095
2096 ======================================================================*/
2097 /* in alpha order */
2098 EXPORT_SYMBOL(pcmcia_access_configuration_register);
2099 EXPORT_SYMBOL(pcmcia_adjust_resource_info);
2100 EXPORT_SYMBOL(pcmcia_check_erase_queue);
2101 EXPORT_SYMBOL(pcmcia_close_memory);
2102 EXPORT_SYMBOL(pcmcia_copy_memory);
2103 EXPORT_SYMBOL(pcmcia_deregister_client);
2104 EXPORT_SYMBOL(pcmcia_deregister_erase_queue);
2105 EXPORT_SYMBOL(pcmcia_eject_card);
2106 EXPORT_SYMBOL(pcmcia_get_first_client);
2107 EXPORT_SYMBOL(pcmcia_get_card_services_info);
2108 EXPORT_SYMBOL(pcmcia_get_configuration_info);
2109 EXPORT_SYMBOL(pcmcia_get_mem_page);
2110 EXPORT_SYMBOL(pcmcia_get_next_client);
2111 EXPORT_SYMBOL(pcmcia_get_first_region);
2112 EXPORT_SYMBOL(pcmcia_get_first_tuple);
2113 EXPORT_SYMBOL(pcmcia_get_first_window);
2114 EXPORT_SYMBOL(pcmcia_get_next_region);
2115 EXPORT_SYMBOL(pcmcia_get_next_tuple);
2116 EXPORT_SYMBOL(pcmcia_get_next_window);
2117 EXPORT_SYMBOL(pcmcia_get_status);
2118 EXPORT_SYMBOL(pcmcia_get_tuple_data);
2119 EXPORT_SYMBOL(pcmcia_insert_card);
2120 EXPORT_SYMBOL(pcmcia_map_mem_page);
2121 EXPORT_SYMBOL(pcmcia_modify_configuration);
2122 EXPORT_SYMBOL(pcmcia_modify_window);
2123 EXPORT_SYMBOL(pcmcia_open_memory);
2124 EXPORT_SYMBOL(pcmcia_parse_tuple);
2125 EXPORT_SYMBOL(pcmcia_read_memory);
2126 EXPORT_SYMBOL(pcmcia_register_client);
2127 EXPORT_SYMBOL(pcmcia_register_erase_queue);
2128 EXPORT_SYMBOL(pcmcia_register_mtd);
2129 EXPORT_SYMBOL(pcmcia_release_configuration);
2130 EXPORT_SYMBOL(pcmcia_release_io);
2131 EXPORT_SYMBOL(pcmcia_release_irq);
2132 EXPORT_SYMBOL(pcmcia_release_window);
2133 EXPORT_SYMBOL(pcmcia_replace_cis);
2134 EXPORT_SYMBOL(pcmcia_request_configuration);
2135 EXPORT_SYMBOL(pcmcia_request_io);
2136 EXPORT_SYMBOL(pcmcia_request_irq);
2137 EXPORT_SYMBOL(pcmcia_request_window);
2138 EXPORT_SYMBOL(pcmcia_reset_card);
2139 EXPORT_SYMBOL(pcmcia_resume_card);
2140 EXPORT_SYMBOL(pcmcia_set_event_mask);
2141 EXPORT_SYMBOL(pcmcia_suspend_card);
2142 EXPORT_SYMBOL(pcmcia_validate_cis);
2143 EXPORT_SYMBOL(pcmcia_write_memory);
2144
2145 EXPORT_SYMBOL(dead_socket);
2146 EXPORT_SYMBOL(MTDHelperEntry);
2147 EXPORT_SYMBOL(pcmcia_parse_events);
2148
2149 struct class pcmcia_socket_class = {
2150         .name = "pcmcia_socket",
2151         .release = pcmcia_release_socket,
2152 };
2153 EXPORT_SYMBOL(pcmcia_socket_class);
2154
2155
2156 static int __init init_pcmcia_cs(void)
2157 {
2158     printk(KERN_INFO "%s\n", release);
2159     printk(KERN_INFO "  %s\n", options);
2160
2161     return class_register(&pcmcia_socket_class);
2162 }
2163
2164 static void __exit exit_pcmcia_cs(void)
2165 {
2166     printk(KERN_INFO "unloading Kernel Card Services\n");
2167     release_resource_db();
2168     class_unregister(&pcmcia_socket_class);
2169 }
2170
2171 subsys_initcall(init_pcmcia_cs);
2172 module_exit(exit_pcmcia_cs);
2173
2174 /*====================================================================*/
2175