git.oblomov.eu Git - linux-2.6/blob - drivers/pcmcia/ds.c

   1 /*
   2  * ds.c -- 16-bit PCMCIA core support
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * The initial developer of the original code is David A. Hinds
   9  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  10  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  11  *
  12  * (C) 1999             David A. Hinds
  13  * (C) 2003 - 2004      Dominik Brodowski
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/init.h>
  20 #include <linux/kernel.h>
  21 #include <linux/major.h>
  22 #include <linux/string.h>
  23 #include <linux/errno.h>
  24 #include <linux/slab.h>
  25 #include <linux/mm.h>
  26 #include <linux/fcntl.h>
  27 #include <linux/sched.h>
  28 #include <linux/smp_lock.h>
  29 #include <linux/timer.h>
  30 #include <linux/ioctl.h>
  31 #include <linux/proc_fs.h>
  32 #include <linux/poll.h>
  33 #include <linux/pci.h>
  34 #include <linux/list.h>
  35 #include <linux/delay.h>
  36 #include <linux/kref.h>
  37 #include <linux/workqueue.h>
  38 #include <linux/crc32.h>
  39 #include <linux/firmware.h>
  40
  41 #include <asm/atomic.h>
  42
  43 #define IN_CARD_SERVICES
  44 #include <pcmcia/version.h>
  45 #include <pcmcia/cs_types.h>
  46 #include <pcmcia/cs.h>
  47 #include <pcmcia/bulkmem.h>
  48 #include <pcmcia/cistpl.h>
  49 #include <pcmcia/ds.h>
  50 #include <pcmcia/ss.h>
  51
  52 #include "cs_internal.h"
  53
  54 /*====================================================================*/
  55
  56 /* Module parameters */
  57
  58 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  59 MODULE_DESCRIPTION("PCMCIA Driver Services");
  60 MODULE_LICENSE("GPL");
  61
  62 #ifdef DEBUG
  63 static int ds_pc_debug;
  64
  65 module_param_named(pc_debug, ds_pc_debug, int, 0644);
  66
  67 #define ds_dbg(lvl, fmt, arg...) do {                           \
  68         if (ds_pc_debug > (lvl))                                        \
  69                 printk(KERN_DEBUG "ds: " fmt , ## arg);         \
  70 } while (0)
  71 #else
  72 #define ds_dbg(lvl, fmt, arg...) do { } while (0)
  73 #endif
  74
  75 /*====================================================================*/
  76
  77 /* Device user information */
  78 #define MAX_EVENTS      32
  79 #define USER_MAGIC      0x7ea4
  80 #define CHECK_USER(u) \
  81     (((u) == NULL) || ((u)->user_magic != USER_MAGIC))
  82 typedef struct user_info_t {
  83     u_int               user_magic;
  84     int                 event_head, event_tail;
  85     event_t             event[MAX_EVENTS];
  86     struct user_info_t  *next;
  87     struct pcmcia_bus_socket *socket;
  88 } user_info_t;
  89
  90 /* Socket state information */
  91 struct pcmcia_bus_socket {
  92         struct kref             refcount;
  93         struct pcmcia_callback  callback;
  94         int                     state;
  95         user_info_t             *user;
  96         wait_queue_head_t       queue;
  97         struct pcmcia_socket    *parent;
  98
  99         /* the PCMCIA devices connected to this socket (normally one, more
 100          * for multifunction devices: */
 101         struct list_head        devices_list;
 102         u8                      device_count; /* the number of devices, used
 103                                                * only internally and subject
 104                                                * to incorrectness and change */
 105
 106         u8                      device_add_pending;
 107         struct work_struct      device_add;
 108 };
 109 static spinlock_t pcmcia_dev_list_lock;
 110
 111 static struct bus_type pcmcia_bus_type;
 112
 113 #define DS_SOCKET_PRESENT               0x01
 114 #define DS_SOCKET_BUSY                  0x02
 115 #define DS_SOCKET_REMOVAL_PENDING       0x10
 116 #define DS_SOCKET_DEAD                  0x80
 117
 118 /*====================================================================*/
 119
 120 static int major_dev = -1;
 121
 122 static int unbind_request(struct pcmcia_bus_socket *s);
 123
 124 /*====================================================================*/
 125
 126 /* code which was in cs.c before */
 127
 128 /* String tables for error messages */
 129
 130 typedef struct lookup_t {
 131     int key;
 132     char *msg;
 133 } lookup_t;
 134
 135 static const lookup_t error_table[] = {
 136     { CS_SUCCESS,               "Operation succeeded" },
 137     { CS_BAD_ADAPTER,           "Bad adapter" },
 138     { CS_BAD_ATTRIBUTE,         "Bad attribute", },
 139     { CS_BAD_BASE,              "Bad base address" },
 140     { CS_BAD_EDC,               "Bad EDC" },
 141     { CS_BAD_IRQ,               "Bad IRQ" },
 142     { CS_BAD_OFFSET,            "Bad offset" },
 143     { CS_BAD_PAGE,              "Bad page number" },
 144     { CS_READ_FAILURE,          "Read failure" },
 145     { CS_BAD_SIZE,              "Bad size" },
 146     { CS_BAD_SOCKET,            "Bad socket" },
 147     { CS_BAD_TYPE,              "Bad type" },
 148     { CS_BAD_VCC,               "Bad Vcc" },
 149     { CS_BAD_VPP,               "Bad Vpp" },
 150     { CS_BAD_WINDOW,            "Bad window" },
 151     { CS_WRITE_FAILURE,         "Write failure" },
 152     { CS_NO_CARD,               "No card present" },
 153     { CS_UNSUPPORTED_FUNCTION,  "Usupported function" },
 154     { CS_UNSUPPORTED_MODE,      "Unsupported mode" },
 155     { CS_BAD_SPEED,             "Bad speed" },
 156     { CS_BUSY,                  "Resource busy" },
 157     { CS_GENERAL_FAILURE,       "General failure" },
 158     { CS_WRITE_PROTECTED,       "Write protected" },
 159     { CS_BAD_ARG_LENGTH,        "Bad argument length" },
 160     { CS_BAD_ARGS,              "Bad arguments" },
 161     { CS_CONFIGURATION_LOCKED,  "Configuration locked" },
 162     { CS_IN_USE,                "Resource in use" },
 163     { CS_NO_MORE_ITEMS,         "No more items" },
 164     { CS_OUT_OF_RESOURCE,       "Out of resource" },
 165     { CS_BAD_HANDLE,            "Bad handle" },
 166     { CS_BAD_TUPLE,             "Bad CIS tuple" }
 167 };
 168
 169
 170 static const lookup_t service_table[] = {
 171     { AccessConfigurationRegister,      "AccessConfigurationRegister" },
 172     { AddSocketServices,                "AddSocketServices" },
 173     { AdjustResourceInfo,               "AdjustResourceInfo" },
 174     { CheckEraseQueue,                  "CheckEraseQueue" },
 175     { CloseMemory,                      "CloseMemory" },
 176     { DeregisterClient,                 "DeregisterClient" },
 177     { DeregisterEraseQueue,             "DeregisterEraseQueue" },
 178     { GetCardServicesInfo,              "GetCardServicesInfo" },
 179     { GetClientInfo,                    "GetClientInfo" },
 180     { GetConfigurationInfo,             "GetConfigurationInfo" },
 181     { GetEventMask,                     "GetEventMask" },
 182     { GetFirstClient,                   "GetFirstClient" },
 183     { GetFirstRegion,                   "GetFirstRegion" },
 184     { GetFirstTuple,                    "GetFirstTuple" },
 185     { GetNextClient,                    "GetNextClient" },
 186     { GetNextRegion,                    "GetNextRegion" },
 187     { GetNextTuple,                     "GetNextTuple" },
 188     { GetStatus,                        "GetStatus" },
 189     { GetTupleData,                     "GetTupleData" },
 190     { MapMemPage,                       "MapMemPage" },
 191     { ModifyConfiguration,              "ModifyConfiguration" },
 192     { ModifyWindow,                     "ModifyWindow" },
 193     { OpenMemory,                       "OpenMemory" },
 194     { ParseTuple,                       "ParseTuple" },
 195     { ReadMemory,                       "ReadMemory" },
 196     { RegisterClient,                   "RegisterClient" },
 197     { RegisterEraseQueue,               "RegisterEraseQueue" },
 198     { RegisterMTD,                      "RegisterMTD" },
 199     { ReleaseConfiguration,             "ReleaseConfiguration" },
 200     { ReleaseIO,                        "ReleaseIO" },
 201     { ReleaseIRQ,                       "ReleaseIRQ" },
 202     { ReleaseWindow,                    "ReleaseWindow" },
 203     { RequestConfiguration,             "RequestConfiguration" },
 204     { RequestIO,                        "RequestIO" },
 205     { RequestIRQ,                       "RequestIRQ" },
 206     { RequestSocketMask,                "RequestSocketMask" },
 207     { RequestWindow,                    "RequestWindow" },
 208     { ResetCard,                        "ResetCard" },
 209     { SetEventMask,                     "SetEventMask" },
 210     { ValidateCIS,                      "ValidateCIS" },
 211     { WriteMemory,                      "WriteMemory" },
 212     { BindDevice,                       "BindDevice" },
 213     { BindMTD,                          "BindMTD" },
 214     { ReportError,                      "ReportError" },
 215     { SuspendCard,                      "SuspendCard" },
 216     { ResumeCard,                       "ResumeCard" },
 217     { EjectCard,                        "EjectCard" },
 218     { InsertCard,                       "InsertCard" },
 219     { ReplaceCIS,                       "ReplaceCIS" }
 220 };
 221
 222
 223 static int pcmcia_report_error(client_handle_t handle, error_info_t *err)
 224 {
 225         int i;
 226         char *serv;
 227
 228         if (CHECK_HANDLE(handle))
 229                 printk(KERN_NOTICE);
 230         else {
 231                 struct pcmcia_device *p_dev = handle_to_pdev(handle);
 232                 printk(KERN_NOTICE "%s: ", p_dev->dev.bus_id);
 233         }
 234
 235         for (i = 0; i < ARRAY_SIZE(service_table); i++)
 236                 if (service_table[i].key == err->func)
 237                         break;
 238         if (i < ARRAY_SIZE(service_table))
 239                 serv = service_table[i].msg;
 240         else
 241                 serv = "Unknown service number";
 242
 243         for (i = 0; i < ARRAY_SIZE(error_table); i++)
 244                 if (error_table[i].key == err->retcode)
 245                         break;
 246         if (i < ARRAY_SIZE(error_table))
 247                 printk("%s: %s\n", serv, error_table[i].msg);
 248         else
 249                 printk("%s: Unknown error code %#x\n", serv, err->retcode);
 250
 251         return CS_SUCCESS;
 252 } /* report_error */
 253
 254 /* end of code which was in cs.c before */
 255
 256 /*======================================================================*/
 257
 258 void cs_error(client_handle_t handle, int func, int ret)
 259 {
 260         error_info_t err = { func, ret };
 261         pcmcia_report_error(handle, &err);
 262 }
 263 EXPORT_SYMBOL(cs_error);
 264
 265 #ifdef CONFIG_PCMCIA_DEBUG
 266
 267
 268 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
 269 {
 270         struct pcmcia_device_id *did = p_drv->id_table;
 271         unsigned int i;
 272         u32 hash;
 273
 274         while (did && did->match_flags) {
 275                 for (i=0; i<4; i++) {
 276                         if (!did->prod_id[i])
 277                                 continue;
 278
 279                         hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
 280                         if (hash == did->prod_id_hash[i])
 281                                 continue;
 282
 283                         printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
 284                                "product string \"%s\": is 0x%x, should "
 285                                "be 0x%x\n", p_drv->drv.name, did->prod_id[i],
 286                                did->prod_id_hash[i], hash);
 287                 }
 288                 did++;
 289         }
 290
 291         return;
 292 }
 293
 294 #else
 295 static inline void pcmcia_check_driver(struct pcmcia_driver *p_drv) {
 296         return;
 297 }
 298 #endif
 299
 300
 301 #ifdef CONFIG_PCMCIA_LOAD_CIS
 302
 303 /**
 304  * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
 305  * @dev - the pcmcia device which needs a CIS override
 306  * @filename - requested filename in /lib/firmware/cis/
 307  *
 308  * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
 309  * the one provided by the card is broken. The firmware files reside in
 310  * /lib/firmware/cis/ in userspace.
 311  */
 312 static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
 313 {
 314         struct pcmcia_socket *s = dev->socket;
 315         const struct firmware *fw;
 316         char path[20];
 317         int ret=-ENOMEM;
 318         cisdump_t *cis;
 319
 320         if (!filename)
 321                 return -EINVAL;
 322
 323         ds_dbg(1, "trying to load firmware %s\n", filename);
 324
 325         if (strlen(filename) > 14)
 326                 return -EINVAL;
 327
 328         snprintf(path, 20, "%s", filename);
 329
 330         if (request_firmware(&fw, path, &dev->dev) == 0) {
 331                 if (fw->size >= CISTPL_MAX_CIS_SIZE)
 332                         goto release;
 333
 334                 cis = kmalloc(sizeof(cisdump_t), GFP_KERNEL);
 335                 if (!cis)
 336                         goto release;
 337
 338                 memset(cis, 0, sizeof(cisdump_t));
 339
 340                 cis->Length = fw->size + 1;
 341                 memcpy(cis->Data, fw->data, fw->size);
 342
 343                 if (!pcmcia_replace_cis(s, cis))
 344                         ret = 0;
 345         }
 346  release:
 347         release_firmware(fw);
 348
 349         return (ret);
 350 }
 351
 352 #else /* !CONFIG_PCMCIA_LOAD_CIS */
 353
 354 static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
 355 {
 356         return -ENODEV;
 357 }
 358
 359 #endif
 360
 361
 362 /*======================================================================*/
 363
 364 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info);
 365 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr);
 366
 367 static void pcmcia_release_bus_socket(struct kref *refcount)
 368 {
 369         struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
 370         pcmcia_put_socket(s->parent);
 371         kfree(s);
 372 }
 373
 374 static void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
 375 {
 376         kref_put(&s->refcount, pcmcia_release_bus_socket);
 377 }
 378
 379 static struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
 380 {
 381         kref_get(&s->refcount);
 382         return (s);
 383 }
 384
 385 /**
 386  * pcmcia_register_driver - register a PCMCIA driver with the bus core
 387  *
 388  * Registers a PCMCIA driver with the PCMCIA bus core.
 389  */
 390 static int pcmcia_device_probe(struct device *dev);
 391 static int pcmcia_device_remove(struct device * dev);
 392
 393 int pcmcia_register_driver(struct pcmcia_driver *driver)
 394 {
 395         if (!driver)
 396                 return -EINVAL;
 397
 398         pcmcia_check_driver(driver);
 399
 400         /* initialize common fields */
 401         driver->drv.bus = &pcmcia_bus_type;
 402         driver->drv.owner = driver->owner;
 403         driver->drv.probe = pcmcia_device_probe;
 404         driver->drv.remove = pcmcia_device_remove;
 405
 406         return driver_register(&driver->drv);
 407 }
 408 EXPORT_SYMBOL(pcmcia_register_driver);
 409
 410 /**
 411  * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
 412  */
 413 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
 414 {
 415         driver_unregister(&driver->drv);
 416 }
 417 EXPORT_SYMBOL(pcmcia_unregister_driver);
 418
 419 #ifdef CONFIG_PROC_FS
 420 static struct proc_dir_entry *proc_pccard = NULL;
 421
 422 static int proc_read_drivers_callback(struct device_driver *driver, void *d)
 423 {
 424         char **p = d;
 425         struct pcmcia_driver *p_drv = container_of(driver,
 426                                                    struct pcmcia_driver, drv);
 427
 428         *p += sprintf(*p, "%-24.24s 1 %d\n", p_drv->drv.name,
 429 #ifdef CONFIG_MODULE_UNLOAD
 430                       (p_drv->owner) ? module_refcount(p_drv->owner) : 1
 431 #else
 432                       1
 433 #endif
 434         );
 435         d = (void *) p;
 436
 437         return 0;
 438 }
 439
 440 static int proc_read_drivers(char *buf, char **start, off_t pos,
 441                              int count, int *eof, void *data)
 442 {
 443         char *p = buf;
 444
 445         bus_for_each_drv(&pcmcia_bus_type, NULL,
 446                          (void *) &p, proc_read_drivers_callback);
 447
 448         return (p - buf);
 449 }
 450 #endif
 451
 452 /* pcmcia_device handling */
 453
 454 static struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev)
 455 {
 456         struct device *tmp_dev;
 457         tmp_dev = get_device(&p_dev->dev);
 458         if (!tmp_dev)
 459                 return NULL;
 460         return to_pcmcia_dev(tmp_dev);
 461 }
 462
 463 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
 464 {
 465         if (p_dev)
 466                 put_device(&p_dev->dev);
 467 }
 468
 469 static void pcmcia_release_dev(struct device *dev)
 470 {
 471         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 472         ds_dbg(1, "releasing dev %p\n", p_dev);
 473         pcmcia_put_bus_socket(p_dev->socket->pcmcia);
 474         kfree(p_dev);
 475 }
 476
 477
 478 static int pcmcia_device_probe(struct device * dev)
 479 {
 480         struct pcmcia_device *p_dev;
 481         struct pcmcia_driver *p_drv;
 482         int ret = 0;
 483
 484         dev = get_device(dev);
 485         if (!dev)
 486                 return -ENODEV;
 487
 488         p_dev = to_pcmcia_dev(dev);
 489         p_drv = to_pcmcia_drv(dev->driver);
 490
 491         if (!try_module_get(p_drv->owner)) {
 492                 ret = -EINVAL;
 493                 goto put_dev;
 494         }
 495
 496         if (p_drv->attach) {
 497                 p_dev->instance = p_drv->attach();
 498                 if ((!p_dev->instance) || (p_dev->client.state & CLIENT_UNBOUND)) {
 499                         printk(KERN_NOTICE "ds: unable to create instance "
 500                                "of '%s'!\n", p_drv->drv.name);
 501                         ret = -EINVAL;
 502                 }
 503         }
 504
 505         if (ret)
 506                 module_put(p_drv->owner);
 507  put_dev:
 508         if ((ret) || !(p_drv->attach))
 509                 put_device(dev);
 510         return (ret);
 511 }
 512
 513
 514 static int pcmcia_device_remove(struct device * dev)
 515 {
 516         struct pcmcia_device *p_dev;
 517         struct pcmcia_driver *p_drv;
 518
 519         /* detach the "instance" */
 520         p_dev = to_pcmcia_dev(dev);
 521         p_drv = to_pcmcia_drv(dev->driver);
 522
 523         if (p_drv) {
 524                 if ((p_drv->detach) && (p_dev->instance)) {
 525                         p_drv->detach(p_dev->instance);
 526                         /* from pcmcia_probe_device */
 527                         put_device(&p_dev->dev);
 528                 }
 529                 module_put(p_drv->owner);
 530         }
 531
 532         return 0;
 533 }
 534
 535
 536
 537 /*
 538  * pcmcia_device_query -- determine information about a pcmcia device
 539  */
 540 static int pcmcia_device_query(struct pcmcia_device *p_dev)
 541 {
 542         cistpl_manfid_t manf_id;
 543         cistpl_funcid_t func_id;
 544         cistpl_vers_1_t vers1;
 545         unsigned int i;
 546
 547         if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 548                                CISTPL_MANFID, &manf_id)) {
 549                 p_dev->manf_id = manf_id.manf;
 550                 p_dev->card_id = manf_id.card;
 551                 p_dev->has_manf_id = 1;
 552                 p_dev->has_card_id = 1;
 553         }
 554
 555         if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 556                                CISTPL_FUNCID, &func_id)) {
 557                 p_dev->func_id = func_id.func;
 558                 p_dev->has_func_id = 1;
 559         } else {
 560                 /* rule of thumb: cards with no FUNCID, but with
 561                  * common memory device geometry information, are
 562                  * probably memory cards (from pcmcia-cs) */
 563                 cistpl_device_geo_t devgeo;
 564                 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 565                                       CISTPL_DEVICE_GEO, &devgeo)) {
 566                         ds_dbg(0, "mem device geometry probably means "
 567                                "FUNCID_MEMORY\n");
 568                         p_dev->func_id = CISTPL_FUNCID_MEMORY;
 569                         p_dev->has_func_id = 1;
 570                 }
 571         }
 572
 573         if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_VERS_1,
 574                                &vers1)) {
 575                 for (i=0; i < vers1.ns; i++) {
 576                         char *tmp;
 577                         unsigned int length;
 578
 579                         tmp = vers1.str + vers1.ofs[i];
 580
 581                         length = strlen(tmp) + 1;
 582                         if ((length < 3) || (length > 255))
 583                                 continue;
 584
 585                         p_dev->prod_id[i] = kmalloc(sizeof(char) * length,
 586                                                     GFP_KERNEL);
 587                         if (!p_dev->prod_id[i])
 588                                 continue;
 589
 590                         p_dev->prod_id[i] = strncpy(p_dev->prod_id[i],
 591                                                     tmp, length);
 592                 }
 593         }
 594
 595         return 0;
 596 }
 597
 598
 599 /* device_add_lock is needed to avoid double registration by cardmgr and kernel.
 600  * Serializes pcmcia_device_add; will most likely be removed in future.
 601  *
 602  * While it has the caveat that adding new PCMCIA devices inside(!) device_register()
 603  * won't work, this doesn't matter much at the moment: the driver core doesn't
 604  * support it either.
 605  */
 606 static DECLARE_MUTEX(device_add_lock);
 607
 608 static struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function)
 609 {
 610         struct pcmcia_device *p_dev;
 611         unsigned long flags;
 612
 613         s = pcmcia_get_bus_socket(s);
 614         if (!s)
 615                 return NULL;
 616
 617         down(&device_add_lock);
 618
 619         /* max of 2 devices per card */
 620         if (s->device_count == 2)
 621                 goto err_put;
 622
 623         p_dev = kmalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
 624         if (!p_dev)
 625                 goto err_put;
 626         memset(p_dev, 0, sizeof(struct pcmcia_device));
 627
 628         p_dev->socket = s->parent;
 629         p_dev->device_no = (s->device_count++);
 630         p_dev->func   = function;
 631
 632         p_dev->dev.bus = &pcmcia_bus_type;
 633         p_dev->dev.parent = s->parent->dev.dev;
 634         p_dev->dev.release = pcmcia_release_dev;
 635         sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
 636
 637         /* compat */
 638         p_dev->client.client_magic = CLIENT_MAGIC;
 639         p_dev->client.Socket = s->parent;
 640         p_dev->client.Function = function;
 641         p_dev->client.state = CLIENT_UNBOUND;
 642
 643         /* Add to the list in pcmcia_bus_socket */
 644         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
 645         list_add_tail(&p_dev->socket_device_list, &s->devices_list);
 646         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 647
 648         pcmcia_device_query(p_dev);
 649
 650         if (device_register(&p_dev->dev)) {
 651                 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
 652                 list_del(&p_dev->socket_device_list);
 653                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 654
 655                 goto err_free;
 656        }
 657
 658         up(&device_add_lock);
 659
 660         return p_dev;
 661
 662  err_free:
 663         kfree(p_dev);
 664         s->device_count--;
 665  err_put:
 666         up(&device_add_lock);
 667         pcmcia_put_bus_socket(s);
 668
 669         return NULL;
 670 }
 671
 672
 673 static int pcmcia_card_add(struct pcmcia_socket *s)
 674 {
 675         cisinfo_t cisinfo;
 676         cistpl_longlink_mfc_t mfc;
 677         unsigned int no_funcs, i;
 678         int ret = 0;
 679
 680         if (!(s->resource_setup_done))
 681                 return -EAGAIN; /* try again, but later... */
 682
 683         pcmcia_validate_mem(s);
 684         ret = pccard_validate_cis(s, BIND_FN_ALL, &cisinfo);
 685         if (ret || !cisinfo.Chains) {
 686                 ds_dbg(0, "invalid CIS or invalid resources\n");
 687                 return -ENODEV;
 688         }
 689
 690         if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
 691                 no_funcs = mfc.nfn;
 692         else
 693                 no_funcs = 1;
 694
 695         /* this doesn't handle multifunction devices on one pcmcia function
 696          * yet. */
 697         for (i=0; i < no_funcs; i++)
 698                 pcmcia_device_add(s->pcmcia, i);
 699
 700         return (ret);
 701 }
 702
 703
 704 static void pcmcia_delayed_add_pseudo_device(void *data)
 705 {
 706         struct pcmcia_bus_socket *s = data;
 707         pcmcia_device_add(s, 0);
 708         s->device_add_pending = 0;
 709 }
 710
 711 static inline void pcmcia_add_pseudo_device(struct pcmcia_bus_socket *s)
 712 {
 713         if (!s->device_add_pending) {
 714                 schedule_work(&s->device_add);
 715                 s->device_add_pending = 1;
 716         }
 717         return;
 718 }
 719
 720 static int pcmcia_requery(struct device *dev, void * _data)
 721 {
 722         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 723         if (!p_dev->dev.driver)
 724                 pcmcia_device_query(p_dev);
 725
 726         return 0;
 727 }
 728
 729 static void pcmcia_bus_rescan(struct pcmcia_socket *skt)
 730 {
 731         int no_devices=0;
 732         unsigned long flags;
 733
 734         /* must be called with skt_sem held */
 735         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
 736         if (list_empty(&skt->pcmcia->devices_list))
 737                 no_devices=1;
 738         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
 739
 740         /* if no devices were added for this socket yet because of
 741          * missing resource information or other trouble, we need to
 742          * do this now. */
 743         if (no_devices) {
 744                 int ret = pcmcia_card_add(skt);
 745                 if (ret)
 746                         return;
 747         }
 748
 749         /* some device information might have changed because of a CIS
 750          * update or because we can finally read it correctly... so
 751          * determine it again, overwriting old values if necessary. */
 752         bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery);
 753
 754         /* we re-scan all devices, not just the ones connected to this
 755          * socket. This does not matter, though. */
 756         bus_rescan_devices(&pcmcia_bus_type);
 757 }
 758
 759 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 760                                   struct pcmcia_device_id *did)
 761 {
 762         if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
 763                 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
 764                         return 0;
 765         }
 766
 767         if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
 768                 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
 769                         return 0;
 770         }
 771
 772         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
 773                 if (dev->func != did->function)
 774                         return 0;
 775         }
 776
 777         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
 778                 if (!dev->prod_id[0])
 779                         return 0;
 780                 if (strcmp(did->prod_id[0], dev->prod_id[0]))
 781                         return 0;
 782         }
 783
 784         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
 785                 if (!dev->prod_id[1])
 786                         return 0;
 787                 if (strcmp(did->prod_id[1], dev->prod_id[1]))
 788                         return 0;
 789         }
 790
 791         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
 792                 if (!dev->prod_id[2])
 793                         return 0;
 794                 if (strcmp(did->prod_id[2], dev->prod_id[2]))
 795                         return 0;
 796         }
 797
 798         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
 799                 if (!dev->prod_id[3])
 800                         return 0;
 801                 if (strcmp(did->prod_id[3], dev->prod_id[3]))
 802                         return 0;
 803         }
 804
 805         if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
 806                 /* handle pseudo multifunction devices:
 807                  * there are at most two pseudo multifunction devices.
 808                  * if we're matching against the first, schedule a
 809                  * call which will then check whether there are two
 810                  * pseudo devices, and if not, add the second one.
 811                  */
 812                 if (dev->device_no == 0)
 813                         pcmcia_add_pseudo_device(dev->socket->pcmcia);
 814
 815                 if (dev->device_no != did->device_no)
 816                         return 0;
 817         }
 818
 819         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
 820                 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
 821                         return 0;
 822
 823                 /* if this is a pseudo-multi-function device,
 824                  * we need explicit matches */
 825                 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO)
 826                         return 0;
 827                 if (dev->device_no)
 828                         return 0;
 829
 830                 /* also, FUNC_ID matching needs to be activated by userspace
 831                  * after it has re-checked that there is no possible module
 832                  * with a prod_id/manf_id/card_id match.
 833                  */
 834                 if (!dev->allow_func_id_match)
 835                         return 0;
 836         }
 837
 838         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
 839                 if (!dev->socket->fake_cis)
 840                         pcmcia_load_firmware(dev, did->cisfile);
 841
 842                 if (!dev->socket->fake_cis)
 843                         return 0;
 844         }
 845
 846         if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
 847                 int i;
 848                 for (i=0; i<4; i++)
 849                         if (dev->prod_id[i])
 850                                 return 0;
 851                 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
 852                         return 0;
 853         }
 854
 855         dev->dev.driver_data = (void *) did;
 856
 857         return 1;
 858 }
 859
 860
 861 static int pcmcia_bus_match(struct device * dev, struct device_driver * drv) {
 862         struct pcmcia_device * p_dev = to_pcmcia_dev(dev);
 863         struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
 864         struct pcmcia_device_id *did = p_drv->id_table;
 865
 866         /* matching by cardmgr */
 867         if (p_dev->cardmgr == p_drv)
 868                 return 1;
 869
 870         while (did && did->match_flags) {
 871                 if (pcmcia_devmatch(p_dev, did))
 872                         return 1;
 873                 did++;
 874         }
 875
 876         return 0;
 877 }
 878
 879 #ifdef CONFIG_HOTPLUG
 880
 881 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
 882                               char *buffer, int buffer_size)
 883 {
 884         struct pcmcia_device *p_dev;
 885         int i, length = 0;
 886         u32 hash[4] = { 0, 0, 0, 0};
 887
 888         if (!dev)
 889                 return -ENODEV;
 890
 891         p_dev = to_pcmcia_dev(dev);
 892
 893         /* calculate hashes */
 894         for (i=0; i<4; i++) {
 895                 if (!p_dev->prod_id[i])
 896                         continue;
 897                 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
 898         }
 899
 900         i = 0;
 901
 902         if (add_hotplug_env_var(envp, num_envp, &i,
 903                                 buffer, buffer_size, &length,
 904                                 "SOCKET_NO=%u",
 905                                 p_dev->socket->sock))
 906                 return -ENOMEM;
 907
 908         if (add_hotplug_env_var(envp, num_envp, &i,
 909                                 buffer, buffer_size, &length,
 910                                 "DEVICE_NO=%02X",
 911                                 p_dev->device_no))
 912                 return -ENOMEM;
 913
 914         if (add_hotplug_env_var(envp, num_envp, &i,
 915                                 buffer, buffer_size, &length,
 916                                 "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
 917                                 "pa%08Xpb%08Xpc%08Xpd%08X",
 918                                 p_dev->has_manf_id ? p_dev->manf_id : 0,
 919                                 p_dev->has_card_id ? p_dev->card_id : 0,
 920                                 p_dev->has_func_id ? p_dev->func_id : 0,
 921                                 p_dev->func,
 922                                 p_dev->device_no,
 923                                 hash[0],
 924                                 hash[1],
 925                                 hash[2],
 926                                 hash[3]))
 927                 return -ENOMEM;
 928
 929         envp[i] = NULL;
 930
 931         return 0;
 932 }
 933
 934 #else
 935
 936 static int pcmcia_bus_hotplug(struct device *dev, char **envp, int num_envp,
 937                               char *buffer, int buffer_size)
 938 {
 939         return -ENODEV;
 940 }
 941
 942 #endif
 943
 944 /************************ per-device sysfs output ***************************/
 945
 946 #define pcmcia_device_attr(field, test, format)                         \
 947 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)              \
 948 {                                                                       \
 949         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
 950         return p_dev->test ? sprintf (buf, format, p_dev->field) : -ENODEV; \
 951 }
 952
 953 #define pcmcia_device_stringattr(name, field)                                   \
 954 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)               \
 955 {                                                                       \
 956         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
 957         return p_dev->field ? sprintf (buf, "%s\n", p_dev->field) : -ENODEV; \
 958 }
 959
 960 pcmcia_device_attr(func, socket, "0x%02x\n");
 961 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
 962 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
 963 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
 964 pcmcia_device_stringattr(prod_id1, prod_id[0]);
 965 pcmcia_device_stringattr(prod_id2, prod_id[1]);
 966 pcmcia_device_stringattr(prod_id3, prod_id[2]);
 967 pcmcia_device_stringattr(prod_id4, prod_id[3]);
 968
 969
 970 static ssize_t pcmcia_store_allow_func_id_match (struct device * dev, struct device_attribute *attr,
 971                                                  const char * buf, size_t count)
 972 {
 973         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 974         if (!count)
 975                 return -EINVAL;
 976
 977         down(&p_dev->socket->skt_sem);
 978         p_dev->allow_func_id_match = 1;
 979         up(&p_dev->socket->skt_sem);
 980
 981         bus_rescan_devices(&pcmcia_bus_type);
 982
 983         return count;
 984 }
 985
 986 static struct device_attribute pcmcia_dev_attrs[] = {
 987         __ATTR(function, 0444, func_show, NULL),
 988         __ATTR_RO(func_id),
 989         __ATTR_RO(manf_id),
 990         __ATTR_RO(card_id),
 991         __ATTR_RO(prod_id1),
 992         __ATTR_RO(prod_id2),
 993         __ATTR_RO(prod_id3),
 994         __ATTR_RO(prod_id4),
 995         __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match),
 996         __ATTR_NULL,
 997 };
 998
 999
1000 /*======================================================================
1001
1002     These manage a ring buffer of events pending for one user process
1003
1004 ======================================================================*/
1005
1006 static int queue_empty(user_info_t *user)
1007 {
1008     return (user->event_head == user->event_tail);
1009 }
1010
1011 static event_t get_queued_event(user_info_t *user)
1012 {
1013     user->event_tail = (user->event_tail+1) % MAX_EVENTS;
1014     return user->event[user->event_tail];
1015 }
1016
1017 static void queue_event(user_info_t *user, event_t event)
1018 {
1019     user->event_head = (user->event_head+1) % MAX_EVENTS;
1020     if (user->event_head == user->event_tail)
1021         user->event_tail = (user->event_tail+1) % MAX_EVENTS;
1022     user->event[user->event_head] = event;
1023 }
1024
1025 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
1026 {
1027     user_info_t *user;
1028     for (user = s->user; user; user = user->next)
1029         queue_event(user, event);
1030     wake_up_interruptible(&s->queue);
1031 }
1032
1033
1034 /*======================================================================
1035
1036     The card status event handler.
1037
1038 ======================================================================*/
1039
1040 struct send_event_data {
1041         struct pcmcia_socket *skt;
1042         event_t event;
1043         int priority;
1044 };
1045
1046 static int send_event_callback(struct device *dev, void * _data)
1047 {
1048         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1049         struct send_event_data *data = _data;
1050
1051         /* we get called for all sockets, but may only pass the event
1052          * for drivers _on the affected socket_ */
1053         if (p_dev->socket != data->skt)
1054                 return 0;
1055
1056         if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
1057                 return 0;
1058
1059         if (p_dev->client.EventMask & data->event)
1060                 return EVENT(&p_dev->client, data->event, data->priority);
1061
1062         return 0;
1063 }
1064
1065 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
1066 {
1067         int ret = 0;
1068         struct send_event_data private;
1069         struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
1070
1071         if (!skt)
1072                 return 0;
1073
1074         private.skt = s;
1075         private.event = event;
1076         private.priority = priority;
1077
1078         ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
1079
1080         pcmcia_put_bus_socket(skt);
1081         return ret;
1082 } /* send_event */
1083
1084
1085 /* Normally, the event is passed to individual drivers after
1086  * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
1087  * is inversed to maintain historic compatibility.
1088  */
1089
1090 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
1091 {
1092         struct pcmcia_bus_socket *s = skt->pcmcia;
1093         int ret = 0;
1094
1095         ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
1096                event, priority, s);
1097
1098         switch (event) {
1099
1100         case CS_EVENT_CARD_REMOVAL:
1101                 s->state &= ~DS_SOCKET_PRESENT;
1102                 send_event(skt, event, priority);
1103                 unbind_request(s);
1104                 handle_event(s, event);
1105                 break;
1106
1107         case CS_EVENT_CARD_INSERTION:
1108                 s->state |= DS_SOCKET_PRESENT;
1109                 pcmcia_card_add(skt);
1110                 handle_event(s, event);
1111                 break;
1112
1113         case CS_EVENT_EJECTION_REQUEST:
1114                 ret = send_event(skt, event, priority);
1115                 break;
1116
1117         default:
1118                 handle_event(s, event);
1119                 send_event(skt, event, priority);
1120                 break;
1121     }
1122
1123     return 0;
1124 } /* ds_event */
1125
1126
1127 /*======================================================================
1128
1129     bind_request() and bind_device() are merged by now. Register_client()
1130     is called right at the end of bind_request(), during the driver's
1131     ->attach() call. Individual descriptions:
1132
1133     bind_request() connects a socket to a particular client driver.
1134     It looks up the specified device ID in the list of registered
1135     drivers, binds it to the socket, and tries to create an instance
1136     of the device.  unbind_request() deletes a driver instance.
1137
1138     Bind_device() associates a device driver with a particular socket.
1139     It is normally called by Driver Services after it has identified
1140     a newly inserted card.  An instance of that driver will then be
1141     eligible to register as a client of this socket.
1142
1143     Register_client() uses the dev_info_t handle to match the
1144     caller with a socket.  The driver must have already been bound
1145     to a socket with bind_device() -- in fact, bind_device()
1146     allocates the client structure that will be used.
1147
1148 ======================================================================*/
1149
1150 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1151 {
1152         struct pcmcia_driver *p_drv;
1153         struct pcmcia_device *p_dev;
1154         int ret = 0;
1155         unsigned long flags;
1156
1157         s = pcmcia_get_bus_socket(s);
1158         if (!s)
1159                 return -EINVAL;
1160
1161         ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1162                (char *)bind_info->dev_info);
1163
1164         p_drv = get_pcmcia_driver(&bind_info->dev_info);
1165         if (!p_drv) {
1166                 ret = -EINVAL;
1167                 goto err_put;
1168         }
1169
1170         if (!try_module_get(p_drv->owner)) {
1171                 ret = -EINVAL;
1172                 goto err_put_driver;
1173         }
1174
1175         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1176         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1177                 if (p_dev->func == bind_info->function) {
1178                         if ((p_dev->dev.driver == &p_drv->drv)) {
1179                                 if (p_dev->cardmgr) {
1180                                         /* if there's already a device
1181                                          * registered, and it was registered
1182                                          * by userspace before, we need to
1183                                          * return the "instance". */
1184                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1185                                         bind_info->instance = p_dev->instance;
1186                                         ret = -EBUSY;
1187                                         goto err_put_module;
1188                                 } else {
1189                                         /* the correct driver managed to bind
1190                                          * itself magically to the correct
1191                                          * device. */
1192                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1193                                         p_dev->cardmgr = p_drv;
1194                                         ret = 0;
1195                                         goto err_put_module;
1196                                 }
1197                         } else if (!p_dev->dev.driver) {
1198                                 /* there's already a device available where
1199                                  * no device has been bound to yet. So we don't
1200                                  * need to register a device! */
1201                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1202                                 goto rescan;
1203                         }
1204                 }
1205         }
1206         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1207
1208         p_dev = pcmcia_device_add(s, bind_info->function);
1209         if (!p_dev) {
1210                 ret = -EIO;
1211                 goto err_put_module;
1212         }
1213
1214 rescan:
1215         p_dev->cardmgr = p_drv;
1216
1217         /* if a driver is already running, we can abort */
1218         if (p_dev->dev.driver)
1219                 goto err_put_module;
1220
1221         /*
1222          * Prevent this racing with a card insertion.
1223          */
1224         down(&s->parent->skt_sem);
1225         bus_rescan_devices(&pcmcia_bus_type);
1226         up(&s->parent->skt_sem);
1227
1228         /* check whether the driver indeed matched. I don't care if this
1229          * is racy or not, because it can only happen on cardmgr access
1230          * paths...
1231          */
1232         if (!(p_dev->dev.driver == &p_drv->drv))
1233                 p_dev->cardmgr = NULL;
1234
1235  err_put_module:
1236         module_put(p_drv->owner);
1237  err_put_driver:
1238         put_driver(&p_drv->drv);
1239  err_put:
1240         pcmcia_put_bus_socket(s);
1241
1242         return (ret);
1243 } /* bind_request */
1244
1245
1246 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1247 {
1248         client_t *client = NULL;
1249         struct pcmcia_socket *s;
1250         struct pcmcia_bus_socket *skt = NULL;
1251         struct pcmcia_device *p_dev = NULL;
1252
1253         /* Look for unbound client with matching dev_info */
1254         down_read(&pcmcia_socket_list_rwsem);
1255         list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1256                 unsigned long flags;
1257
1258                 if (s->state & SOCKET_CARDBUS)
1259                         continue;
1260
1261                 skt = s->pcmcia;
1262                 if (!skt)
1263                         continue;
1264                 skt = pcmcia_get_bus_socket(skt);
1265                 if (!skt)
1266                         continue;
1267                 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1268                 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1269                         struct pcmcia_driver *p_drv;
1270                         p_dev = pcmcia_get_dev(p_dev);
1271                         if (!p_dev)
1272                                 continue;
1273                         if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1274                             (!p_dev->dev.driver)) {
1275                                 pcmcia_put_dev(p_dev);
1276                                 continue;
1277                         }
1278                         p_drv = to_pcmcia_drv(p_dev->dev.driver);
1279                         if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1280                                 client = &p_dev->client;
1281                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1282                                 goto found;
1283                         }
1284                         pcmcia_put_dev(p_dev);
1285                 }
1286                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1287                 pcmcia_put_bus_socket(skt);
1288         }
1289  found:
1290         up_read(&pcmcia_socket_list_rwsem);
1291         if (!p_dev || !client)
1292                 return -ENODEV;
1293
1294         pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1295
1296         *handle = client;
1297         client->state &= ~CLIENT_UNBOUND;
1298         client->Socket = s;
1299         client->EventMask = req->EventMask;
1300         client->event_handler = req->event_handler;
1301         client->event_callback_args = req->event_callback_args;
1302         client->event_callback_args.client_handle = client;
1303
1304         if (s->state & SOCKET_CARDBUS)
1305                 client->state |= CLIENT_CARDBUS;
1306
1307         if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1308             (client->Function != BIND_FN_ALL)) {
1309                 cistpl_longlink_mfc_t mfc;
1310                 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1311                     == CS_SUCCESS)
1312                         s->functions = mfc.nfn;
1313                 else
1314                         s->functions = 1;
1315                 s->config = kmalloc(sizeof(config_t) * s->functions,
1316                                     GFP_KERNEL);
1317                 if (!s->config)
1318                         goto out_no_resource;
1319                 memset(s->config, 0, sizeof(config_t) * s->functions);
1320         }
1321
1322         ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1323                client, p_dev->dev.bus_id);
1324         if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1325                 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1326
1327         if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1328                 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1329                         EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1330         }
1331
1332         return CS_SUCCESS;
1333
1334  out_no_resource:
1335         pcmcia_put_dev(p_dev);
1336         return CS_OUT_OF_RESOURCE;
1337 } /* register_client */
1338 EXPORT_SYMBOL(pcmcia_register_client);
1339
1340
1341 /*====================================================================*/
1342
1343 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1344
1345 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1346 {
1347         dev_node_t *node;
1348         struct pcmcia_device *p_dev;
1349         unsigned long flags;
1350         int ret = 0;
1351
1352 #ifdef CONFIG_CARDBUS
1353         /*
1354          * Some unbelievably ugly code to associate the PCI cardbus
1355          * device and its driver with the PCMCIA "bind" information.
1356          */
1357         {
1358                 struct pci_bus *bus;
1359
1360                 bus = pcmcia_lookup_bus(s->parent);
1361                 if (bus) {
1362                         struct list_head *list;
1363                         struct pci_dev *dev = NULL;
1364
1365                         list = bus->devices.next;
1366                         while (list != &bus->devices) {
1367                                 struct pci_dev *pdev = pci_dev_b(list);
1368                                 list = list->next;
1369
1370                                 if (first) {
1371                                         dev = pdev;
1372                                         break;
1373                                 }
1374
1375                                 /* Try to handle "next" here some way? */
1376                         }
1377                         if (dev && dev->driver) {
1378                                 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1379                                 bind_info->major = 0;
1380                                 bind_info->minor = 0;
1381                                 bind_info->next = NULL;
1382                                 return 0;
1383                         }
1384                 }
1385         }
1386 #endif
1387
1388         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1389         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1390                 if (p_dev->func == bind_info->function) {
1391                         p_dev = pcmcia_get_dev(p_dev);
1392                         if (!p_dev)
1393                                 continue;
1394                         goto found;
1395                 }
1396         }
1397         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1398         return -ENODEV;
1399
1400  found:
1401         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1402
1403         if ((!p_dev->instance) ||
1404             (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1405                 ret = -EAGAIN;
1406                 goto err_put;
1407         }
1408
1409         if (first)
1410                 node = p_dev->instance->dev;
1411         else
1412                 for (node = p_dev->instance->dev; node; node = node->next)
1413                         if (node == bind_info->next)
1414                                 break;
1415         if (!node) {
1416                 ret = -ENODEV;
1417                 goto err_put;
1418         }
1419
1420         strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1421         bind_info->major = node->major;
1422         bind_info->minor = node->minor;
1423         bind_info->next = node->next;
1424
1425  err_put:
1426         pcmcia_put_dev(p_dev);
1427         return (ret);
1428 } /* get_device_info */
1429
1430 /*====================================================================*/
1431
1432 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1433  * drivers have been called with EVENT_CARD_REMOVAL before.
1434  */
1435 static int unbind_request(struct pcmcia_bus_socket *s)
1436 {
1437         struct pcmcia_device    *p_dev;
1438         unsigned long           flags;
1439
1440         ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1441
1442         s->device_count = 0;
1443
1444         for (;;) {
1445                 /* unregister all pcmcia_devices registered with this socket*/
1446                 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1447                 if (list_empty(&s->devices_list)) {
1448                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1449                         return 0;
1450                 }
1451                 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1452                 list_del(&p_dev->socket_device_list);
1453                 p_dev->client.state |= CLIENT_STALE;
1454                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1455
1456                 device_unregister(&p_dev->dev);
1457         }
1458
1459         return 0;
1460 } /* unbind_request */
1461
1462 int pcmcia_deregister_client(client_handle_t handle)
1463 {
1464         struct pcmcia_socket *s;
1465         int i;
1466         struct pcmcia_device *p_dev = handle_to_pdev(handle);
1467
1468         if (CHECK_HANDLE(handle))
1469                 return CS_BAD_HANDLE;
1470
1471         s = SOCKET(handle);
1472         ds_dbg(1, "deregister_client(%p)\n", handle);
1473
1474         if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1475                 goto warn_out;
1476         for (i = 0; i < MAX_WIN; i++)
1477                 if (handle->state & CLIENT_WIN_REQ(i))
1478                         goto warn_out;
1479
1480         if (handle->state & CLIENT_STALE) {
1481                 handle->client_magic = 0;
1482                 handle->state &= ~CLIENT_STALE;
1483                 pcmcia_put_dev(p_dev);
1484         } else {
1485                 handle->state = CLIENT_UNBOUND;
1486                 handle->event_handler = NULL;
1487         }
1488
1489         return CS_SUCCESS;
1490  warn_out:
1491         printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1492         return CS_IN_USE;
1493 } /* deregister_client */
1494 EXPORT_SYMBOL(pcmcia_deregister_client);
1495
1496
1497 /*======================================================================
1498
1499     The user-mode PC Card device interface
1500
1501 ======================================================================*/
1502
1503 static int ds_open(struct inode *inode, struct file *file)
1504 {
1505     socket_t i = iminor(inode);
1506     struct pcmcia_bus_socket *s;
1507     user_info_t *user;
1508
1509     ds_dbg(0, "ds_open(socket %d)\n", i);
1510
1511     s = get_socket_info_by_nr(i);
1512     if (!s)
1513             return -ENODEV;
1514     s = pcmcia_get_bus_socket(s);
1515     if (!s)
1516             return -ENODEV;
1517
1518     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1519             if (s->state & DS_SOCKET_BUSY) {
1520                     pcmcia_put_bus_socket(s);
1521                     return -EBUSY;
1522             }
1523         else
1524             s->state |= DS_SOCKET_BUSY;
1525     }
1526
1527     user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1528     if (!user) {
1529             pcmcia_put_bus_socket(s);
1530             return -ENOMEM;
1531     }
1532     user->event_tail = user->event_head = 0;
1533     user->next = s->user;
1534     user->user_magic = USER_MAGIC;
1535     user->socket = s;
1536     s->user = user;
1537     file->private_data = user;
1538
1539     if (s->state & DS_SOCKET_PRESENT)
1540         queue_event(user, CS_EVENT_CARD_INSERTION);
1541     return 0;
1542 } /* ds_open */
1543
1544 /*====================================================================*/
1545
1546 static int ds_release(struct inode *inode, struct file *file)
1547 {
1548     struct pcmcia_bus_socket *s;
1549     user_info_t *user, **link;
1550
1551     ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1552
1553     user = file->private_data;
1554     if (CHECK_USER(user))
1555         goto out;
1556
1557     s = user->socket;
1558
1559     /* Unlink user data structure */
1560     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1561         s->state &= ~DS_SOCKET_BUSY;
1562     }
1563     file->private_data = NULL;
1564     for (link = &s->user; *link; link = &(*link)->next)
1565         if (*link == user) break;
1566     if (link == NULL)
1567         goto out;
1568     *link = user->next;
1569     user->user_magic = 0;
1570     kfree(user);
1571     pcmcia_put_bus_socket(s);
1572 out:
1573     return 0;
1574 } /* ds_release */
1575
1576 /*====================================================================*/
1577
1578 static ssize_t ds_read(struct file *file, char __user *buf,
1579                        size_t count, loff_t *ppos)
1580 {
1581     struct pcmcia_bus_socket *s;
1582     user_info_t *user;
1583     int ret;
1584
1585     ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1586
1587     if (count < 4)
1588         return -EINVAL;
1589
1590     user = file->private_data;
1591     if (CHECK_USER(user))
1592         return -EIO;
1593
1594     s = user->socket;
1595     if (s->state & DS_SOCKET_DEAD)
1596         return -EIO;
1597
1598     ret = wait_event_interruptible(s->queue, !queue_empty(user));
1599     if (ret == 0)
1600         ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1601
1602     return ret;
1603 } /* ds_read */
1604
1605 /*====================================================================*/
1606
1607 static ssize_t ds_write(struct file *file, const char __user *buf,
1608                         size_t count, loff_t *ppos)
1609 {
1610     ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1611
1612     if (count != 4)
1613         return -EINVAL;
1614     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1615         return -EBADF;
1616
1617     return -EIO;
1618 } /* ds_write */
1619
1620 /*====================================================================*/
1621
1622 /* No kernel lock - fine */
1623 static u_int ds_poll(struct file *file, poll_table *wait)
1624 {
1625     struct pcmcia_bus_socket *s;
1626     user_info_t *user;
1627
1628     ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1629
1630     user = file->private_data;
1631     if (CHECK_USER(user))
1632         return POLLERR;
1633     s = user->socket;
1634     /*
1635      * We don't check for a dead socket here since that
1636      * will send cardmgr into an endless spin.
1637      */
1638     poll_wait(file, &s->queue, wait);
1639     if (!queue_empty(user))
1640         return POLLIN | POLLRDNORM;
1641     return 0;
1642 } /* ds_poll */
1643
1644 /*====================================================================*/
1645
1646 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1647
1648 static int ds_ioctl(struct inode * inode, struct file * file,
1649                     u_int cmd, u_long arg)
1650 {
1651     struct pcmcia_bus_socket *s;
1652     void __user *uarg = (char __user *)arg;
1653     u_int size;
1654     int ret, err;
1655     ds_ioctl_arg_t *buf;
1656     user_info_t *user;
1657
1658     ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1659
1660     user = file->private_data;
1661     if (CHECK_USER(user))
1662         return -EIO;
1663
1664     s = user->socket;
1665     if (s->state & DS_SOCKET_DEAD)
1666         return -EIO;
1667
1668     size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1669     if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1670
1671     /* Permission check */
1672     if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1673         return -EPERM;
1674
1675     if (cmd & IOC_IN) {
1676         if (!access_ok(VERIFY_READ, uarg, size)) {
1677             ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1678             return -EFAULT;
1679         }
1680     }
1681     if (cmd & IOC_OUT) {
1682         if (!access_ok(VERIFY_WRITE, uarg, size)) {
1683             ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1684             return -EFAULT;
1685         }
1686     }
1687     buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1688     if (!buf)
1689         return -ENOMEM;
1690
1691     err = ret = 0;
1692
1693     if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1694
1695     switch (cmd) {
1696     case DS_ADJUST_RESOURCE_INFO:
1697         ret = pcmcia_adjust_resource_info(&buf->adjust);
1698         break;
1699     case DS_GET_CARD_SERVICES_INFO:
1700         ret = pcmcia_get_card_services_info(&buf->servinfo);
1701         break;
1702     case DS_GET_CONFIGURATION_INFO:
1703         if (buf->config.Function &&
1704            (buf->config.Function >= s->parent->functions))
1705             ret = CS_BAD_ARGS;
1706         else
1707             ret = pccard_get_configuration_info(s->parent,
1708                         buf->config.Function, &buf->config);
1709         break;
1710     case DS_GET_FIRST_TUPLE:
1711         down(&s->parent->skt_sem);
1712         pcmcia_validate_mem(s->parent);
1713         up(&s->parent->skt_sem);
1714         ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1715         break;
1716     case DS_GET_NEXT_TUPLE:
1717         ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1718         break;
1719     case DS_GET_TUPLE_DATA:
1720         buf->tuple.TupleData = buf->tuple_parse.data;
1721         buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1722         ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1723         break;
1724     case DS_PARSE_TUPLE:
1725         buf->tuple.TupleData = buf->tuple_parse.data;
1726         ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1727         break;
1728     case DS_RESET_CARD:
1729         ret = pccard_reset_card(s->parent);
1730         break;
1731     case DS_GET_STATUS:
1732         if (buf->status.Function &&
1733            (buf->status.Function >= s->parent->functions))
1734             ret = CS_BAD_ARGS;
1735         else
1736         ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1737         break;
1738     case DS_VALIDATE_CIS:
1739         down(&s->parent->skt_sem);
1740         pcmcia_validate_mem(s->parent);
1741         up(&s->parent->skt_sem);
1742         ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1743         break;
1744     case DS_SUSPEND_CARD:
1745         ret = pcmcia_suspend_card(s->parent);
1746         break;
1747     case DS_RESUME_CARD:
1748         ret = pcmcia_resume_card(s->parent);
1749         break;
1750     case DS_EJECT_CARD:
1751         err = pcmcia_eject_card(s->parent);
1752         break;
1753     case DS_INSERT_CARD:
1754         err = pcmcia_insert_card(s->parent);
1755         break;
1756     case DS_ACCESS_CONFIGURATION_REGISTER:
1757         if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1758             err = -EPERM;
1759             goto free_out;
1760         }
1761         if (buf->conf_reg.Function &&
1762            (buf->conf_reg.Function >= s->parent->functions))
1763             ret = CS_BAD_ARGS;
1764         else
1765             ret = pccard_access_configuration_register(s->parent,
1766                         buf->conf_reg.Function, &buf->conf_reg);
1767         break;
1768     case DS_GET_FIRST_REGION:
1769     case DS_GET_NEXT_REGION:
1770     case DS_BIND_MTD:
1771         if (!capable(CAP_SYS_ADMIN)) {
1772                 err = -EPERM;
1773                 goto free_out;
1774         } else {
1775                 static int printed = 0;
1776                 if (!printed) {
1777                         printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1778                         printk(KERN_WARNING "MTD handling any more.\n");
1779                         printed++;
1780                 }
1781         }
1782         err = -EINVAL;
1783         goto free_out;
1784         break;
1785     case DS_GET_FIRST_WINDOW:
1786         ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1787                         &buf->win_info.window);
1788         break;
1789     case DS_GET_NEXT_WINDOW:
1790         ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1791                         buf->win_info.handle->index + 1, &buf->win_info.window);
1792         break;
1793     case DS_GET_MEM_PAGE:
1794         ret = pcmcia_get_mem_page(buf->win_info.handle,
1795                            &buf->win_info.map);
1796         break;
1797     case DS_REPLACE_CIS:
1798         ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1799         break;
1800     case DS_BIND_REQUEST:
1801         if (!capable(CAP_SYS_ADMIN)) {
1802                 err = -EPERM;
1803                 goto free_out;
1804         }
1805         err = bind_request(s, &buf->bind_info);
1806         break;
1807     case DS_GET_DEVICE_INFO:
1808         err = get_device_info(s, &buf->bind_info, 1);
1809         break;
1810     case DS_GET_NEXT_DEVICE:
1811         err = get_device_info(s, &buf->bind_info, 0);
1812         break;
1813     case DS_UNBIND_REQUEST:
1814         err = 0;
1815         break;
1816     default:
1817         err = -EINVAL;
1818     }
1819
1820     if ((err == 0) && (ret != CS_SUCCESS)) {
1821         ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1822         switch (ret) {
1823         case CS_BAD_SOCKET: case CS_NO_CARD:
1824             err = -ENODEV; break;
1825         case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1826         case CS_BAD_TUPLE:
1827             err = -EINVAL; break;
1828         case CS_IN_USE:
1829             err = -EBUSY; break;
1830         case CS_OUT_OF_RESOURCE:
1831             err = -ENOSPC; break;
1832         case CS_NO_MORE_ITEMS:
1833             err = -ENODATA; break;
1834         case CS_UNSUPPORTED_FUNCTION:
1835             err = -ENOSYS; break;
1836         default:
1837             err = -EIO; break;
1838         }
1839     }
1840
1841     if (cmd & IOC_OUT) {
1842         if (__copy_to_user(uarg, (char *)buf, size))
1843             err = -EFAULT;
1844     }
1845
1846 free_out:
1847     kfree(buf);
1848     return err;
1849 } /* ds_ioctl */
1850
1851 /*====================================================================*/
1852
1853 static struct file_operations ds_fops = {
1854         .owner          = THIS_MODULE,
1855         .open           = ds_open,
1856         .release        = ds_release,
1857         .ioctl          = ds_ioctl,
1858         .read           = ds_read,
1859         .write          = ds_write,
1860         .poll           = ds_poll,
1861 };
1862
1863 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1864 {
1865         struct pcmcia_socket *socket = class_get_devdata(class_dev);
1866         struct pcmcia_bus_socket *s;
1867         int ret;
1868
1869         s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1870         if(!s)
1871                 return -ENOMEM;
1872         memset(s, 0, sizeof(struct pcmcia_bus_socket));
1873
1874         /* get reference to parent socket */
1875         s->parent = pcmcia_get_socket(socket);
1876         if (!s->parent) {
1877                 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1878                 kfree (s);
1879                 return -ENODEV;
1880         }
1881
1882         kref_init(&s->refcount);
1883
1884         /*
1885          * Ugly. But we want to wait for the socket threads to have started up.
1886          * We really should let the drivers themselves drive some of this..
1887          */
1888         msleep(250);
1889
1890         init_waitqueue_head(&s->queue);
1891         INIT_LIST_HEAD(&s->devices_list);
1892         INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1893
1894         /* Set up hotline to Card Services */
1895         s->callback.owner = THIS_MODULE;
1896         s->callback.event = &ds_event;
1897         s->callback.requery = &pcmcia_bus_rescan;
1898         socket->pcmcia = s;
1899
1900         ret = pccard_register_pcmcia(socket, &s->callback);
1901         if (ret) {
1902                 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1903                 pcmcia_put_bus_socket(s);
1904                 socket->pcmcia = NULL;
1905                 return (ret);
1906         }
1907
1908         return 0;
1909 }
1910
1911
1912 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1913 {
1914         struct pcmcia_socket *socket = class_get_devdata(class_dev);
1915
1916         if (!socket || !socket->pcmcia)
1917                 return;
1918
1919         pccard_register_pcmcia(socket, NULL);
1920
1921         socket->pcmcia->state |= DS_SOCKET_DEAD;
1922         pcmcia_put_bus_socket(socket->pcmcia);
1923         socket->pcmcia = NULL;
1924
1925         return;
1926 }
1927
1928
1929 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1930 static struct class_interface pcmcia_bus_interface = {
1931         .class = &pcmcia_socket_class,
1932         .add = &pcmcia_bus_add_socket,
1933         .remove = &pcmcia_bus_remove_socket,
1934 };
1935
1936
1937 static struct bus_type pcmcia_bus_type = {
1938         .name = "pcmcia",
1939         .hotplug = pcmcia_bus_hotplug,
1940         .match = pcmcia_bus_match,
1941         .dev_attrs = pcmcia_dev_attrs,
1942 };
1943
1944
1945 static int __init init_pcmcia_bus(void)
1946 {
1947         int i;
1948
1949         spin_lock_init(&pcmcia_dev_list_lock);
1950
1951         bus_register(&pcmcia_bus_type);
1952         class_interface_register(&pcmcia_bus_interface);
1953
1954         /* Set up character device for user mode clients */
1955         i = register_chrdev(0, "pcmcia", &ds_fops);
1956         if (i < 0)
1957                 printk(KERN_NOTICE "unable to find a free device # for "
1958                        "Driver Services (error=%d)\n", i);
1959         else
1960                 major_dev = i;
1961
1962 #ifdef CONFIG_PROC_FS
1963         proc_pccard = proc_mkdir("pccard", proc_bus);
1964         if (proc_pccard)
1965                 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1966 #endif
1967
1968         return 0;
1969 }
1970 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1971                                * pcmcia_socket_class is already registered */
1972
1973
1974 static void __exit exit_pcmcia_bus(void)
1975 {
1976         class_interface_unregister(&pcmcia_bus_interface);
1977
1978 #ifdef CONFIG_PROC_FS
1979         if (proc_pccard) {
1980                 remove_proc_entry("drivers", proc_pccard);
1981                 remove_proc_entry("pccard", proc_bus);
1982         }
1983 #endif
1984         if (major_dev != -1)
1985                 unregister_chrdev(major_dev, "pcmcia");
1986
1987         bus_unregister(&pcmcia_bus_type);
1988 }
1989 module_exit(exit_pcmcia_bus);
1990
1991
1992
1993 /* helpers for backwards-compatible functions */
1994
1995 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1996 {
1997         struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1998         if (s && s->pcmcia)
1999                 return s->pcmcia;
2000         else
2001                 return NULL;
2002 }
2003
2004 /* backwards-compatible accessing of driver --- by name! */
2005
2006 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
2007 {
2008         struct device_driver *drv;
2009         struct pcmcia_driver *p_drv;
2010
2011         drv = driver_find((char *) dev_info, &pcmcia_bus_type);
2012         if (!drv)
2013                 return NULL;
2014
2015         p_drv = container_of(drv, struct pcmcia_driver, drv);
2016
2017         return (p_drv);
2018 }
2019
2020 MODULE_ALIAS("ds");