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