drivers/pcmcia/cs.c

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