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