err.no Git - linux-2.6/blob - drivers/pcmcia/ds.c

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