drivers/pcmcia/ds.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ds.c -- 16-bit PCMCIA core support
   4  *
   5  * The initial developer of the original code is David A. Hinds
   6  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
   7  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
   8  *
   9  * (C) 1999             David A. Hinds
  10  * (C) 2003 - 2010      Dominik Brodowski
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/errno.h>
  17 #include <linux/list.h>
  18 #include <linux/delay.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/crc32.h>
  21 #include <linux/firmware.h>
  22 #include <linux/kref.h>
  23 #include <linux/dma-mapping.h>
  24 #include <linux/slab.h>
  25
  26 #include <pcmcia/cistpl.h>
  27 #include <pcmcia/ds.h>
  28 #include <pcmcia/ss.h>
  29
  30 #include "cs_internal.h"
  31
  32 /*====================================================================*/
  33
  34 /* Module parameters */
  35
  36 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  37 MODULE_DESCRIPTION("PCMCIA Driver Services");
  38 MODULE_LICENSE("GPL");
  39
  40
  41 /*====================================================================*/
  42
  43 static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
  44 {
  45         const struct pcmcia_device_id *did = p_drv->id_table;
  46         unsigned int i;
  47         u32 hash;
  48
  49         if (!p_drv->probe || !p_drv->remove)
  50                 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
  51                        "function\n", p_drv->name);
  52
  53         while (did && did->match_flags) {
  54                 for (i = 0; i < 4; i++) {
  55                         if (!did->prod_id[i])
  56                                 continue;
  57
  58                         hash = crc32(0, did->prod_id[i], strlen(did->prod_id[i]));
  59                         if (hash == did->prod_id_hash[i])
  60                                 continue;
  61
  62                         printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
  63                                "product string \"%s\": is 0x%x, should "
  64                                "be 0x%x\n", p_drv->name, did->prod_id[i],
  65                                did->prod_id_hash[i], hash);
  66                         printk(KERN_DEBUG "pcmcia: see "
  67                                 "Documentation/pcmcia/devicetable.rst for "
  68                                 "details\n");
  69                 }
  70                 did++;
  71         }
  72
  73         return;
  74 }
  75
  76
  77 /*======================================================================*/
  78
  79
  80 struct pcmcia_dynid {
  81         struct list_head                node;
  82         struct pcmcia_device_id         id;
  83 };
  84
  85 /**
  86  * pcmcia_store_new_id - add a new PCMCIA device ID to this driver and re-probe devices
  87  * @driver: target device driver
  88  * @buf: buffer for scanning device ID data
  89  * @count: input size
  90  *
  91  * Adds a new dynamic PCMCIA device ID to this driver,
  92  * and causes the driver to probe for all devices again.
  93  */
  94 static ssize_t
  95 new_id_store(struct device_driver *driver, const char *buf, size_t count)
  96 {
  97         struct pcmcia_dynid *dynid;
  98         struct pcmcia_driver *pdrv = to_pcmcia_drv(driver);
  99         __u16 match_flags, manf_id, card_id;
 100         __u8 func_id, function, device_no;
 101         __u32 prod_id_hash[4] = {0, 0, 0, 0};
 102         int fields = 0;
 103         int retval = 0;
 104
 105         fields = sscanf(buf, "%hx %hx %hx %hhx %hhx %hhx %x %x %x %x",
 106                         &match_flags, &manf_id, &card_id, &func_id, &function, &device_no,
 107                         &prod_id_hash[0], &prod_id_hash[1], &prod_id_hash[2], &prod_id_hash[3]);
 108         if (fields < 6)
 109                 return -EINVAL;
 110
 111         dynid = kzalloc(sizeof(struct pcmcia_dynid), GFP_KERNEL);
 112         if (!dynid)
 113                 return -ENOMEM;
 114
 115         dynid->id.match_flags = match_flags;
 116         dynid->id.manf_id = manf_id;
 117         dynid->id.card_id = card_id;
 118         dynid->id.func_id = func_id;
 119         dynid->id.function = function;
 120         dynid->id.device_no = device_no;
 121         memcpy(dynid->id.prod_id_hash, prod_id_hash, sizeof(__u32) * 4);
 122
 123         mutex_lock(&pdrv->dynids.lock);
 124         list_add_tail(&dynid->node, &pdrv->dynids.list);
 125         mutex_unlock(&pdrv->dynids.lock);
 126
 127         retval = driver_attach(&pdrv->drv);
 128
 129         if (retval)
 130                 return retval;
 131         return count;
 132 }
 133 static DRIVER_ATTR_WO(new_id);
 134
 135 static void
 136 pcmcia_free_dynids(struct pcmcia_driver *drv)
 137 {
 138         struct pcmcia_dynid *dynid, *n;
 139
 140         mutex_lock(&drv->dynids.lock);
 141         list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
 142                 list_del(&dynid->node);
 143                 kfree(dynid);
 144         }
 145         mutex_unlock(&drv->dynids.lock);
 146 }
 147
 148 static int
 149 pcmcia_create_newid_file(struct pcmcia_driver *drv)
 150 {
 151         int error = 0;
 152         if (drv->probe != NULL)
 153                 error = driver_create_file(&drv->drv, &driver_attr_new_id);
 154         return error;
 155 }
 156
 157 static void
 158 pcmcia_remove_newid_file(struct pcmcia_driver *drv)
 159 {
 160         driver_remove_file(&drv->drv, &driver_attr_new_id);
 161 }
 162
 163 /**
 164  * pcmcia_register_driver - register a PCMCIA driver with the bus core
 165  * @driver: the &driver being registered
 166  *
 167  * Registers a PCMCIA driver with the PCMCIA bus core.
 168  */
 169 int pcmcia_register_driver(struct pcmcia_driver *driver)
 170 {
 171         int error;
 172
 173         if (!driver)
 174                 return -EINVAL;
 175
 176         pcmcia_check_driver(driver);
 177
 178         /* initialize common fields */
 179         driver->drv.bus = &pcmcia_bus_type;
 180         driver->drv.owner = driver->owner;
 181         driver->drv.name = driver->name;
 182         mutex_init(&driver->dynids.lock);
 183         INIT_LIST_HEAD(&driver->dynids.list);
 184
 185         pr_debug("registering driver %s\n", driver->name);
 186
 187         error = driver_register(&driver->drv);
 188         if (error < 0)
 189                 return error;
 190
 191         error = pcmcia_create_newid_file(driver);
 192         if (error)
 193                 driver_unregister(&driver->drv);
 194
 195         return error;
 196 }
 197 EXPORT_SYMBOL(pcmcia_register_driver);
 198
 199 /**
 200  * pcmcia_unregister_driver - unregister a PCMCIA driver with the bus core
 201  * @driver: the &driver being unregistered
 202  */
 203 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
 204 {
 205         pr_debug("unregistering driver %s\n", driver->name);
 206         pcmcia_remove_newid_file(driver);
 207         driver_unregister(&driver->drv);
 208         pcmcia_free_dynids(driver);
 209 }
 210 EXPORT_SYMBOL(pcmcia_unregister_driver);
 211
 212
 213 /* pcmcia_device handling */
 214
 215 static struct pcmcia_device *pcmcia_get_dev(struct pcmcia_device *p_dev)
 216 {
 217         struct device *tmp_dev;
 218         tmp_dev = get_device(&p_dev->dev);
 219         if (!tmp_dev)
 220                 return NULL;
 221         return to_pcmcia_dev(tmp_dev);
 222 }
 223
 224 static void pcmcia_put_dev(struct pcmcia_device *p_dev)
 225 {
 226         if (p_dev)
 227                 put_device(&p_dev->dev);
 228 }
 229
 230 static void pcmcia_release_function(struct kref *ref)
 231 {
 232         struct config_t *c = container_of(ref, struct config_t, ref);
 233         pr_debug("releasing config_t\n");
 234         kfree(c);
 235 }
 236
 237 static void pcmcia_release_dev(struct device *dev)
 238 {
 239         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 240         int i;
 241         dev_dbg(dev, "releasing device\n");
 242         pcmcia_put_socket(p_dev->socket);
 243         for (i = 0; i < 4; i++)
 244                 kfree(p_dev->prod_id[i]);
 245         kfree(p_dev->devname);
 246         kref_put(&p_dev->function_config->ref, pcmcia_release_function);
 247         kfree(p_dev);
 248 }
 249
 250
 251 static int pcmcia_device_probe(struct device *dev)
 252 {
 253         struct pcmcia_device *p_dev;
 254         struct pcmcia_driver *p_drv;
 255         struct pcmcia_socket *s;
 256         cistpl_config_t cis_config;
 257         int ret = 0;
 258
 259         dev = get_device(dev);
 260         if (!dev)
 261                 return -ENODEV;
 262
 263         p_dev = to_pcmcia_dev(dev);
 264         p_drv = to_pcmcia_drv(dev->driver);
 265         s = p_dev->socket;
 266
 267         dev_dbg(dev, "trying to bind to %s\n", p_drv->name);
 268
 269         if ((!p_drv->probe) || (!p_dev->function_config) ||
 270             (!try_module_get(p_drv->owner))) {
 271                 ret = -EINVAL;
 272                 goto put_dev;
 273         }
 274
 275         /* set up some more device information */
 276         ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,
 277                                 &cis_config);
 278         if (!ret) {
 279                 p_dev->config_base = cis_config.base;
 280                 p_dev->config_regs = cis_config.rmask[0];
 281                 dev_dbg(dev, "base %x, regs %x", p_dev->config_base,
 282                         p_dev->config_regs);
 283         } else {
 284                 dev_info(dev,
 285                          "pcmcia: could not parse base and rmask0 of CIS\n");
 286                 p_dev->config_base = 0;
 287                 p_dev->config_regs = 0;
 288         }
 289
 290         ret = p_drv->probe(p_dev);
 291         if (ret) {
 292                 dev_dbg(dev, "binding to %s failed with %d\n",
 293                            p_drv->name, ret);
 294                 goto put_module;
 295         }
 296         dev_dbg(dev, "%s bound: Vpp %d.%d, idx %x, IRQ %d", p_drv->name,
 297                 p_dev->vpp/10, p_dev->vpp%10, p_dev->config_index, p_dev->irq);
 298         dev_dbg(dev, "resources: ioport %pR %pR iomem %pR %pR %pR",
 299                 p_dev->resource[0], p_dev->resource[1], p_dev->resource[2],
 300                 p_dev->resource[3], p_dev->resource[4]);
 301
 302         mutex_lock(&s->ops_mutex);
 303         if ((s->pcmcia_pfc) &&
 304             (p_dev->socket->device_count == 1) && (p_dev->device_no == 0))
 305                 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 306         mutex_unlock(&s->ops_mutex);
 307
 308 put_module:
 309         if (ret)
 310                 module_put(p_drv->owner);
 311 put_dev:
 312         if (ret)
 313                 put_device(dev);
 314         return ret;
 315 }
 316
 317
 318 /*
 319  * Removes a PCMCIA card from the device tree and socket list.
 320  */
 321 static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)
 322 {
 323         struct pcmcia_device    *p_dev;
 324         struct pcmcia_device    *tmp;
 325
 326         dev_dbg(leftover ? &leftover->dev : &s->dev,
 327                    "pcmcia_card_remove(%d) %s\n", s->sock,
 328                    leftover ? leftover->devname : "");
 329
 330         mutex_lock(&s->ops_mutex);
 331         if (!leftover)
 332                 s->device_count = 0;
 333         else
 334                 s->device_count = 1;
 335         mutex_unlock(&s->ops_mutex);
 336
 337         /* unregister all pcmcia_devices registered with this socket, except leftover */
 338         list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) {
 339                 if (p_dev == leftover)
 340                         continue;
 341
 342                 mutex_lock(&s->ops_mutex);
 343                 list_del(&p_dev->socket_device_list);
 344                 mutex_unlock(&s->ops_mutex);
 345
 346                 dev_dbg(&p_dev->dev, "unregistering device\n");
 347                 device_unregister(&p_dev->dev);
 348         }
 349
 350         return;
 351 }
 352
 353 static int pcmcia_device_remove(struct device *dev)
 354 {
 355         struct pcmcia_device *p_dev;
 356         struct pcmcia_driver *p_drv;
 357         int i;
 358
 359         p_dev = to_pcmcia_dev(dev);
 360         p_drv = to_pcmcia_drv(dev->driver);
 361
 362         dev_dbg(dev, "removing device\n");
 363
 364         /* If we're removing the primary module driving a
 365          * pseudo multi-function card, we need to unbind
 366          * all devices
 367          */
 368         if ((p_dev->socket->pcmcia_pfc) &&
 369             (p_dev->socket->device_count > 0) &&
 370             (p_dev->device_no == 0))
 371                 pcmcia_card_remove(p_dev->socket, p_dev);
 372
 373         /* detach the "instance" */
 374         if (!p_drv)
 375                 return 0;
 376
 377         if (p_drv->remove)
 378                 p_drv->remove(p_dev);
 379
 380         /* check for proper unloading */
 381         if (p_dev->_irq || p_dev->_io || p_dev->_locked)
 382                 dev_info(dev,
 383                          "pcmcia: driver %s did not release config properly\n",
 384                          p_drv->name);
 385
 386         for (i = 0; i < MAX_WIN; i++)
 387                 if (p_dev->_win & CLIENT_WIN_REQ(i))
 388                         dev_info(dev,
 389                                  "pcmcia: driver %s did not release window properly\n",
 390                                  p_drv->name);
 391
 392         /* references from pcmcia_probe_device */
 393         pcmcia_put_dev(p_dev);
 394         module_put(p_drv->owner);
 395
 396         return 0;
 397 }
 398
 399
 400 /*
 401  * pcmcia_device_query -- determine information about a pcmcia device
 402  */
 403 static int pcmcia_device_query(struct pcmcia_device *p_dev)
 404 {
 405         cistpl_manfid_t manf_id;
 406         cistpl_funcid_t func_id;
 407         cistpl_vers_1_t *vers1;
 408         unsigned int i;
 409
 410         vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
 411         if (!vers1)
 412                 return -ENOMEM;
 413
 414         if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL,
 415                                CISTPL_MANFID, &manf_id)) {
 416                 mutex_lock(&p_dev->socket->ops_mutex);
 417                 p_dev->manf_id = manf_id.manf;
 418                 p_dev->card_id = manf_id.card;
 419                 p_dev->has_manf_id = 1;
 420                 p_dev->has_card_id = 1;
 421                 mutex_unlock(&p_dev->socket->ops_mutex);
 422         }
 423
 424         if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 425                                CISTPL_FUNCID, &func_id)) {
 426                 mutex_lock(&p_dev->socket->ops_mutex);
 427                 p_dev->func_id = func_id.func;
 428                 p_dev->has_func_id = 1;
 429                 mutex_unlock(&p_dev->socket->ops_mutex);
 430         } else {
 431                 /* rule of thumb: cards with no FUNCID, but with
 432                  * common memory device geometry information, are
 433                  * probably memory cards (from pcmcia-cs) */
 434                 cistpl_device_geo_t *devgeo;
 435
 436                 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
 437                 if (!devgeo) {
 438                         kfree(vers1);
 439                         return -ENOMEM;
 440                 }
 441                 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 442                                       CISTPL_DEVICE_GEO, devgeo)) {
 443                         dev_dbg(&p_dev->dev,
 444                                    "mem device geometry probably means "
 445                                    "FUNCID_MEMORY\n");
 446                         mutex_lock(&p_dev->socket->ops_mutex);
 447                         p_dev->func_id = CISTPL_FUNCID_MEMORY;
 448                         p_dev->has_func_id = 1;
 449                         mutex_unlock(&p_dev->socket->ops_mutex);
 450                 }
 451                 kfree(devgeo);
 452         }
 453
 454         if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,
 455                                vers1)) {
 456                 mutex_lock(&p_dev->socket->ops_mutex);
 457                 for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {
 458                         char *tmp;
 459                         unsigned int length;
 460                         char *new;
 461
 462                         tmp = vers1->str + vers1->ofs[i];
 463
 464                         length = strlen(tmp) + 1;
 465                         if ((length < 2) || (length > 255))
 466                                 continue;
 467
 468                         new = kstrdup(tmp, GFP_KERNEL);
 469                         if (!new)
 470                                 continue;
 471
 472                         tmp = p_dev->prod_id[i];
 473                         p_dev->prod_id[i] = new;
 474                         kfree(tmp);
 475                 }
 476                 mutex_unlock(&p_dev->socket->ops_mutex);
 477         }
 478
 479         kfree(vers1);
 480         return 0;
 481 }
 482
 483
 484 static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
 485                                                unsigned int function)
 486 {
 487         struct pcmcia_device *p_dev, *tmp_dev;
 488         int i;
 489
 490         s = pcmcia_get_socket(s);
 491         if (!s)
 492                 return NULL;
 493
 494         pr_debug("adding device to %d, function %d\n", s->sock, function);
 495
 496         p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
 497         if (!p_dev)
 498                 goto err_put;
 499
 500         mutex_lock(&s->ops_mutex);
 501         p_dev->device_no = (s->device_count++);
 502         mutex_unlock(&s->ops_mutex);
 503
 504         /* max of 2 PFC devices */
 505         if ((p_dev->device_no >= 2) && (function == 0))
 506                 goto err_free;
 507
 508         /* max of 4 devices overall */
 509         if (p_dev->device_no >= 4)
 510                 goto err_free;
 511
 512         p_dev->socket = s;
 513         p_dev->func   = function;
 514
 515         p_dev->dev.bus = &pcmcia_bus_type;
 516         p_dev->dev.parent = s->dev.parent;
 517         p_dev->dev.release = pcmcia_release_dev;
 518         /* by default don't allow DMA */
 519         p_dev->dma_mask = 0;
 520         p_dev->dev.dma_mask = &p_dev->dma_mask;
 521         dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
 522         if (!dev_name(&p_dev->dev))
 523                 goto err_free;
 524         p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
 525         if (!p_dev->devname)
 526                 goto err_free;
 527         dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
 528
 529         mutex_lock(&s->ops_mutex);
 530
 531         /*
 532          * p_dev->function_config must be the same for all card functions.
 533          * Note that this is serialized by ops_mutex, so that only one
 534          * such struct will be created.
 535          */
 536         list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
 537                 if (p_dev->func == tmp_dev->func) {
 538                         p_dev->function_config = tmp_dev->function_config;
 539                         p_dev->irq = tmp_dev->irq;
 540                         kref_get(&p_dev->function_config->ref);
 541                 }
 542
 543         /* Add to the list in pcmcia_bus_socket */
 544         list_add(&p_dev->socket_device_list, &s->devices_list);
 545
 546         if (pcmcia_setup_irq(p_dev))
 547                 dev_warn(&p_dev->dev,
 548                         "IRQ setup failed -- device might not work\n");
 549
 550         if (!p_dev->function_config) {
 551                 config_t *c;
 552                 dev_dbg(&p_dev->dev, "creating config_t\n");
 553                 c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
 554                 if (!c) {
 555                         mutex_unlock(&s->ops_mutex);
 556                         goto err_unreg;
 557                 }
 558                 p_dev->function_config = c;
 559                 kref_init(&c->ref);
 560                 for (i = 0; i < MAX_IO_WIN; i++) {
 561                         c->io[i].name = p_dev->devname;
 562                         c->io[i].flags = IORESOURCE_IO;
 563                 }
 564                 for (i = 0; i < MAX_WIN; i++) {
 565                         c->mem[i].name = p_dev->devname;
 566                         c->mem[i].flags = IORESOURCE_MEM;
 567                 }
 568         }
 569         for (i = 0; i < MAX_IO_WIN; i++)
 570                 p_dev->resource[i] = &p_dev->function_config->io[i];
 571         for (; i < (MAX_IO_WIN + MAX_WIN); i++)
 572                 p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
 573
 574         mutex_unlock(&s->ops_mutex);
 575
 576         dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
 577                    p_dev->devname, p_dev->irq);
 578
 579         pcmcia_device_query(p_dev);
 580
 581         if (device_register(&p_dev->dev))
 582                 goto err_unreg;
 583
 584         return p_dev;
 585
 586  err_unreg:
 587         mutex_lock(&s->ops_mutex);
 588         list_del(&p_dev->socket_device_list);
 589         mutex_unlock(&s->ops_mutex);
 590
 591  err_free:
 592         mutex_lock(&s->ops_mutex);
 593         s->device_count--;
 594         mutex_unlock(&s->ops_mutex);
 595
 596         for (i = 0; i < 4; i++)
 597                 kfree(p_dev->prod_id[i]);
 598         kfree(p_dev->devname);
 599         kfree(p_dev);
 600  err_put:
 601         pcmcia_put_socket(s);
 602
 603         return NULL;
 604 }
 605
 606
 607 static int pcmcia_card_add(struct pcmcia_socket *s)
 608 {
 609         cistpl_longlink_mfc_t mfc;
 610         unsigned int no_funcs, i, no_chains;
 611         int ret = -EAGAIN;
 612
 613         mutex_lock(&s->ops_mutex);
 614         if (!(s->resource_setup_done)) {
 615                 dev_dbg(&s->dev,
 616                            "no resources available, delaying card_add\n");
 617                 mutex_unlock(&s->ops_mutex);
 618                 return -EAGAIN; /* try again, but later... */
 619         }
 620
 621         if (pcmcia_validate_mem(s)) {
 622                 dev_dbg(&s->dev, "validating mem resources failed, "
 623                        "delaying card_add\n");
 624                 mutex_unlock(&s->ops_mutex);
 625                 return -EAGAIN; /* try again, but later... */
 626         }
 627         mutex_unlock(&s->ops_mutex);
 628
 629         ret = pccard_validate_cis(s, &no_chains);
 630         if (ret || !no_chains) {
 631 #if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)
 632                 /* Set up as an anonymous card. If we don't have anonymous
 633                    memory support then just error the card as there is no
 634                    point trying to second guess.
 635
 636                    Note: some cards have just a device entry, it may be
 637                    worth extending support to cover these in future */
 638                 if (ret == -EIO) {
 639                         dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
 640                         pcmcia_replace_cis(s, "\xFF", 1);
 641                         no_chains = 1;
 642                         ret = 0;
 643                 } else
 644 #endif
 645                 {
 646                         dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
 647                         return -ENODEV;
 648                 }
 649         }
 650
 651         if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
 652                 no_funcs = mfc.nfn;
 653         else
 654                 no_funcs = 1;
 655         s->functions = no_funcs;
 656
 657         for (i = 0; i < no_funcs; i++)
 658                 pcmcia_device_add(s, i);
 659
 660         return ret;
 661 }
 662
 663
 664 static int pcmcia_requery_callback(struct device *dev, void *_data)
 665 {
 666         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 667         if (!p_dev->dev.driver) {
 668                 dev_dbg(dev, "update device information\n");
 669                 pcmcia_device_query(p_dev);
 670         }
 671
 672         return 0;
 673 }
 674
 675
 676 static void pcmcia_requery(struct pcmcia_socket *s)
 677 {
 678         int has_pfc;
 679
 680         if (!(s->state & SOCKET_PRESENT))
 681                 return;
 682
 683         if (s->functions == 0) {
 684                 pcmcia_card_add(s);
 685                 return;
 686         }
 687
 688         /* some device information might have changed because of a CIS
 689          * update or because we can finally read it correctly... so
 690          * determine it again, overwriting old values if necessary. */
 691         bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);
 692
 693         /* if the CIS changed, we need to check whether the number of
 694          * functions changed. */
 695         if (s->fake_cis) {
 696                 int old_funcs, new_funcs;
 697                 cistpl_longlink_mfc_t mfc;
 698
 699                 /* does this cis override add or remove functions? */
 700                 old_funcs = s->functions;
 701
 702                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 703                                         &mfc))
 704                         new_funcs = mfc.nfn;
 705                 else
 706                         new_funcs = 1;
 707                 if (old_funcs != new_funcs) {
 708                         /* we need to re-start */
 709                         pcmcia_card_remove(s, NULL);
 710                         s->functions = 0;
 711                         pcmcia_card_add(s);
 712                 }
 713         }
 714
 715         /* If the PCMCIA device consists of two pseudo devices,
 716          * call pcmcia_device_add() -- which will fail if both
 717          * devices are already registered. */
 718         mutex_lock(&s->ops_mutex);
 719         has_pfc = s->pcmcia_pfc;
 720         mutex_unlock(&s->ops_mutex);
 721         if (has_pfc)
 722                 pcmcia_device_add(s, 0);
 723
 724         /* we re-scan all devices, not just the ones connected to this
 725          * socket. This does not matter, though. */
 726         if (bus_rescan_devices(&pcmcia_bus_type))
 727                 dev_warn(&s->dev, "rescanning the bus failed\n");
 728 }
 729
 730
 731 #ifdef CONFIG_PCMCIA_LOAD_CIS
 732
 733 /**
 734  * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
 735  * @dev: the pcmcia device which needs a CIS override
 736  * @filename: requested filename in /lib/firmware/
 737  *
 738  * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
 739  * the one provided by the card is broken. The firmware files reside in
 740  * /lib/firmware/ in userspace.
 741  */
 742 static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
 743 {
 744         struct pcmcia_socket *s = dev->socket;
 745         const struct firmware *fw;
 746         int ret = -ENOMEM;
 747         cistpl_longlink_mfc_t mfc;
 748         int old_funcs, new_funcs = 1;
 749
 750         if (!filename)
 751                 return -EINVAL;
 752
 753         dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
 754
 755         if (request_firmware(&fw, filename, &dev->dev) == 0) {
 756                 if (fw->size >= CISTPL_MAX_CIS_SIZE) {
 757                         ret = -EINVAL;
 758                         dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
 759                         goto release;
 760                 }
 761
 762                 if (!pcmcia_replace_cis(s, fw->data, fw->size))
 763                         ret = 0;
 764                 else {
 765                         dev_err(&dev->dev, "pcmcia: CIS override failed\n");
 766                         goto release;
 767                 }
 768
 769                 /* we need to re-start if the number of functions changed */
 770                 old_funcs = s->functions;
 771                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 772                                         &mfc))
 773                         new_funcs = mfc.nfn;
 774
 775                 if (old_funcs != new_funcs)
 776                         ret = -EBUSY;
 777
 778                 /* update information */
 779                 pcmcia_device_query(dev);
 780
 781                 /* requery (as number of functions might have changed) */
 782                 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 783         }
 784  release:
 785         release_firmware(fw);
 786
 787         return ret;
 788 }
 789
 790 #else /* !CONFIG_PCMCIA_LOAD_CIS */
 791
 792 static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
 793                                        char *filename)
 794 {
 795         return -ENODEV;
 796 }
 797
 798 #endif
 799
 800
 801 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 802                                   const struct pcmcia_device_id *did)
 803 {
 804         if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
 805                 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
 806                         return 0;
 807         }
 808
 809         if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
 810                 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
 811                         return 0;
 812         }
 813
 814         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
 815                 if (dev->func != did->function)
 816                         return 0;
 817         }
 818
 819         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
 820                 if (!dev->prod_id[0])
 821                         return 0;
 822                 if (strcmp(did->prod_id[0], dev->prod_id[0]))
 823                         return 0;
 824         }
 825
 826         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
 827                 if (!dev->prod_id[1])
 828                         return 0;
 829                 if (strcmp(did->prod_id[1], dev->prod_id[1]))
 830                         return 0;
 831         }
 832
 833         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
 834                 if (!dev->prod_id[2])
 835                         return 0;
 836                 if (strcmp(did->prod_id[2], dev->prod_id[2]))
 837                         return 0;
 838         }
 839
 840         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
 841                 if (!dev->prod_id[3])
 842                         return 0;
 843                 if (strcmp(did->prod_id[3], dev->prod_id[3]))
 844                         return 0;
 845         }
 846
 847         if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
 848                 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
 849                 mutex_lock(&dev->socket->ops_mutex);
 850                 dev->socket->pcmcia_pfc = 1;
 851                 mutex_unlock(&dev->socket->ops_mutex);
 852                 if (dev->device_no != did->device_no)
 853                         return 0;
 854         }
 855
 856         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
 857                 int ret;
 858
 859                 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
 860                         return 0;
 861
 862                 /* if this is a pseudo-multi-function device,
 863                  * we need explicit matches */
 864                 if (dev->socket->pcmcia_pfc)
 865                         return 0;
 866                 if (dev->device_no)
 867                         return 0;
 868
 869                 /* also, FUNC_ID matching needs to be activated by userspace
 870                  * after it has re-checked that there is no possible module
 871                  * with a prod_id/manf_id/card_id match.
 872                  */
 873                 mutex_lock(&dev->socket->ops_mutex);
 874                 ret = dev->allow_func_id_match;
 875                 mutex_unlock(&dev->socket->ops_mutex);
 876
 877                 if (!ret) {
 878                         dev_dbg(&dev->dev,
 879                                 "skipping FUNC_ID match until userspace ACK\n");
 880                         return 0;
 881                 }
 882         }
 883
 884         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
 885                 dev_dbg(&dev->dev, "device needs a fake CIS\n");
 886                 if (!dev->socket->fake_cis)
 887                         if (pcmcia_load_firmware(dev, did->cisfile))
 888                                 return 0;
 889         }
 890
 891         if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
 892                 int i;
 893                 for (i = 0; i < 4; i++)
 894                         if (dev->prod_id[i])
 895                                 return 0;
 896                 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
 897                         return 0;
 898         }
 899
 900         return 1;
 901 }
 902
 903
 904 static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
 905 {
 906         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 907         struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
 908         const struct pcmcia_device_id *did = p_drv->id_table;
 909         struct pcmcia_dynid *dynid;
 910
 911         /* match dynamic devices first */
 912         mutex_lock(&p_drv->dynids.lock);
 913         list_for_each_entry(dynid, &p_drv->dynids.list, node) {
 914                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 915                 if (pcmcia_devmatch(p_dev, &dynid->id)) {
 916                         dev_dbg(dev, "matched to %s\n", drv->name);
 917                         mutex_unlock(&p_drv->dynids.lock);
 918                         return 1;
 919                 }
 920         }
 921         mutex_unlock(&p_drv->dynids.lock);
 922
 923         while (did && did->match_flags) {
 924                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 925                 if (pcmcia_devmatch(p_dev, did)) {
 926                         dev_dbg(dev, "matched to %s\n", drv->name);
 927                         return 1;
 928                 }
 929                 did++;
 930         }
 931
 932         return 0;
 933 }
 934
 935 static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 936 {
 937         struct pcmcia_device *p_dev;
 938         int i;
 939         u32 hash[4] = { 0, 0, 0, 0};
 940
 941         if (!dev)
 942                 return -ENODEV;
 943
 944         p_dev = to_pcmcia_dev(dev);
 945
 946         /* calculate hashes */
 947         for (i = 0; i < 4; i++) {
 948                 if (!p_dev->prod_id[i])
 949                         continue;
 950                 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
 951         }
 952
 953         if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
 954                 return -ENOMEM;
 955
 956         if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
 957                 return -ENOMEM;
 958
 959         if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
 960                            "pa%08Xpb%08Xpc%08Xpd%08X",
 961                            p_dev->has_manf_id ? p_dev->manf_id : 0,
 962                            p_dev->has_card_id ? p_dev->card_id : 0,
 963                            p_dev->has_func_id ? p_dev->func_id : 0,
 964                            p_dev->func,
 965                            p_dev->device_no,
 966                            hash[0],
 967                            hash[1],
 968                            hash[2],
 969                            hash[3]))
 970                 return -ENOMEM;
 971
 972         return 0;
 973 }
 974
 975 /************************ runtime PM support ***************************/
 976
 977 static int pcmcia_dev_suspend(struct device *dev);
 978 static int pcmcia_dev_resume(struct device *dev);
 979
 980 static int runtime_suspend(struct device *dev)
 981 {
 982         int rc;
 983
 984         device_lock(dev);
 985         rc = pcmcia_dev_suspend(dev);
 986         device_unlock(dev);
 987         return rc;
 988 }
 989
 990 static int runtime_resume(struct device *dev)
 991 {
 992         int rc;
 993
 994         device_lock(dev);
 995         rc = pcmcia_dev_resume(dev);
 996         device_unlock(dev);
 997         return rc;
 998 }
 999
1000 /************************ per-device sysfs output ***************************/
1001
1002 #define pcmcia_device_attr(field, test, format)                         \
1003 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)              \
1004 {                                                                       \
1005         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1006         return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \
1007 }                                                                       \
1008 static DEVICE_ATTR_RO(field);
1009
1010 #define pcmcia_device_stringattr(name, field)                                   \
1011 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)               \
1012 {                                                                       \
1013         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1014         return p_dev->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \
1015 }                                                                       \
1016 static DEVICE_ATTR_RO(name);
1017
1018 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
1019 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
1020 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
1021 pcmcia_device_stringattr(prod_id1, prod_id[0]);
1022 pcmcia_device_stringattr(prod_id2, prod_id[1]);
1023 pcmcia_device_stringattr(prod_id3, prod_id[2]);
1024 pcmcia_device_stringattr(prod_id4, prod_id[3]);
1025
1026 static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1027                              char *buf)
1028 {
1029         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1030         return p_dev->socket ? sprintf(buf, "0x%02x\n", p_dev->func) : -ENODEV;
1031 }
1032 static DEVICE_ATTR_RO(function);
1033
1034 static ssize_t resources_show(struct device *dev,
1035                               struct device_attribute *attr, char *buf)
1036 {
1037         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1038         char *str = buf;
1039         int i;
1040
1041         for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1042                 str += sprintf(str, "%pr\n", p_dev->resource[i]);
1043
1044         return str - buf;
1045 }
1046 static DEVICE_ATTR_RO(resources);
1047
1048 static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1049 {
1050         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1051
1052         if (p_dev->suspended)
1053                 return sprintf(buf, "off\n");
1054         else
1055                 return sprintf(buf, "on\n");
1056 }
1057
1058 static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1059                               const char *buf, size_t count)
1060 {
1061         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1062         int ret = 0;
1063
1064         if (!count)
1065                 return -EINVAL;
1066
1067         if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
1068                 ret = runtime_suspend(dev);
1069         else if (p_dev->suspended && !strncmp(buf, "on", 2))
1070                 ret = runtime_resume(dev);
1071
1072         return ret ? ret : count;
1073 }
1074 static DEVICE_ATTR_RW(pm_state);
1075
1076 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1077 {
1078         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1079         int i;
1080         u32 hash[4] = { 0, 0, 0, 0};
1081
1082         /* calculate hashes */
1083         for (i = 0; i < 4; i++) {
1084                 if (!p_dev->prod_id[i])
1085                         continue;
1086                 hash[i] = crc32(0, p_dev->prod_id[i],
1087                                 strlen(p_dev->prod_id[i]));
1088         }
1089         return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
1090                                 "pa%08Xpb%08Xpc%08Xpd%08X\n",
1091                                 p_dev->has_manf_id ? p_dev->manf_id : 0,
1092                                 p_dev->has_card_id ? p_dev->card_id : 0,
1093                                 p_dev->has_func_id ? p_dev->func_id : 0,
1094                                 p_dev->func, p_dev->device_no,
1095                                 hash[0], hash[1], hash[2], hash[3]);
1096 }
1097 static DEVICE_ATTR_RO(modalias);
1098
1099 static ssize_t allow_func_id_match_store(struct device *dev,
1100                 struct device_attribute *attr, const char *buf, size_t count)
1101 {
1102         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1103
1104         if (!count)
1105                 return -EINVAL;
1106
1107         mutex_lock(&p_dev->socket->ops_mutex);
1108         p_dev->allow_func_id_match = 1;
1109         mutex_unlock(&p_dev->socket->ops_mutex);
1110         pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY);
1111
1112         return count;
1113 }
1114 static DEVICE_ATTR_WO(allow_func_id_match);
1115
1116 static struct attribute *pcmcia_dev_attrs[] = {
1117         &dev_attr_resources.attr,
1118         &dev_attr_pm_state.attr,
1119         &dev_attr_function.attr,
1120         &dev_attr_func_id.attr,
1121         &dev_attr_manf_id.attr,
1122         &dev_attr_card_id.attr,
1123         &dev_attr_prod_id1.attr,
1124         &dev_attr_prod_id2.attr,
1125         &dev_attr_prod_id3.attr,
1126         &dev_attr_prod_id4.attr,
1127         &dev_attr_modalias.attr,
1128         &dev_attr_allow_func_id_match.attr,
1129         NULL,
1130 };
1131 ATTRIBUTE_GROUPS(pcmcia_dev);
1132
1133 /* PM support, also needed for reset */
1134
1135 static int pcmcia_dev_suspend(struct device *dev)
1136 {
1137         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1138         struct pcmcia_driver *p_drv = NULL;
1139         int ret = 0;
1140
1141         mutex_lock(&p_dev->socket->ops_mutex);
1142         if (p_dev->suspended) {
1143                 mutex_unlock(&p_dev->socket->ops_mutex);
1144                 return 0;
1145         }
1146         p_dev->suspended = 1;
1147         mutex_unlock(&p_dev->socket->ops_mutex);
1148
1149         dev_dbg(dev, "suspending\n");
1150
1151         if (dev->driver)
1152                 p_drv = to_pcmcia_drv(dev->driver);
1153
1154         if (!p_drv)
1155                 goto out;
1156
1157         if (p_drv->suspend) {
1158                 ret = p_drv->suspend(p_dev);
1159                 if (ret) {
1160                         dev_err(dev,
1161                                 "pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n",
1162                                 p_dev->devname, p_drv->name, ret);
1163                         mutex_lock(&p_dev->socket->ops_mutex);
1164                         p_dev->suspended = 0;
1165                         mutex_unlock(&p_dev->socket->ops_mutex);
1166                         goto out;
1167                 }
1168         }
1169
1170         if (p_dev->device_no == p_dev->func) {
1171                 dev_dbg(dev, "releasing configuration\n");
1172                 pcmcia_release_configuration(p_dev);
1173         }
1174
1175  out:
1176         return ret;
1177 }
1178
1179
1180 static int pcmcia_dev_resume(struct device *dev)
1181 {
1182         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1183         struct pcmcia_driver *p_drv = NULL;
1184         int ret = 0;
1185
1186         mutex_lock(&p_dev->socket->ops_mutex);
1187         if (!p_dev->suspended) {
1188                 mutex_unlock(&p_dev->socket->ops_mutex);
1189                 return 0;
1190         }
1191         p_dev->suspended = 0;
1192         mutex_unlock(&p_dev->socket->ops_mutex);
1193
1194         dev_dbg(dev, "resuming\n");
1195
1196         if (dev->driver)
1197                 p_drv = to_pcmcia_drv(dev->driver);
1198
1199         if (!p_drv)
1200                 goto out;
1201
1202         if (p_dev->device_no == p_dev->func) {
1203                 dev_dbg(dev, "requesting configuration\n");
1204                 ret = pcmcia_enable_device(p_dev);
1205                 if (ret)
1206                         goto out;
1207         }
1208
1209         if (p_drv->resume)
1210                 ret = p_drv->resume(p_dev);
1211
1212  out:
1213         return ret;
1214 }
1215
1216
1217 static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)
1218 {
1219         struct pcmcia_socket *skt = _data;
1220         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1221
1222         if (p_dev->socket != skt || p_dev->suspended)
1223                 return 0;
1224
1225         return runtime_suspend(dev);
1226 }
1227
1228 static int pcmcia_bus_resume_callback(struct device *dev, void *_data)
1229 {
1230         struct pcmcia_socket *skt = _data;
1231         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1232
1233         if (p_dev->socket != skt || !p_dev->suspended)
1234                 return 0;
1235
1236         runtime_resume(dev);
1237
1238         return 0;
1239 }
1240
1241 static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1242 {
1243         dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock);
1244         bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);
1245         return 0;
1246 }
1247
1248 static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1249 {
1250         dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock);
1251         if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,
1252                              pcmcia_bus_suspend_callback)) {
1253                 pcmcia_bus_resume(skt);
1254                 return -EIO;
1255         }
1256         return 0;
1257 }
1258
1259 static int pcmcia_bus_remove(struct pcmcia_socket *skt)
1260 {
1261         atomic_set(&skt->present, 0);
1262         pcmcia_card_remove(skt, NULL);
1263
1264         mutex_lock(&skt->ops_mutex);
1265         destroy_cis_cache(skt);
1266         pcmcia_cleanup_irq(skt);
1267         mutex_unlock(&skt->ops_mutex);
1268
1269         return 0;
1270 }
1271
1272 static int pcmcia_bus_add(struct pcmcia_socket *skt)
1273 {
1274         atomic_set(&skt->present, 1);
1275
1276         mutex_lock(&skt->ops_mutex);
1277         skt->pcmcia_pfc = 0;
1278         destroy_cis_cache(skt); /* to be on the safe side... */
1279         mutex_unlock(&skt->ops_mutex);
1280
1281         pcmcia_card_add(skt);
1282
1283         return 0;
1284 }
1285
1286 static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
1287 {
1288         if (!verify_cis_cache(skt))
1289                 return 0;
1290
1291         dev_dbg(&skt->dev, "cis mismatch - different card\n");
1292
1293         /* first, remove the card */
1294         pcmcia_bus_remove(skt);
1295
1296         mutex_lock(&skt->ops_mutex);
1297         destroy_cis_cache(skt);
1298         kfree(skt->fake_cis);
1299         skt->fake_cis = NULL;
1300         skt->functions = 0;
1301         mutex_unlock(&skt->ops_mutex);
1302
1303         /* now, add the new card */
1304         pcmcia_bus_add(skt);
1305         return 0;
1306 }
1307
1308
1309 /*
1310  * NOTE: This is racy. There's no guarantee the card will still be
1311  * physically present, even if the call to this function returns
1312  * non-NULL. Furthermore, the device driver most likely is unbound
1313  * almost immediately, so the timeframe where pcmcia_dev_present
1314  * returns NULL is probably really really small.
1315  */
1316 struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)
1317 {
1318         struct pcmcia_device *p_dev;
1319         struct pcmcia_device *ret = NULL;
1320
1321         p_dev = pcmcia_get_dev(_p_dev);
1322         if (!p_dev)
1323                 return NULL;
1324
1325         if (atomic_read(&p_dev->socket->present) != 0)
1326                 ret = p_dev;
1327
1328         pcmcia_put_dev(p_dev);
1329         return ret;
1330 }
1331 EXPORT_SYMBOL(pcmcia_dev_present);
1332
1333
1334 static struct pcmcia_callback pcmcia_bus_callback = {
1335         .owner = THIS_MODULE,
1336         .add = pcmcia_bus_add,
1337         .remove = pcmcia_bus_remove,
1338         .requery = pcmcia_requery,
1339         .validate = pccard_validate_cis,
1340         .suspend = pcmcia_bus_suspend,
1341         .early_resume = pcmcia_bus_early_resume,
1342         .resume = pcmcia_bus_resume,
1343 };
1344
1345 static int pcmcia_bus_add_socket(struct device *dev,
1346                                            struct class_interface *class_intf)
1347 {
1348         struct pcmcia_socket *socket = dev_get_drvdata(dev);
1349         int ret;
1350
1351         socket = pcmcia_get_socket(socket);
1352         if (!socket) {
1353                 dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1354                 return -ENODEV;
1355         }
1356
1357         ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1358         if (ret) {
1359                 dev_err(dev, "PCMCIA registration failed\n");
1360                 pcmcia_put_socket(socket);
1361                 return ret;
1362         }
1363
1364         INIT_LIST_HEAD(&socket->devices_list);
1365         socket->pcmcia_pfc = 0;
1366         socket->device_count = 0;
1367         atomic_set(&socket->present, 0);
1368
1369         ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1370         if (ret) {
1371                 dev_err(dev, "PCMCIA registration failed\n");
1372                 pcmcia_put_socket(socket);
1373                 return ret;
1374         }
1375
1376         return 0;
1377 }
1378
1379 static void pcmcia_bus_remove_socket(struct device *dev,
1380                                      struct class_interface *class_intf)
1381 {
1382         struct pcmcia_socket *socket = dev_get_drvdata(dev);
1383
1384         if (!socket)
1385                 return;
1386
1387         pccard_register_pcmcia(socket, NULL);
1388
1389         /* unregister any unbound devices */
1390         mutex_lock(&socket->skt_mutex);
1391         pcmcia_card_remove(socket, NULL);
1392         release_cis_mem(socket);
1393         mutex_unlock(&socket->skt_mutex);
1394
1395         sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
1396
1397         pcmcia_put_socket(socket);
1398
1399         return;
1400 }
1401
1402
1403 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1404 static struct class_interface pcmcia_bus_interface __refdata = {
1405         .class = &pcmcia_socket_class,
1406         .add_dev = &pcmcia_bus_add_socket,
1407         .remove_dev = &pcmcia_bus_remove_socket,
1408 };
1409
1410 static const struct dev_pm_ops pcmcia_bus_pm_ops = {
1411         SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)
1412 };
1413
1414 struct bus_type pcmcia_bus_type = {
1415         .name = "pcmcia",
1416         .uevent = pcmcia_bus_uevent,
1417         .match = pcmcia_bus_match,
1418         .dev_groups = pcmcia_dev_groups,
1419         .probe = pcmcia_device_probe,
1420         .remove = pcmcia_device_remove,
1421         .pm = &pcmcia_bus_pm_ops,
1422 };
1423
1424
1425 static int __init init_pcmcia_bus(void)
1426 {
1427         int ret;
1428
1429         ret = bus_register(&pcmcia_bus_type);
1430         if (ret < 0) {
1431                 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);
1432                 return ret;
1433         }
1434         ret = class_interface_register(&pcmcia_bus_interface);
1435         if (ret < 0) {
1436                 printk(KERN_WARNING
1437                         "pcmcia: class_interface_register error: %d\n", ret);
1438                 bus_unregister(&pcmcia_bus_type);
1439                 return ret;
1440         }
1441
1442         return 0;
1443 }
1444 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1445                                * pcmcia_socket_class is already registered */
1446
1447
1448 static void __exit exit_pcmcia_bus(void)
1449 {
1450         class_interface_unregister(&pcmcia_bus_interface);
1451
1452         bus_unregister(&pcmcia_bus_type);
1453 }
1454 module_exit(exit_pcmcia_bus);
1455
1456
1457 MODULE_ALIAS("ds");