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  * <[email protected]>.  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 <[email protected]>");
  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  * new_id_store() - 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->remove)
 375                 p_drv->remove(p_dev);
 376
 377         /* check for proper unloading */
 378         if (p_dev->_irq || p_dev->_io || p_dev->_locked)
 379                 dev_info(dev,
 380                          "pcmcia: driver %s did not release config properly\n",
 381                          p_drv->name);
 382
 383         for (i = 0; i < MAX_WIN; i++)
 384                 if (p_dev->_win & CLIENT_WIN_REQ(i))
 385                         dev_info(dev,
 386                                  "pcmcia: driver %s did not release window properly\n",
 387                                  p_drv->name);
 388
 389         /* references from pcmcia_device_probe */
 390         pcmcia_put_dev(p_dev);
 391         module_put(p_drv->owner);
 392
 393         return 0;
 394 }
 395
 396
 397 /*
 398  * pcmcia_device_query -- determine information about a pcmcia device
 399  */
 400 static int pcmcia_device_query(struct pcmcia_device *p_dev)
 401 {
 402         cistpl_manfid_t manf_id;
 403         cistpl_funcid_t func_id;
 404         cistpl_vers_1_t *vers1;
 405         unsigned int i;
 406
 407         vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL);
 408         if (!vers1)
 409                 return -ENOMEM;
 410
 411         if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL,
 412                                CISTPL_MANFID, &manf_id)) {
 413                 mutex_lock(&p_dev->socket->ops_mutex);
 414                 p_dev->manf_id = manf_id.manf;
 415                 p_dev->card_id = manf_id.card;
 416                 p_dev->has_manf_id = 1;
 417                 p_dev->has_card_id = 1;
 418                 mutex_unlock(&p_dev->socket->ops_mutex);
 419         }
 420
 421         if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 422                                CISTPL_FUNCID, &func_id)) {
 423                 mutex_lock(&p_dev->socket->ops_mutex);
 424                 p_dev->func_id = func_id.func;
 425                 p_dev->has_func_id = 1;
 426                 mutex_unlock(&p_dev->socket->ops_mutex);
 427         } else {
 428                 /* rule of thumb: cards with no FUNCID, but with
 429                  * common memory device geometry information, are
 430                  * probably memory cards (from pcmcia-cs) */
 431                 cistpl_device_geo_t *devgeo;
 432
 433                 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL);
 434                 if (!devgeo) {
 435                         kfree(vers1);
 436                         return -ENOMEM;
 437                 }
 438                 if (!pccard_read_tuple(p_dev->socket, p_dev->func,
 439                                       CISTPL_DEVICE_GEO, devgeo)) {
 440                         dev_dbg(&p_dev->dev,
 441                                    "mem device geometry probably means "
 442                                    "FUNCID_MEMORY\n");
 443                         mutex_lock(&p_dev->socket->ops_mutex);
 444                         p_dev->func_id = CISTPL_FUNCID_MEMORY;
 445                         p_dev->has_func_id = 1;
 446                         mutex_unlock(&p_dev->socket->ops_mutex);
 447                 }
 448                 kfree(devgeo);
 449         }
 450
 451         if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1,
 452                                vers1)) {
 453                 mutex_lock(&p_dev->socket->ops_mutex);
 454                 for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) {
 455                         char *tmp;
 456                         unsigned int length;
 457                         char *new;
 458
 459                         tmp = vers1->str + vers1->ofs[i];
 460
 461                         length = strlen(tmp) + 1;
 462                         if ((length < 2) || (length > 255))
 463                                 continue;
 464
 465                         new = kstrdup(tmp, GFP_KERNEL);
 466                         if (!new)
 467                                 continue;
 468
 469                         tmp = p_dev->prod_id[i];
 470                         p_dev->prod_id[i] = new;
 471                         kfree(tmp);
 472                 }
 473                 mutex_unlock(&p_dev->socket->ops_mutex);
 474         }
 475
 476         kfree(vers1);
 477         return 0;
 478 }
 479
 480
 481 static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s,
 482                                                unsigned int function)
 483 {
 484         struct pcmcia_device *p_dev, *tmp_dev;
 485         int i;
 486
 487         s = pcmcia_get_socket(s);
 488         if (!s)
 489                 return NULL;
 490
 491         pr_debug("adding device to %d, function %d\n", s->sock, function);
 492
 493         p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL);
 494         if (!p_dev)
 495                 goto err_put;
 496
 497         mutex_lock(&s->ops_mutex);
 498         p_dev->device_no = (s->device_count++);
 499         mutex_unlock(&s->ops_mutex);
 500
 501         /* max of 2 PFC devices */
 502         if ((p_dev->device_no >= 2) && (function == 0))
 503                 goto err_free;
 504
 505         /* max of 4 devices overall */
 506         if (p_dev->device_no >= 4)
 507                 goto err_free;
 508
 509         p_dev->socket = s;
 510         p_dev->func   = function;
 511
 512         p_dev->dev.bus = &pcmcia_bus_type;
 513         p_dev->dev.parent = s->dev.parent;
 514         p_dev->dev.release = pcmcia_release_dev;
 515         /* by default don't allow DMA */
 516         p_dev->dma_mask = 0;
 517         p_dev->dev.dma_mask = &p_dev->dma_mask;
 518         dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
 519         if (!dev_name(&p_dev->dev))
 520                 goto err_free;
 521         p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
 522         if (!p_dev->devname)
 523                 goto err_free;
 524         dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
 525
 526         mutex_lock(&s->ops_mutex);
 527
 528         /*
 529          * p_dev->function_config must be the same for all card functions.
 530          * Note that this is serialized by ops_mutex, so that only one
 531          * such struct will be created.
 532          */
 533         list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
 534                 if (p_dev->func == tmp_dev->func) {
 535                         p_dev->function_config = tmp_dev->function_config;
 536                         p_dev->irq = tmp_dev->irq;
 537                         kref_get(&p_dev->function_config->ref);
 538                 }
 539
 540         /* Add to the list in pcmcia_bus_socket */
 541         list_add(&p_dev->socket_device_list, &s->devices_list);
 542
 543         if (pcmcia_setup_irq(p_dev))
 544                 dev_warn(&p_dev->dev,
 545                         "IRQ setup failed -- device might not work\n");
 546
 547         if (!p_dev->function_config) {
 548                 config_t *c;
 549                 dev_dbg(&p_dev->dev, "creating config_t\n");
 550                 c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
 551                 if (!c) {
 552                         mutex_unlock(&s->ops_mutex);
 553                         goto err_unreg;
 554                 }
 555                 p_dev->function_config = c;
 556                 kref_init(&c->ref);
 557                 for (i = 0; i < MAX_IO_WIN; i++) {
 558                         c->io[i].name = p_dev->devname;
 559                         c->io[i].flags = IORESOURCE_IO;
 560                 }
 561                 for (i = 0; i < MAX_WIN; i++) {
 562                         c->mem[i].name = p_dev->devname;
 563                         c->mem[i].flags = IORESOURCE_MEM;
 564                 }
 565         }
 566         for (i = 0; i < MAX_IO_WIN; i++)
 567                 p_dev->resource[i] = &p_dev->function_config->io[i];
 568         for (; i < (MAX_IO_WIN + MAX_WIN); i++)
 569                 p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
 570
 571         mutex_unlock(&s->ops_mutex);
 572
 573         dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
 574                    p_dev->devname, p_dev->irq);
 575
 576         pcmcia_device_query(p_dev);
 577
 578         if (device_register(&p_dev->dev))
 579                 goto err_unreg;
 580
 581         return p_dev;
 582
 583  err_unreg:
 584         mutex_lock(&s->ops_mutex);
 585         list_del(&p_dev->socket_device_list);
 586         mutex_unlock(&s->ops_mutex);
 587
 588  err_free:
 589         mutex_lock(&s->ops_mutex);
 590         s->device_count--;
 591         mutex_unlock(&s->ops_mutex);
 592
 593         for (i = 0; i < 4; i++)
 594                 kfree(p_dev->prod_id[i]);
 595         kfree(p_dev->devname);
 596         kfree(p_dev);
 597  err_put:
 598         pcmcia_put_socket(s);
 599
 600         return NULL;
 601 }
 602
 603
 604 static int pcmcia_card_add(struct pcmcia_socket *s)
 605 {
 606         cistpl_longlink_mfc_t mfc;
 607         unsigned int no_funcs, i, no_chains;
 608         int ret = -EAGAIN;
 609
 610         mutex_lock(&s->ops_mutex);
 611         if (!(s->resource_setup_done)) {
 612                 dev_dbg(&s->dev,
 613                            "no resources available, delaying card_add\n");
 614                 mutex_unlock(&s->ops_mutex);
 615                 return -EAGAIN; /* try again, but later... */
 616         }
 617
 618         if (pcmcia_validate_mem(s)) {
 619                 dev_dbg(&s->dev, "validating mem resources failed, "
 620                        "delaying card_add\n");
 621                 mutex_unlock(&s->ops_mutex);
 622                 return -EAGAIN; /* try again, but later... */
 623         }
 624         mutex_unlock(&s->ops_mutex);
 625
 626         ret = pccard_validate_cis(s, &no_chains);
 627         if (ret || !no_chains) {
 628 #if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)
 629                 /* Set up as an anonymous card. If we don't have anonymous
 630                    memory support then just error the card as there is no
 631                    point trying to second guess.
 632
 633                    Note: some cards have just a device entry, it may be
 634                    worth extending support to cover these in future */
 635                 if (ret == -EIO) {
 636                         dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
 637                         pcmcia_replace_cis(s, "\xFF", 1);
 638                         no_chains = 1;
 639                         ret = 0;
 640                 } else
 641 #endif
 642                 {
 643                         dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
 644                         return -ENODEV;
 645                 }
 646         }
 647
 648         if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
 649                 no_funcs = mfc.nfn;
 650         else
 651                 no_funcs = 1;
 652         s->functions = no_funcs;
 653
 654         for (i = 0; i < no_funcs; i++)
 655                 pcmcia_device_add(s, i);
 656
 657         return ret;
 658 }
 659
 660
 661 static int pcmcia_requery_callback(struct device *dev, void *_data)
 662 {
 663         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 664         if (!p_dev->dev.driver) {
 665                 dev_dbg(dev, "update device information\n");
 666                 pcmcia_device_query(p_dev);
 667         }
 668
 669         return 0;
 670 }
 671
 672
 673 static void pcmcia_requery(struct pcmcia_socket *s)
 674 {
 675         int has_pfc;
 676
 677         if (!(s->state & SOCKET_PRESENT))
 678                 return;
 679
 680         if (s->functions == 0) {
 681                 pcmcia_card_add(s);
 682                 return;
 683         }
 684
 685         /* some device information might have changed because of a CIS
 686          * update or because we can finally read it correctly... so
 687          * determine it again, overwriting old values if necessary. */
 688         bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);
 689
 690         /* if the CIS changed, we need to check whether the number of
 691          * functions changed. */
 692         if (s->fake_cis) {
 693                 int old_funcs, new_funcs;
 694                 cistpl_longlink_mfc_t mfc;
 695
 696                 /* does this cis override add or remove functions? */
 697                 old_funcs = s->functions;
 698
 699                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 700                                         &mfc))
 701                         new_funcs = mfc.nfn;
 702                 else
 703                         new_funcs = 1;
 704                 if (old_funcs != new_funcs) {
 705                         /* we need to re-start */
 706                         pcmcia_card_remove(s, NULL);
 707                         s->functions = 0;
 708                         pcmcia_card_add(s);
 709                 }
 710         }
 711
 712         /* If the PCMCIA device consists of two pseudo devices,
 713          * call pcmcia_device_add() -- which will fail if both
 714          * devices are already registered. */
 715         mutex_lock(&s->ops_mutex);
 716         has_pfc = s->pcmcia_pfc;
 717         mutex_unlock(&s->ops_mutex);
 718         if (has_pfc)
 719                 pcmcia_device_add(s, 0);
 720
 721         /* we re-scan all devices, not just the ones connected to this
 722          * socket. This does not matter, though. */
 723         if (bus_rescan_devices(&pcmcia_bus_type))
 724                 dev_warn(&s->dev, "rescanning the bus failed\n");
 725 }
 726
 727
 728 #ifdef CONFIG_PCMCIA_LOAD_CIS
 729
 730 /**
 731  * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
 732  * @dev: the pcmcia device which needs a CIS override
 733  * @filename: requested filename in /lib/firmware/
 734  *
 735  * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
 736  * the one provided by the card is broken. The firmware files reside in
 737  * /lib/firmware/ in userspace.
 738  */
 739 static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
 740 {
 741         struct pcmcia_socket *s = dev->socket;
 742         const struct firmware *fw;
 743         int ret = -ENOMEM;
 744         cistpl_longlink_mfc_t mfc;
 745         int old_funcs, new_funcs = 1;
 746
 747         if (!filename)
 748                 return -EINVAL;
 749
 750         dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
 751
 752         if (request_firmware(&fw, filename, &dev->dev) == 0) {
 753                 if (fw->size >= CISTPL_MAX_CIS_SIZE) {
 754                         ret = -EINVAL;
 755                         dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
 756                         goto release;
 757                 }
 758
 759                 if (!pcmcia_replace_cis(s, fw->data, fw->size))
 760                         ret = 0;
 761                 else {
 762                         dev_err(&dev->dev, "pcmcia: CIS override failed\n");
 763                         goto release;
 764                 }
 765
 766                 /* we need to re-start if the number of functions changed */
 767                 old_funcs = s->functions;
 768                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 769                                         &mfc))
 770                         new_funcs = mfc.nfn;
 771
 772                 if (old_funcs != new_funcs)
 773                         ret = -EBUSY;
 774
 775                 /* update information */
 776                 pcmcia_device_query(dev);
 777
 778                 /* requery (as number of functions might have changed) */
 779                 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 780         }
 781  release:
 782         release_firmware(fw);
 783
 784         return ret;
 785 }
 786
 787 #else /* !CONFIG_PCMCIA_LOAD_CIS */
 788
 789 static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
 790                                        char *filename)
 791 {
 792         return -ENODEV;
 793 }
 794
 795 #endif
 796
 797
 798 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 799                                   const struct pcmcia_device_id *did)
 800 {
 801         if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
 802                 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
 803                         return 0;
 804         }
 805
 806         if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
 807                 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
 808                         return 0;
 809         }
 810
 811         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
 812                 if (dev->func != did->function)
 813                         return 0;
 814         }
 815
 816         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
 817                 if (!dev->prod_id[0])
 818                         return 0;
 819                 if (strcmp(did->prod_id[0], dev->prod_id[0]))
 820                         return 0;
 821         }
 822
 823         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
 824                 if (!dev->prod_id[1])
 825                         return 0;
 826                 if (strcmp(did->prod_id[1], dev->prod_id[1]))
 827                         return 0;
 828         }
 829
 830         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
 831                 if (!dev->prod_id[2])
 832                         return 0;
 833                 if (strcmp(did->prod_id[2], dev->prod_id[2]))
 834                         return 0;
 835         }
 836
 837         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
 838                 if (!dev->prod_id[3])
 839                         return 0;
 840                 if (strcmp(did->prod_id[3], dev->prod_id[3]))
 841                         return 0;
 842         }
 843
 844         if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
 845                 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
 846                 mutex_lock(&dev->socket->ops_mutex);
 847                 dev->socket->pcmcia_pfc = 1;
 848                 mutex_unlock(&dev->socket->ops_mutex);
 849                 if (dev->device_no != did->device_no)
 850                         return 0;
 851         }
 852
 853         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
 854                 int ret;
 855
 856                 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
 857                         return 0;
 858
 859                 /* if this is a pseudo-multi-function device,
 860                  * we need explicit matches */
 861                 if (dev->socket->pcmcia_pfc)
 862                         return 0;
 863                 if (dev->device_no)
 864                         return 0;
 865
 866                 /* also, FUNC_ID matching needs to be activated by userspace
 867                  * after it has re-checked that there is no possible module
 868                  * with a prod_id/manf_id/card_id match.
 869                  */
 870                 mutex_lock(&dev->socket->ops_mutex);
 871                 ret = dev->allow_func_id_match;
 872                 mutex_unlock(&dev->socket->ops_mutex);
 873
 874                 if (!ret) {
 875                         dev_dbg(&dev->dev,
 876                                 "skipping FUNC_ID match until userspace ACK\n");
 877                         return 0;
 878                 }
 879         }
 880
 881         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
 882                 dev_dbg(&dev->dev, "device needs a fake CIS\n");
 883                 if (!dev->socket->fake_cis)
 884                         if (pcmcia_load_firmware(dev, did->cisfile))
 885                                 return 0;
 886         }
 887
 888         if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
 889                 int i;
 890                 for (i = 0; i < 4; i++)
 891                         if (dev->prod_id[i])
 892                                 return 0;
 893                 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
 894                         return 0;
 895         }
 896
 897         return 1;
 898 }
 899
 900
 901 static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
 902 {
 903         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 904         struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
 905         const struct pcmcia_device_id *did = p_drv->id_table;
 906         struct pcmcia_dynid *dynid;
 907
 908         /* match dynamic devices first */
 909         mutex_lock(&p_drv->dynids.lock);
 910         list_for_each_entry(dynid, &p_drv->dynids.list, node) {
 911                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 912                 if (pcmcia_devmatch(p_dev, &dynid->id)) {
 913                         dev_dbg(dev, "matched to %s\n", drv->name);
 914                         mutex_unlock(&p_drv->dynids.lock);
 915                         return 1;
 916                 }
 917         }
 918         mutex_unlock(&p_drv->dynids.lock);
 919
 920         while (did && did->match_flags) {
 921                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 922                 if (pcmcia_devmatch(p_dev, did)) {
 923                         dev_dbg(dev, "matched to %s\n", drv->name);
 924                         return 1;
 925                 }
 926                 did++;
 927         }
 928
 929         return 0;
 930 }
 931
 932 static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
 933 {
 934         struct pcmcia_device *p_dev;
 935         int i;
 936         u32 hash[4] = { 0, 0, 0, 0};
 937
 938         if (!dev)
 939                 return -ENODEV;
 940
 941         p_dev = to_pcmcia_dev(dev);
 942
 943         /* calculate hashes */
 944         for (i = 0; i < 4; i++) {
 945                 if (!p_dev->prod_id[i])
 946                         continue;
 947                 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
 948         }
 949
 950         if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
 951                 return -ENOMEM;
 952
 953         if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
 954                 return -ENOMEM;
 955
 956         if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
 957                            "pa%08Xpb%08Xpc%08Xpd%08X",
 958                            p_dev->has_manf_id ? p_dev->manf_id : 0,
 959                            p_dev->has_card_id ? p_dev->card_id : 0,
 960                            p_dev->has_func_id ? p_dev->func_id : 0,
 961                            p_dev->func,
 962                            p_dev->device_no,
 963                            hash[0],
 964                            hash[1],
 965                            hash[2],
 966                            hash[3]))
 967                 return -ENOMEM;
 968
 969         return 0;
 970 }
 971
 972 /************************ runtime PM support ***************************/
 973
 974 static int pcmcia_dev_suspend(struct device *dev);
 975 static int pcmcia_dev_resume(struct device *dev);
 976
 977 static int runtime_suspend(struct device *dev)
 978 {
 979         int rc;
 980
 981         device_lock(dev);
 982         rc = pcmcia_dev_suspend(dev);
 983         device_unlock(dev);
 984         return rc;
 985 }
 986
 987 static int runtime_resume(struct device *dev)
 988 {
 989         int rc;
 990
 991         device_lock(dev);
 992         rc = pcmcia_dev_resume(dev);
 993         device_unlock(dev);
 994         return rc;
 995 }
 996
 997 /************************ per-device sysfs output ***************************/
 998
 999 #define pcmcia_device_attr(field, test, format)                         \
1000 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)              \
1001 {                                                                       \
1002         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1003         return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \
1004 }                                                                       \
1005 static DEVICE_ATTR_RO(field);
1006
1007 #define pcmcia_device_stringattr(name, field)                                   \
1008 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)               \
1009 {                                                                       \
1010         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1011         return p_dev->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \
1012 }                                                                       \
1013 static DEVICE_ATTR_RO(name);
1014
1015 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
1016 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
1017 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
1018 pcmcia_device_stringattr(prod_id1, prod_id[0]);
1019 pcmcia_device_stringattr(prod_id2, prod_id[1]);
1020 pcmcia_device_stringattr(prod_id3, prod_id[2]);
1021 pcmcia_device_stringattr(prod_id4, prod_id[3]);
1022
1023 static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1024                              char *buf)
1025 {
1026         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1027         return p_dev->socket ? sprintf(buf, "0x%02x\n", p_dev->func) : -ENODEV;
1028 }
1029 static DEVICE_ATTR_RO(function);
1030
1031 static ssize_t resources_show(struct device *dev,
1032                               struct device_attribute *attr, char *buf)
1033 {
1034         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1035         char *str = buf;
1036         int i;
1037
1038         for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1039                 str += sprintf(str, "%pr\n", p_dev->resource[i]);
1040
1041         return str - buf;
1042 }
1043 static DEVICE_ATTR_RO(resources);
1044
1045 static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1046 {
1047         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1048
1049         if (p_dev->suspended)
1050                 return sprintf(buf, "off\n");
1051         else
1052                 return sprintf(buf, "on\n");
1053 }
1054
1055 static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1056                               const char *buf, size_t count)
1057 {
1058         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1059         int ret = 0;
1060
1061         if (!count)
1062                 return -EINVAL;
1063
1064         if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
1065                 ret = runtime_suspend(dev);
1066         else if (p_dev->suspended && !strncmp(buf, "on", 2))
1067                 ret = runtime_resume(dev);
1068
1069         return ret ? ret : count;
1070 }
1071 static DEVICE_ATTR_RW(pm_state);
1072
1073 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1074 {
1075         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1076         int i;
1077         u32 hash[4] = { 0, 0, 0, 0};
1078
1079         /* calculate hashes */
1080         for (i = 0; i < 4; i++) {
1081                 if (!p_dev->prod_id[i])
1082                         continue;
1083                 hash[i] = crc32(0, p_dev->prod_id[i],
1084                                 strlen(p_dev->prod_id[i]));
1085         }
1086         return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
1087                                 "pa%08Xpb%08Xpc%08Xpd%08X\n",
1088                                 p_dev->has_manf_id ? p_dev->manf_id : 0,
1089                                 p_dev->has_card_id ? p_dev->card_id : 0,
1090                                 p_dev->has_func_id ? p_dev->func_id : 0,
1091                                 p_dev->func, p_dev->device_no,
1092                                 hash[0], hash[1], hash[2], hash[3]);
1093 }
1094 static DEVICE_ATTR_RO(modalias);
1095
1096 static ssize_t allow_func_id_match_store(struct device *dev,
1097                 struct device_attribute *attr, const char *buf, size_t count)
1098 {
1099         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1100
1101         if (!count)
1102                 return -EINVAL;
1103
1104         mutex_lock(&p_dev->socket->ops_mutex);
1105         p_dev->allow_func_id_match = 1;
1106         mutex_unlock(&p_dev->socket->ops_mutex);
1107         pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY);
1108
1109         return count;
1110 }
1111 static DEVICE_ATTR_WO(allow_func_id_match);
1112
1113 static struct attribute *pcmcia_dev_attrs[] = {
1114         &dev_attr_resources.attr,
1115         &dev_attr_pm_state.attr,
1116         &dev_attr_function.attr,
1117         &dev_attr_func_id.attr,
1118         &dev_attr_manf_id.attr,
1119         &dev_attr_card_id.attr,
1120         &dev_attr_prod_id1.attr,
1121         &dev_attr_prod_id2.attr,
1122         &dev_attr_prod_id3.attr,
1123         &dev_attr_prod_id4.attr,
1124         &dev_attr_modalias.attr,
1125         &dev_attr_allow_func_id_match.attr,
1126         NULL,
1127 };
1128 ATTRIBUTE_GROUPS(pcmcia_dev);
1129
1130 /* PM support, also needed for reset */
1131
1132 static int pcmcia_dev_suspend(struct device *dev)
1133 {
1134         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1135         struct pcmcia_driver *p_drv = NULL;
1136         int ret = 0;
1137
1138         mutex_lock(&p_dev->socket->ops_mutex);
1139         if (p_dev->suspended) {
1140                 mutex_unlock(&p_dev->socket->ops_mutex);
1141                 return 0;
1142         }
1143         p_dev->suspended = 1;
1144         mutex_unlock(&p_dev->socket->ops_mutex);
1145
1146         dev_dbg(dev, "suspending\n");
1147
1148         if (dev->driver)
1149                 p_drv = to_pcmcia_drv(dev->driver);
1150
1151         if (!p_drv)
1152                 goto out;
1153
1154         if (p_drv->suspend) {
1155                 ret = p_drv->suspend(p_dev);
1156                 if (ret) {
1157                         dev_err(dev,
1158                                 "pcmcia: device %s (driver %s) did not want to go to sleep (%d)\n",
1159                                 p_dev->devname, p_drv->name, ret);
1160                         mutex_lock(&p_dev->socket->ops_mutex);
1161                         p_dev->suspended = 0;
1162                         mutex_unlock(&p_dev->socket->ops_mutex);
1163                         goto out;
1164                 }
1165         }
1166
1167         if (p_dev->device_no == p_dev->func) {
1168                 dev_dbg(dev, "releasing configuration\n");
1169                 pcmcia_release_configuration(p_dev);
1170         }
1171
1172  out:
1173         return ret;
1174 }
1175
1176
1177 static int pcmcia_dev_resume(struct device *dev)
1178 {
1179         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1180         struct pcmcia_driver *p_drv = NULL;
1181         int ret = 0;
1182
1183         mutex_lock(&p_dev->socket->ops_mutex);
1184         if (!p_dev->suspended) {
1185                 mutex_unlock(&p_dev->socket->ops_mutex);
1186                 return 0;
1187         }
1188         p_dev->suspended = 0;
1189         mutex_unlock(&p_dev->socket->ops_mutex);
1190
1191         dev_dbg(dev, "resuming\n");
1192
1193         if (dev->driver)
1194                 p_drv = to_pcmcia_drv(dev->driver);
1195
1196         if (!p_drv)
1197                 goto out;
1198
1199         if (p_dev->device_no == p_dev->func) {
1200                 dev_dbg(dev, "requesting configuration\n");
1201                 ret = pcmcia_enable_device(p_dev);
1202                 if (ret)
1203                         goto out;
1204         }
1205
1206         if (p_drv->resume)
1207                 ret = p_drv->resume(p_dev);
1208
1209  out:
1210         return ret;
1211 }
1212
1213
1214 static int pcmcia_bus_suspend_callback(struct device *dev, void *_data)
1215 {
1216         struct pcmcia_socket *skt = _data;
1217         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1218
1219         if (p_dev->socket != skt || p_dev->suspended)
1220                 return 0;
1221
1222         return runtime_suspend(dev);
1223 }
1224
1225 static int pcmcia_bus_resume_callback(struct device *dev, void *_data)
1226 {
1227         struct pcmcia_socket *skt = _data;
1228         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1229
1230         if (p_dev->socket != skt || !p_dev->suspended)
1231                 return 0;
1232
1233         runtime_resume(dev);
1234
1235         return 0;
1236 }
1237
1238 static int pcmcia_bus_resume(struct pcmcia_socket *skt)
1239 {
1240         dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock);
1241         bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback);
1242         return 0;
1243 }
1244
1245 static int pcmcia_bus_suspend(struct pcmcia_socket *skt)
1246 {
1247         dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock);
1248         if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt,
1249                              pcmcia_bus_suspend_callback)) {
1250                 pcmcia_bus_resume(skt);
1251                 return -EIO;
1252         }
1253         return 0;
1254 }
1255
1256 static int pcmcia_bus_remove(struct pcmcia_socket *skt)
1257 {
1258         atomic_set(&skt->present, 0);
1259         pcmcia_card_remove(skt, NULL);
1260
1261         mutex_lock(&skt->ops_mutex);
1262         destroy_cis_cache(skt);
1263         pcmcia_cleanup_irq(skt);
1264         mutex_unlock(&skt->ops_mutex);
1265
1266         return 0;
1267 }
1268
1269 static int pcmcia_bus_add(struct pcmcia_socket *skt)
1270 {
1271         atomic_set(&skt->present, 1);
1272
1273         mutex_lock(&skt->ops_mutex);
1274         skt->pcmcia_pfc = 0;
1275         destroy_cis_cache(skt); /* to be on the safe side... */
1276         mutex_unlock(&skt->ops_mutex);
1277
1278         pcmcia_card_add(skt);
1279
1280         return 0;
1281 }
1282
1283 static int pcmcia_bus_early_resume(struct pcmcia_socket *skt)
1284 {
1285         if (!verify_cis_cache(skt))
1286                 return 0;
1287
1288         dev_dbg(&skt->dev, "cis mismatch - different card\n");
1289
1290         /* first, remove the card */
1291         pcmcia_bus_remove(skt);
1292
1293         mutex_lock(&skt->ops_mutex);
1294         destroy_cis_cache(skt);
1295         kfree(skt->fake_cis);
1296         skt->fake_cis = NULL;
1297         skt->functions = 0;
1298         mutex_unlock(&skt->ops_mutex);
1299
1300         /* now, add the new card */
1301         pcmcia_bus_add(skt);
1302         return 0;
1303 }
1304
1305
1306 /*
1307  * NOTE: This is racy. There's no guarantee the card will still be
1308  * physically present, even if the call to this function returns
1309  * non-NULL. Furthermore, the device driver most likely is unbound
1310  * almost immediately, so the timeframe where pcmcia_dev_present
1311  * returns NULL is probably really really small.
1312  */
1313 struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev)
1314 {
1315         struct pcmcia_device *p_dev;
1316         struct pcmcia_device *ret = NULL;
1317
1318         p_dev = pcmcia_get_dev(_p_dev);
1319         if (!p_dev)
1320                 return NULL;
1321
1322         if (atomic_read(&p_dev->socket->present) != 0)
1323                 ret = p_dev;
1324
1325         pcmcia_put_dev(p_dev);
1326         return ret;
1327 }
1328 EXPORT_SYMBOL(pcmcia_dev_present);
1329
1330
1331 static struct pcmcia_callback pcmcia_bus_callback = {
1332         .owner = THIS_MODULE,
1333         .add = pcmcia_bus_add,
1334         .remove = pcmcia_bus_remove,
1335         .requery = pcmcia_requery,
1336         .validate = pccard_validate_cis,
1337         .suspend = pcmcia_bus_suspend,
1338         .early_resume = pcmcia_bus_early_resume,
1339         .resume = pcmcia_bus_resume,
1340 };
1341
1342 static int pcmcia_bus_add_socket(struct device *dev,
1343                                            struct class_interface *class_intf)
1344 {
1345         struct pcmcia_socket *socket = dev_get_drvdata(dev);
1346         int ret;
1347
1348         socket = pcmcia_get_socket(socket);
1349         if (!socket) {
1350                 dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1351                 return -ENODEV;
1352         }
1353
1354         ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1355         if (ret) {
1356                 dev_err(dev, "PCMCIA registration failed\n");
1357                 pcmcia_put_socket(socket);
1358                 return ret;
1359         }
1360
1361         INIT_LIST_HEAD(&socket->devices_list);
1362         socket->pcmcia_pfc = 0;
1363         socket->device_count = 0;
1364         atomic_set(&socket->present, 0);
1365
1366         ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1367         if (ret) {
1368                 dev_err(dev, "PCMCIA registration failed\n");
1369                 pcmcia_put_socket(socket);
1370                 return ret;
1371         }
1372
1373         return 0;
1374 }
1375
1376 static void pcmcia_bus_remove_socket(struct device *dev,
1377                                      struct class_interface *class_intf)
1378 {
1379         struct pcmcia_socket *socket = dev_get_drvdata(dev);
1380
1381         if (!socket)
1382                 return;
1383
1384         pccard_register_pcmcia(socket, NULL);
1385
1386         /* unregister any unbound devices */
1387         mutex_lock(&socket->skt_mutex);
1388         pcmcia_card_remove(socket, NULL);
1389         release_cis_mem(socket);
1390         mutex_unlock(&socket->skt_mutex);
1391
1392         sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr);
1393
1394         pcmcia_put_socket(socket);
1395
1396         return;
1397 }
1398
1399
1400 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */
1401 static struct class_interface pcmcia_bus_interface __refdata = {
1402         .class = &pcmcia_socket_class,
1403         .add_dev = &pcmcia_bus_add_socket,
1404         .remove_dev = &pcmcia_bus_remove_socket,
1405 };
1406
1407 static const struct dev_pm_ops pcmcia_bus_pm_ops = {
1408         SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume)
1409 };
1410
1411 struct bus_type pcmcia_bus_type = {
1412         .name = "pcmcia",
1413         .uevent = pcmcia_bus_uevent,
1414         .match = pcmcia_bus_match,
1415         .dev_groups = pcmcia_dev_groups,
1416         .probe = pcmcia_device_probe,
1417         .remove = pcmcia_device_remove,
1418         .pm = &pcmcia_bus_pm_ops,
1419 };
1420
1421
1422 static int __init init_pcmcia_bus(void)
1423 {
1424         int ret;
1425
1426         ret = bus_register(&pcmcia_bus_type);
1427         if (ret < 0) {
1428                 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret);
1429                 return ret;
1430         }
1431         ret = class_interface_register(&pcmcia_bus_interface);
1432         if (ret < 0) {
1433                 printk(KERN_WARNING
1434                         "pcmcia: class_interface_register error: %d\n", ret);
1435                 bus_unregister(&pcmcia_bus_type);
1436                 return ret;
1437         }
1438
1439         return 0;
1440 }
1441 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that
1442                                * pcmcia_socket_class is already registered */
1443
1444
1445 static void __exit exit_pcmcia_bus(void)
1446 {
1447         class_interface_unregister(&pcmcia_bus_interface);
1448
1449         bus_unregister(&pcmcia_bus_type);
1450 }
1451 module_exit(exit_pcmcia_bus);
1452
1453
1454 MODULE_ALIAS("ds");