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