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