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