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