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