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
  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 static struct device_attribute pcmcia_dev_attrs[] = {
 873         __ATTR(function, 0444, func_show, NULL),
 874         __ATTR_RO(func_id),
 875         __ATTR_RO(manf_id),
 876         __ATTR_RO(card_id),
 877         __ATTR_RO(prod_id1),
 878         __ATTR_RO(prod_id2),
 879         __ATTR_RO(prod_id3),
 880         __ATTR_RO(prod_id4),
 881         __ATTR_NULL,
 882 };
 883
 884
 885 /*======================================================================
 886
 887     These manage a ring buffer of events pending for one user process
 888
 889 ======================================================================*/
 890
 891 static int queue_empty(user_info_t *user)
 892 {
 893     return (user->event_head == user->event_tail);
 894 }
 895
 896 static event_t get_queued_event(user_info_t *user)
 897 {
 898     user->event_tail = (user->event_tail+1) % MAX_EVENTS;
 899     return user->event[user->event_tail];
 900 }
 901
 902 static void queue_event(user_info_t *user, event_t event)
 903 {
 904     user->event_head = (user->event_head+1) % MAX_EVENTS;
 905     if (user->event_head == user->event_tail)
 906         user->event_tail = (user->event_tail+1) % MAX_EVENTS;
 907     user->event[user->event_head] = event;
 908 }
 909
 910 static void handle_event(struct pcmcia_bus_socket *s, event_t event)
 911 {
 912     user_info_t *user;
 913     for (user = s->user; user; user = user->next)
 914         queue_event(user, event);
 915     wake_up_interruptible(&s->queue);
 916 }
 917
 918
 919 /*======================================================================
 920
 921     The card status event handler.
 922
 923 ======================================================================*/
 924
 925 struct send_event_data {
 926         struct pcmcia_socket *skt;
 927         event_t event;
 928         int priority;
 929 };
 930
 931 static int send_event_callback(struct device *dev, void * _data)
 932 {
 933         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 934         struct send_event_data *data = _data;
 935
 936         /* we get called for all sockets, but may only pass the event
 937          * for drivers _on the affected socket_ */
 938         if (p_dev->socket != data->skt)
 939                 return 0;
 940
 941         if (p_dev->client.state & (CLIENT_UNBOUND|CLIENT_STALE))
 942                 return 0;
 943
 944         if (p_dev->client.EventMask & data->event)
 945                 return EVENT(&p_dev->client, data->event, data->priority);
 946
 947         return 0;
 948 }
 949
 950 static int send_event(struct pcmcia_socket *s, event_t event, int priority)
 951 {
 952         int ret = 0;
 953         struct send_event_data private;
 954         struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
 955
 956         if (!skt)
 957                 return 0;
 958
 959         private.skt = s;
 960         private.event = event;
 961         private.priority = priority;
 962
 963         ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
 964
 965         pcmcia_put_bus_socket(skt);
 966         return ret;
 967 } /* send_event */
 968
 969
 970 /* Normally, the event is passed to individual drivers after
 971  * informing userspace. Only for CS_EVENT_CARD_REMOVAL this
 972  * is inversed to maintain historic compatibility.
 973  */
 974
 975 static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
 976 {
 977         struct pcmcia_bus_socket *s = skt->pcmcia;
 978         int ret = 0;
 979
 980         ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
 981                event, priority, s);
 982
 983         switch (event) {
 984
 985         case CS_EVENT_CARD_REMOVAL:
 986                 s->state &= ~DS_SOCKET_PRESENT;
 987                 send_event(skt, event, priority);
 988                 unbind_request(s);
 989                 handle_event(s, event);
 990                 break;
 991
 992         case CS_EVENT_CARD_INSERTION:
 993                 s->state |= DS_SOCKET_PRESENT;
 994                 pcmcia_card_add(skt);
 995                 handle_event(s, event);
 996                 break;
 997
 998         case CS_EVENT_EJECTION_REQUEST:
 999                 ret = send_event(skt, event, priority);
1000                 break;
1001
1002         default:
1003                 handle_event(s, event);
1004                 send_event(skt, event, priority);
1005                 break;
1006     }
1007
1008     return 0;
1009 } /* ds_event */
1010
1011
1012 /*======================================================================
1013
1014     bind_request() and bind_device() are merged by now. Register_client()
1015     is called right at the end of bind_request(), during the driver's
1016     ->attach() call. Individual descriptions:
1017
1018     bind_request() connects a socket to a particular client driver.
1019     It looks up the specified device ID in the list of registered
1020     drivers, binds it to the socket, and tries to create an instance
1021     of the device.  unbind_request() deletes a driver instance.
1022
1023     Bind_device() associates a device driver with a particular socket.
1024     It is normally called by Driver Services after it has identified
1025     a newly inserted card.  An instance of that driver will then be
1026     eligible to register as a client of this socket.
1027
1028     Register_client() uses the dev_info_t handle to match the
1029     caller with a socket.  The driver must have already been bound
1030     to a socket with bind_device() -- in fact, bind_device()
1031     allocates the client structure that will be used.
1032
1033 ======================================================================*/
1034
1035 static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info)
1036 {
1037         struct pcmcia_driver *p_drv;
1038         struct pcmcia_device *p_dev;
1039         int ret = 0;
1040         unsigned long flags;
1041
1042         s = pcmcia_get_bus_socket(s);
1043         if (!s)
1044                 return -EINVAL;
1045
1046         ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock,
1047                (char *)bind_info->dev_info);
1048
1049         p_drv = get_pcmcia_driver(&bind_info->dev_info);
1050         if (!p_drv) {
1051                 ret = -EINVAL;
1052                 goto err_put;
1053         }
1054
1055         if (!try_module_get(p_drv->owner)) {
1056                 ret = -EINVAL;
1057                 goto err_put_driver;
1058         }
1059
1060         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1061         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1062                 if (p_dev->func == bind_info->function) {
1063                         if ((p_dev->dev.driver == &p_drv->drv)) {
1064                                 if (p_dev->cardmgr) {
1065                                         /* if there's already a device
1066                                          * registered, and it was registered
1067                                          * by userspace before, we need to
1068                                          * return the "instance". */
1069                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1070                                         bind_info->instance = p_dev->instance;
1071                                         ret = -EBUSY;
1072                                         goto err_put_module;
1073                                 } else {
1074                                         /* the correct driver managed to bind
1075                                          * itself magically to the correct
1076                                          * device. */
1077                                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1078                                         p_dev->cardmgr = p_drv;
1079                                         ret = 0;
1080                                         goto err_put_module;
1081                                 }
1082                         } else if (!p_dev->dev.driver) {
1083                                 /* there's already a device available where
1084                                  * no device has been bound to yet. So we don't
1085                                  * need to register a device! */
1086                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1087                                 goto rescan;
1088                         }
1089                 }
1090         }
1091         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1092
1093         p_dev = pcmcia_device_add(s, bind_info->function);
1094         if (!p_dev) {
1095                 ret = -EIO;
1096                 goto err_put_module;
1097         }
1098
1099 rescan:
1100         p_dev->cardmgr = p_drv;
1101
1102         /* if a driver is already running, we can abort */
1103         if (p_dev->dev.driver)
1104                 goto err_put_module;
1105
1106         /*
1107          * Prevent this racing with a card insertion.
1108          */
1109         down(&s->parent->skt_sem);
1110         bus_rescan_devices(&pcmcia_bus_type);
1111         up(&s->parent->skt_sem);
1112
1113         /* check whether the driver indeed matched. I don't care if this
1114          * is racy or not, because it can only happen on cardmgr access
1115          * paths...
1116          */
1117         if (!(p_dev->dev.driver == &p_drv->drv))
1118                 p_dev->cardmgr = NULL;
1119
1120  err_put_module:
1121         module_put(p_drv->owner);
1122  err_put_driver:
1123         put_driver(&p_drv->drv);
1124  err_put:
1125         pcmcia_put_bus_socket(s);
1126
1127         return (ret);
1128 } /* bind_request */
1129
1130
1131 int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
1132 {
1133         client_t *client = NULL;
1134         struct pcmcia_socket *s;
1135         struct pcmcia_bus_socket *skt = NULL;
1136         struct pcmcia_device *p_dev = NULL;
1137
1138         /* Look for unbound client with matching dev_info */
1139         down_read(&pcmcia_socket_list_rwsem);
1140         list_for_each_entry(s, &pcmcia_socket_list, socket_list) {
1141                 unsigned long flags;
1142
1143                 if (s->state & SOCKET_CARDBUS)
1144                         continue;
1145
1146                 skt = s->pcmcia;
1147                 if (!skt)
1148                         continue;
1149                 skt = pcmcia_get_bus_socket(skt);
1150                 if (!skt)
1151                         continue;
1152                 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1153                 list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) {
1154                         struct pcmcia_driver *p_drv;
1155                         p_dev = pcmcia_get_dev(p_dev);
1156                         if (!p_dev)
1157                                 continue;
1158                         if (!(p_dev->client.state & CLIENT_UNBOUND) ||
1159                             (!p_dev->dev.driver)) {
1160                                 pcmcia_put_dev(p_dev);
1161                                 continue;
1162                         }
1163                         p_drv = to_pcmcia_drv(p_dev->dev.driver);
1164                         if (!strncmp(p_drv->drv.name, (char *)req->dev_info, DEV_NAME_LEN)) {
1165                                 client = &p_dev->client;
1166                                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1167                                 goto found;
1168                         }
1169                         pcmcia_put_dev(p_dev);
1170                 }
1171                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1172                 pcmcia_put_bus_socket(skt);
1173         }
1174  found:
1175         up_read(&pcmcia_socket_list_rwsem);
1176         if (!p_dev || !client)
1177                 return -ENODEV;
1178
1179         pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */
1180
1181         *handle = client;
1182         client->state &= ~CLIENT_UNBOUND;
1183         client->Socket = s;
1184         client->EventMask = req->EventMask;
1185         client->event_handler = req->event_handler;
1186         client->event_callback_args = req->event_callback_args;
1187         client->event_callback_args.client_handle = client;
1188
1189         if (s->state & SOCKET_CARDBUS)
1190                 client->state |= CLIENT_CARDBUS;
1191
1192         if ((!(s->state & SOCKET_CARDBUS)) && (s->functions == 0) &&
1193             (client->Function != BIND_FN_ALL)) {
1194                 cistpl_longlink_mfc_t mfc;
1195                 if (pccard_read_tuple(s, client->Function, CISTPL_LONGLINK_MFC, &mfc)
1196                     == CS_SUCCESS)
1197                         s->functions = mfc.nfn;
1198                 else
1199                         s->functions = 1;
1200                 s->config = kmalloc(sizeof(config_t) * s->functions,
1201                                     GFP_KERNEL);
1202                 if (!s->config)
1203                         goto out_no_resource;
1204                 memset(s->config, 0, sizeof(config_t) * s->functions);
1205         }
1206
1207         ds_dbg(1, "register_client(): client 0x%p, dev %s\n",
1208                client, p_dev->dev.bus_id);
1209         if (client->EventMask & CS_EVENT_REGISTRATION_COMPLETE)
1210                 EVENT(client, CS_EVENT_REGISTRATION_COMPLETE, CS_EVENT_PRI_LOW);
1211
1212         if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) {
1213                 if (client->EventMask & CS_EVENT_CARD_INSERTION)
1214                         EVENT(client, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
1215         }
1216
1217         return CS_SUCCESS;
1218
1219  out_no_resource:
1220         pcmcia_put_dev(p_dev);
1221         return CS_OUT_OF_RESOURCE;
1222 } /* register_client */
1223 EXPORT_SYMBOL(pcmcia_register_client);
1224
1225
1226 /*====================================================================*/
1227
1228 extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
1229
1230 static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first)
1231 {
1232         dev_node_t *node;
1233         struct pcmcia_device *p_dev;
1234         unsigned long flags;
1235         int ret = 0;
1236
1237 #ifdef CONFIG_CARDBUS
1238         /*
1239          * Some unbelievably ugly code to associate the PCI cardbus
1240          * device and its driver with the PCMCIA "bind" information.
1241          */
1242         {
1243                 struct pci_bus *bus;
1244
1245                 bus = pcmcia_lookup_bus(s->parent);
1246                 if (bus) {
1247                         struct list_head *list;
1248                         struct pci_dev *dev = NULL;
1249
1250                         list = bus->devices.next;
1251                         while (list != &bus->devices) {
1252                                 struct pci_dev *pdev = pci_dev_b(list);
1253                                 list = list->next;
1254
1255                                 if (first) {
1256                                         dev = pdev;
1257                                         break;
1258                                 }
1259
1260                                 /* Try to handle "next" here some way? */
1261                         }
1262                         if (dev && dev->driver) {
1263                                 strlcpy(bind_info->name, dev->driver->name, DEV_NAME_LEN);
1264                                 bind_info->major = 0;
1265                                 bind_info->minor = 0;
1266                                 bind_info->next = NULL;
1267                                 return 0;
1268                         }
1269                 }
1270         }
1271 #endif
1272
1273         spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1274         list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
1275                 if (p_dev->func == bind_info->function) {
1276                         p_dev = pcmcia_get_dev(p_dev);
1277                         if (!p_dev)
1278                                 continue;
1279                         goto found;
1280                 }
1281         }
1282         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1283         return -ENODEV;
1284
1285  found:
1286         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1287
1288         if ((!p_dev->instance) ||
1289             (p_dev->instance->state & DEV_CONFIG_PENDING)) {
1290                 ret = -EAGAIN;
1291                 goto err_put;
1292         }
1293
1294         if (first)
1295                 node = p_dev->instance->dev;
1296         else
1297                 for (node = p_dev->instance->dev; node; node = node->next)
1298                         if (node == bind_info->next)
1299                                 break;
1300         if (!node) {
1301                 ret = -ENODEV;
1302                 goto err_put;
1303         }
1304
1305         strlcpy(bind_info->name, node->dev_name, DEV_NAME_LEN);
1306         bind_info->major = node->major;
1307         bind_info->minor = node->minor;
1308         bind_info->next = node->next;
1309
1310  err_put:
1311         pcmcia_put_dev(p_dev);
1312         return (ret);
1313 } /* get_device_info */
1314
1315 /*====================================================================*/
1316
1317 /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
1318  * drivers have been called with EVENT_CARD_REMOVAL before.
1319  */
1320 static int unbind_request(struct pcmcia_bus_socket *s)
1321 {
1322         struct pcmcia_device    *p_dev;
1323         unsigned long           flags;
1324
1325         ds_dbg(2, "unbind_request(%d)\n", s->parent->sock);
1326
1327         s->device_count = 0;
1328
1329         for (;;) {
1330                 /* unregister all pcmcia_devices registered with this socket*/
1331                 spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
1332                 if (list_empty(&s->devices_list)) {
1333                         spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1334                         return 0;
1335                 }
1336                 p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
1337                 list_del(&p_dev->socket_device_list);
1338                 p_dev->client.state |= CLIENT_STALE;
1339                 spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
1340
1341                 device_unregister(&p_dev->dev);
1342         }
1343
1344         return 0;
1345 } /* unbind_request */
1346
1347 int pcmcia_deregister_client(client_handle_t handle)
1348 {
1349         struct pcmcia_socket *s;
1350         int i;
1351         struct pcmcia_device *p_dev = handle_to_pdev(handle);
1352
1353         if (CHECK_HANDLE(handle))
1354                 return CS_BAD_HANDLE;
1355
1356         s = SOCKET(handle);
1357         ds_dbg(1, "deregister_client(%p)\n", handle);
1358
1359         if (handle->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
1360                 goto warn_out;
1361         for (i = 0; i < MAX_WIN; i++)
1362                 if (handle->state & CLIENT_WIN_REQ(i))
1363                         goto warn_out;
1364
1365         if (handle->state & CLIENT_STALE) {
1366                 handle->client_magic = 0;
1367                 handle->state &= ~CLIENT_STALE;
1368                 pcmcia_put_dev(p_dev);
1369         } else {
1370                 handle->state = CLIENT_UNBOUND;
1371                 handle->event_handler = NULL;
1372         }
1373
1374         return CS_SUCCESS;
1375  warn_out:
1376         printk(KERN_WARNING "ds: deregister_client was called too early.\n");
1377         return CS_IN_USE;
1378 } /* deregister_client */
1379 EXPORT_SYMBOL(pcmcia_deregister_client);
1380
1381
1382 /*======================================================================
1383
1384     The user-mode PC Card device interface
1385
1386 ======================================================================*/
1387
1388 static int ds_open(struct inode *inode, struct file *file)
1389 {
1390     socket_t i = iminor(inode);
1391     struct pcmcia_bus_socket *s;
1392     user_info_t *user;
1393
1394     ds_dbg(0, "ds_open(socket %d)\n", i);
1395
1396     s = get_socket_info_by_nr(i);
1397     if (!s)
1398             return -ENODEV;
1399     s = pcmcia_get_bus_socket(s);
1400     if (!s)
1401             return -ENODEV;
1402
1403     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1404             if (s->state & DS_SOCKET_BUSY) {
1405                     pcmcia_put_bus_socket(s);
1406                     return -EBUSY;
1407             }
1408         else
1409             s->state |= DS_SOCKET_BUSY;
1410     }
1411
1412     user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
1413     if (!user) {
1414             pcmcia_put_bus_socket(s);
1415             return -ENOMEM;
1416     }
1417     user->event_tail = user->event_head = 0;
1418     user->next = s->user;
1419     user->user_magic = USER_MAGIC;
1420     user->socket = s;
1421     s->user = user;
1422     file->private_data = user;
1423
1424     if (s->state & DS_SOCKET_PRESENT)
1425         queue_event(user, CS_EVENT_CARD_INSERTION);
1426     return 0;
1427 } /* ds_open */
1428
1429 /*====================================================================*/
1430
1431 static int ds_release(struct inode *inode, struct file *file)
1432 {
1433     struct pcmcia_bus_socket *s;
1434     user_info_t *user, **link;
1435
1436     ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
1437
1438     user = file->private_data;
1439     if (CHECK_USER(user))
1440         goto out;
1441
1442     s = user->socket;
1443
1444     /* Unlink user data structure */
1445     if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1446         s->state &= ~DS_SOCKET_BUSY;
1447     }
1448     file->private_data = NULL;
1449     for (link = &s->user; *link; link = &(*link)->next)
1450         if (*link == user) break;
1451     if (link == NULL)
1452         goto out;
1453     *link = user->next;
1454     user->user_magic = 0;
1455     kfree(user);
1456     pcmcia_put_bus_socket(s);
1457 out:
1458     return 0;
1459 } /* ds_release */
1460
1461 /*====================================================================*/
1462
1463 static ssize_t ds_read(struct file *file, char __user *buf,
1464                        size_t count, loff_t *ppos)
1465 {
1466     struct pcmcia_bus_socket *s;
1467     user_info_t *user;
1468     int ret;
1469
1470     ds_dbg(2, "ds_read(socket %d)\n", iminor(file->f_dentry->d_inode));
1471
1472     if (count < 4)
1473         return -EINVAL;
1474
1475     user = file->private_data;
1476     if (CHECK_USER(user))
1477         return -EIO;
1478
1479     s = user->socket;
1480     if (s->state & DS_SOCKET_DEAD)
1481         return -EIO;
1482
1483     ret = wait_event_interruptible(s->queue, !queue_empty(user));
1484     if (ret == 0)
1485         ret = put_user(get_queued_event(user), (int __user *)buf) ? -EFAULT : 4;
1486
1487     return ret;
1488 } /* ds_read */
1489
1490 /*====================================================================*/
1491
1492 static ssize_t ds_write(struct file *file, const char __user *buf,
1493                         size_t count, loff_t *ppos)
1494 {
1495     ds_dbg(2, "ds_write(socket %d)\n", iminor(file->f_dentry->d_inode));
1496
1497     if (count != 4)
1498         return -EINVAL;
1499     if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1500         return -EBADF;
1501
1502     return -EIO;
1503 } /* ds_write */
1504
1505 /*====================================================================*/
1506
1507 /* No kernel lock - fine */
1508 static u_int ds_poll(struct file *file, poll_table *wait)
1509 {
1510     struct pcmcia_bus_socket *s;
1511     user_info_t *user;
1512
1513     ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
1514
1515     user = file->private_data;
1516     if (CHECK_USER(user))
1517         return POLLERR;
1518     s = user->socket;
1519     /*
1520      * We don't check for a dead socket here since that
1521      * will send cardmgr into an endless spin.
1522      */
1523     poll_wait(file, &s->queue, wait);
1524     if (!queue_empty(user))
1525         return POLLIN | POLLRDNORM;
1526     return 0;
1527 } /* ds_poll */
1528
1529 /*====================================================================*/
1530
1531 extern int pcmcia_adjust_resource_info(adjust_t *adj);
1532
1533 static int ds_ioctl(struct inode * inode, struct file * file,
1534                     u_int cmd, u_long arg)
1535 {
1536     struct pcmcia_bus_socket *s;
1537     void __user *uarg = (char __user *)arg;
1538     u_int size;
1539     int ret, err;
1540     ds_ioctl_arg_t *buf;
1541     user_info_t *user;
1542
1543     ds_dbg(2, "ds_ioctl(socket %d, %#x, %#lx)\n", iminor(inode), cmd, arg);
1544
1545     user = file->private_data;
1546     if (CHECK_USER(user))
1547         return -EIO;
1548
1549     s = user->socket;
1550     if (s->state & DS_SOCKET_DEAD)
1551         return -EIO;
1552
1553     size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
1554     if (size > sizeof(ds_ioctl_arg_t)) return -EINVAL;
1555
1556     /* Permission check */
1557     if (!(cmd & IOC_OUT) && !capable(CAP_SYS_ADMIN))
1558         return -EPERM;
1559
1560     if (cmd & IOC_IN) {
1561         if (!access_ok(VERIFY_READ, uarg, size)) {
1562             ds_dbg(3, "ds_ioctl(): verify_read = %d\n", -EFAULT);
1563             return -EFAULT;
1564         }
1565     }
1566     if (cmd & IOC_OUT) {
1567         if (!access_ok(VERIFY_WRITE, uarg, size)) {
1568             ds_dbg(3, "ds_ioctl(): verify_write = %d\n", -EFAULT);
1569             return -EFAULT;
1570         }
1571     }
1572     buf = kmalloc(sizeof(ds_ioctl_arg_t), GFP_KERNEL);
1573     if (!buf)
1574         return -ENOMEM;
1575
1576     err = ret = 0;
1577
1578     if (cmd & IOC_IN) __copy_from_user((char *)buf, uarg, size);
1579
1580     switch (cmd) {
1581     case DS_ADJUST_RESOURCE_INFO:
1582         ret = pcmcia_adjust_resource_info(&buf->adjust);
1583         break;
1584     case DS_GET_CARD_SERVICES_INFO:
1585         ret = pcmcia_get_card_services_info(&buf->servinfo);
1586         break;
1587     case DS_GET_CONFIGURATION_INFO:
1588         if (buf->config.Function &&
1589            (buf->config.Function >= s->parent->functions))
1590             ret = CS_BAD_ARGS;
1591         else
1592             ret = pccard_get_configuration_info(s->parent,
1593                         buf->config.Function, &buf->config);
1594         break;
1595     case DS_GET_FIRST_TUPLE:
1596         down(&s->parent->skt_sem);
1597         pcmcia_validate_mem(s->parent);
1598         up(&s->parent->skt_sem);
1599         ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1600         break;
1601     case DS_GET_NEXT_TUPLE:
1602         ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
1603         break;
1604     case DS_GET_TUPLE_DATA:
1605         buf->tuple.TupleData = buf->tuple_parse.data;
1606         buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
1607         ret = pccard_get_tuple_data(s->parent, &buf->tuple);
1608         break;
1609     case DS_PARSE_TUPLE:
1610         buf->tuple.TupleData = buf->tuple_parse.data;
1611         ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
1612         break;
1613     case DS_RESET_CARD:
1614         ret = pccard_reset_card(s->parent);
1615         break;
1616     case DS_GET_STATUS:
1617         if (buf->status.Function &&
1618            (buf->status.Function >= s->parent->functions))
1619             ret = CS_BAD_ARGS;
1620         else
1621         ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
1622         break;
1623     case DS_VALIDATE_CIS:
1624         down(&s->parent->skt_sem);
1625         pcmcia_validate_mem(s->parent);
1626         up(&s->parent->skt_sem);
1627         ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
1628         break;
1629     case DS_SUSPEND_CARD:
1630         ret = pcmcia_suspend_card(s->parent);
1631         break;
1632     case DS_RESUME_CARD:
1633         ret = pcmcia_resume_card(s->parent);
1634         break;
1635     case DS_EJECT_CARD:
1636         err = pcmcia_eject_card(s->parent);
1637         break;
1638     case DS_INSERT_CARD:
1639         err = pcmcia_insert_card(s->parent);
1640         break;
1641     case DS_ACCESS_CONFIGURATION_REGISTER:
1642         if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
1643             err = -EPERM;
1644             goto free_out;
1645         }
1646         if (buf->conf_reg.Function &&
1647            (buf->conf_reg.Function >= s->parent->functions))
1648             ret = CS_BAD_ARGS;
1649         else
1650             ret = pccard_access_configuration_register(s->parent,
1651                         buf->conf_reg.Function, &buf->conf_reg);
1652         break;
1653     case DS_GET_FIRST_REGION:
1654     case DS_GET_NEXT_REGION:
1655     case DS_BIND_MTD:
1656         if (!capable(CAP_SYS_ADMIN)) {
1657                 err = -EPERM;
1658                 goto free_out;
1659         } else {
1660                 static int printed = 0;
1661                 if (!printed) {
1662                         printk(KERN_WARNING "2.6. kernels use pcmciamtd instead of memory_cs.c and do not require special\n");
1663                         printk(KERN_WARNING "MTD handling any more.\n");
1664                         printed++;
1665                 }
1666         }
1667         err = -EINVAL;
1668         goto free_out;
1669         break;
1670     case DS_GET_FIRST_WINDOW:
1671         ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0,
1672                         &buf->win_info.window);
1673         break;
1674     case DS_GET_NEXT_WINDOW:
1675         ret = pcmcia_get_window(s->parent, &buf->win_info.handle,
1676                         buf->win_info.handle->index + 1, &buf->win_info.window);
1677         break;
1678     case DS_GET_MEM_PAGE:
1679         ret = pcmcia_get_mem_page(buf->win_info.handle,
1680                            &buf->win_info.map);
1681         break;
1682     case DS_REPLACE_CIS:
1683         ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
1684         break;
1685     case DS_BIND_REQUEST:
1686         if (!capable(CAP_SYS_ADMIN)) {
1687                 err = -EPERM;
1688                 goto free_out;
1689         }
1690         err = bind_request(s, &buf->bind_info);
1691         break;
1692     case DS_GET_DEVICE_INFO:
1693         err = get_device_info(s, &buf->bind_info, 1);
1694         break;
1695     case DS_GET_NEXT_DEVICE:
1696         err = get_device_info(s, &buf->bind_info, 0);
1697         break;
1698     case DS_UNBIND_REQUEST:
1699         err = 0;
1700         break;
1701     default:
1702         err = -EINVAL;
1703     }
1704
1705     if ((err == 0) && (ret != CS_SUCCESS)) {
1706         ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
1707         switch (ret) {
1708         case CS_BAD_SOCKET: case CS_NO_CARD:
1709             err = -ENODEV; break;
1710         case CS_BAD_ARGS: case CS_BAD_ATTRIBUTE: case CS_BAD_IRQ:
1711         case CS_BAD_TUPLE:
1712             err = -EINVAL; break;
1713         case CS_IN_USE:
1714             err = -EBUSY; break;
1715         case CS_OUT_OF_RESOURCE:
1716             err = -ENOSPC; break;
1717         case CS_NO_MORE_ITEMS:
1718             err = -ENODATA; break;
1719         case CS_UNSUPPORTED_FUNCTION:
1720             err = -ENOSYS; break;
1721         default:
1722             err = -EIO; break;
1723         }
1724     }
1725
1726     if (cmd & IOC_OUT) {
1727         if (__copy_to_user(uarg, (char *)buf, size))
1728             err = -EFAULT;
1729     }
1730
1731 free_out:
1732     kfree(buf);
1733     return err;
1734 } /* ds_ioctl */
1735
1736 /*====================================================================*/
1737
1738 static struct file_operations ds_fops = {
1739         .owner          = THIS_MODULE,
1740         .open           = ds_open,
1741         .release        = ds_release,
1742         .ioctl          = ds_ioctl,
1743         .read           = ds_read,
1744         .write          = ds_write,
1745         .poll           = ds_poll,
1746 };
1747
1748 static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
1749 {
1750         struct pcmcia_socket *socket = class_get_devdata(class_dev);
1751         struct pcmcia_bus_socket *s;
1752         int ret;
1753
1754         s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL);
1755         if(!s)
1756                 return -ENOMEM;
1757         memset(s, 0, sizeof(struct pcmcia_bus_socket));
1758
1759         /* get reference to parent socket */
1760         s->parent = pcmcia_get_socket(socket);
1761         if (!s->parent) {
1762                 printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
1763                 kfree (s);
1764                 return -ENODEV;
1765         }
1766
1767         kref_init(&s->refcount);
1768
1769         /*
1770          * Ugly. But we want to wait for the socket threads to have started up.
1771          * We really should let the drivers themselves drive some of this..
1772          */
1773         msleep(250);
1774
1775         init_waitqueue_head(&s->queue);
1776         INIT_LIST_HEAD(&s->devices_list);
1777         INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s);
1778
1779         /* Set up hotline to Card Services */
1780         s->callback.owner = THIS_MODULE;
1781         s->callback.event = &ds_event;
1782         s->callback.resources_done = &pcmcia_card_add;
1783         s->callback.replace_cis = &pcmcia_bus_rescan;
1784         socket->pcmcia = s;
1785
1786         ret = pccard_register_pcmcia(socket, &s->callback);
1787         if (ret) {
1788                 printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
1789                 pcmcia_put_bus_socket(s);
1790                 socket->pcmcia = NULL;
1791                 return (ret);
1792         }
1793
1794         return 0;
1795 }
1796
1797
1798 static void pcmcia_bus_remove_socket(struct class_device *class_dev)
1799 {
1800         struct pcmcia_socket *socket = class_get_devdata(class_dev);
1801
1802         if (!socket || !socket->pcmcia)
1803                 return;
1804
1805         pccard_register_pcmcia(socket, NULL);
1806
1807         socket->pcmcia->state |= DS_SOCKET_DEAD;
1808         pcmcia_put_bus_socket(socket->pcmcia);
1809         socket->pcmcia = NULL;
1810
1811         return;
1812 }
1813
1814
1815 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1816 static struct class_interface pcmcia_bus_interface = {
1817         .class = &pcmcia_socket_class,
1818         .add = &pcmcia_bus_add_socket,
1819         .remove = &pcmcia_bus_remove_socket,
1820 };
1821
1822
1823 struct bus_type pcmcia_bus_type = {
1824         .name = "pcmcia",
1825         .hotplug = pcmcia_bus_hotplug,
1826         .match = pcmcia_bus_match,
1827         .dev_attrs = pcmcia_dev_attrs,
1828 };
1829 EXPORT_SYMBOL(pcmcia_bus_type);
1830
1831
1832 static int __init init_pcmcia_bus(void)
1833 {
1834         int i;
1835
1836         spin_lock_init(&pcmcia_dev_list_lock);
1837
1838         bus_register(&pcmcia_bus_type);
1839         class_interface_register(&pcmcia_bus_interface);
1840
1841         /* Set up character device for user mode clients */
1842         i = register_chrdev(0, "pcmcia", &ds_fops);
1843         if (i < 0)
1844                 printk(KERN_NOTICE "unable to find a free device # for "
1845                        "Driver Services (error=%d)\n", i);
1846         else
1847                 major_dev = i;
1848
1849 #ifdef CONFIG_PROC_FS
1850         proc_pccard = proc_mkdir("pccard", proc_bus);
1851         if (proc_pccard)
1852                 create_proc_read_entry("drivers",0,proc_pccard,proc_read_drivers,NULL);
1853 #endif
1854
1855         return 0;
1856 }
1857 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1858                                * pcmcia_socket_class is already registered */
1859
1860
1861 static void __exit exit_pcmcia_bus(void)
1862 {
1863         class_interface_unregister(&pcmcia_bus_interface);
1864
1865 #ifdef CONFIG_PROC_FS
1866         if (proc_pccard) {
1867                 remove_proc_entry("drivers", proc_pccard);
1868                 remove_proc_entry("pccard", proc_bus);
1869         }
1870 #endif
1871         if (major_dev != -1)
1872                 unregister_chrdev(major_dev, "pcmcia");
1873
1874         bus_unregister(&pcmcia_bus_type);
1875 }
1876 module_exit(exit_pcmcia_bus);
1877
1878
1879
1880 /* helpers for backwards-compatible functions */
1881
1882 static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
1883 {
1884         struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
1885         if (s && s->pcmcia)
1886                 return s->pcmcia;
1887         else
1888                 return NULL;
1889 }
1890
1891 /* backwards-compatible accessing of driver --- by name! */
1892
1893 static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
1894 {
1895         struct device_driver *drv;
1896         struct pcmcia_driver *p_drv;
1897
1898         drv = driver_find((char *) dev_info, &pcmcia_bus_type);
1899         if (!drv)
1900                 return NULL;
1901
1902         p_drv = container_of(drv, struct pcmcia_driver, drv);
1903
1904         return (p_drv);
1905 }
1906
1907 MODULE_ALIAS("ds");