drivers/pcmcia/cs.c

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