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