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