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         p_dev->devname = kasprintf(GFP_KERNEL, "pcmcia%s", dev_name(&p_dev->dev));
 517         if (!p_dev->devname)
 518                 goto err_free;
 519         dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname);
 520
 521         mutex_lock(&s->ops_mutex);
 522
 523         /*
 524          * p_dev->function_config must be the same for all card functions.
 525          * Note that this is serialized by ops_mutex, so that only one
 526          * such struct will be created.
 527          */
 528         list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
 529                 if (p_dev->func == tmp_dev->func) {
 530                         p_dev->function_config = tmp_dev->function_config;
 531                         p_dev->irq = tmp_dev->irq;
 532                         kref_get(&p_dev->function_config->ref);
 533                 }
 534
 535         /* Add to the list in pcmcia_bus_socket */
 536         list_add(&p_dev->socket_device_list, &s->devices_list);
 537
 538         if (pcmcia_setup_irq(p_dev))
 539                 dev_warn(&p_dev->dev,
 540                         "IRQ setup failed -- device might not work\n");
 541
 542         if (!p_dev->function_config) {
 543                 config_t *c;
 544                 dev_dbg(&p_dev->dev, "creating config_t\n");
 545                 c = kzalloc(sizeof(struct config_t), GFP_KERNEL);
 546                 if (!c) {
 547                         mutex_unlock(&s->ops_mutex);
 548                         goto err_unreg;
 549                 }
 550                 p_dev->function_config = c;
 551                 kref_init(&c->ref);
 552                 for (i = 0; i < MAX_IO_WIN; i++) {
 553                         c->io[i].name = p_dev->devname;
 554                         c->io[i].flags = IORESOURCE_IO;
 555                 }
 556                 for (i = 0; i < MAX_WIN; i++) {
 557                         c->mem[i].name = p_dev->devname;
 558                         c->mem[i].flags = IORESOURCE_MEM;
 559                 }
 560         }
 561         for (i = 0; i < MAX_IO_WIN; i++)
 562                 p_dev->resource[i] = &p_dev->function_config->io[i];
 563         for (; i < (MAX_IO_WIN + MAX_WIN); i++)
 564                 p_dev->resource[i] = &p_dev->function_config->mem[i-MAX_IO_WIN];
 565
 566         mutex_unlock(&s->ops_mutex);
 567
 568         dev_notice(&p_dev->dev, "pcmcia: registering new device %s (IRQ: %d)\n",
 569                    p_dev->devname, p_dev->irq);
 570
 571         pcmcia_device_query(p_dev);
 572
 573         dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no);
 574         if (device_register(&p_dev->dev)) {
 575                 mutex_lock(&s->ops_mutex);
 576                 list_del(&p_dev->socket_device_list);
 577                 s->device_count--;
 578                 mutex_unlock(&s->ops_mutex);
 579                 put_device(&p_dev->dev);
 580                 return NULL;
 581         }
 582
 583         return p_dev;
 584
 585  err_unreg:
 586         mutex_lock(&s->ops_mutex);
 587         list_del(&p_dev->socket_device_list);
 588         mutex_unlock(&s->ops_mutex);
 589
 590  err_free:
 591         mutex_lock(&s->ops_mutex);
 592         s->device_count--;
 593         mutex_unlock(&s->ops_mutex);
 594
 595         for (i = 0; i < 4; i++)
 596                 kfree(p_dev->prod_id[i]);
 597         kfree(p_dev->devname);
 598         kfree(p_dev);
 599  err_put:
 600         pcmcia_put_socket(s);
 601
 602         return NULL;
 603 }
 604
 605
 606 static int pcmcia_card_add(struct pcmcia_socket *s)
 607 {
 608         cistpl_longlink_mfc_t mfc;
 609         unsigned int no_funcs, i, no_chains;
 610         int ret = -EAGAIN;
 611
 612         mutex_lock(&s->ops_mutex);
 613         if (!(s->resource_setup_done)) {
 614                 dev_dbg(&s->dev,
 615                            "no resources available, delaying card_add\n");
 616                 mutex_unlock(&s->ops_mutex);
 617                 return -EAGAIN; /* try again, but later... */
 618         }
 619
 620         if (pcmcia_validate_mem(s)) {
 621                 dev_dbg(&s->dev, "validating mem resources failed, "
 622                        "delaying card_add\n");
 623                 mutex_unlock(&s->ops_mutex);
 624                 return -EAGAIN; /* try again, but later... */
 625         }
 626         mutex_unlock(&s->ops_mutex);
 627
 628         ret = pccard_validate_cis(s, &no_chains);
 629         if (ret || !no_chains) {
 630 #if defined(CONFIG_MTD_PCMCIA_ANONYMOUS)
 631                 /* Set up as an anonymous card. If we don't have anonymous
 632                    memory support then just error the card as there is no
 633                    point trying to second guess.
 634
 635                    Note: some cards have just a device entry, it may be
 636                    worth extending support to cover these in future */
 637                 if (ret == -EIO) {
 638                         dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n");
 639                         pcmcia_replace_cis(s, "\xFF", 1);
 640                         no_chains = 1;
 641                         ret = 0;
 642                 } else
 643 #endif
 644                 {
 645                         dev_dbg(&s->dev, "invalid CIS or invalid resources\n");
 646                         return -ENODEV;
 647                 }
 648         }
 649
 650         if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc))
 651                 no_funcs = mfc.nfn;
 652         else
 653                 no_funcs = 1;
 654         s->functions = no_funcs;
 655
 656         for (i = 0; i < no_funcs; i++)
 657                 pcmcia_device_add(s, i);
 658
 659         return ret;
 660 }
 661
 662
 663 static int pcmcia_requery_callback(struct device *dev, void *_data)
 664 {
 665         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 666         if (!p_dev->dev.driver) {
 667                 dev_dbg(dev, "update device information\n");
 668                 pcmcia_device_query(p_dev);
 669         }
 670
 671         return 0;
 672 }
 673
 674
 675 static void pcmcia_requery(struct pcmcia_socket *s)
 676 {
 677         int has_pfc;
 678
 679         if (!(s->state & SOCKET_PRESENT))
 680                 return;
 681
 682         if (s->functions == 0) {
 683                 pcmcia_card_add(s);
 684                 return;
 685         }
 686
 687         /* some device information might have changed because of a CIS
 688          * update or because we can finally read it correctly... so
 689          * determine it again, overwriting old values if necessary. */
 690         bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback);
 691
 692         /* if the CIS changed, we need to check whether the number of
 693          * functions changed. */
 694         if (s->fake_cis) {
 695                 int old_funcs, new_funcs;
 696                 cistpl_longlink_mfc_t mfc;
 697
 698                 /* does this cis override add or remove functions? */
 699                 old_funcs = s->functions;
 700
 701                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 702                                         &mfc))
 703                         new_funcs = mfc.nfn;
 704                 else
 705                         new_funcs = 1;
 706                 if (old_funcs != new_funcs) {
 707                         /* we need to re-start */
 708                         pcmcia_card_remove(s, NULL);
 709                         s->functions = 0;
 710                         pcmcia_card_add(s);
 711                 }
 712         }
 713
 714         /* If the PCMCIA device consists of two pseudo devices,
 715          * call pcmcia_device_add() -- which will fail if both
 716          * devices are already registered. */
 717         mutex_lock(&s->ops_mutex);
 718         has_pfc = s->pcmcia_pfc;
 719         mutex_unlock(&s->ops_mutex);
 720         if (has_pfc)
 721                 pcmcia_device_add(s, 0);
 722
 723         /* we re-scan all devices, not just the ones connected to this
 724          * socket. This does not matter, though. */
 725         if (bus_rescan_devices(&pcmcia_bus_type))
 726                 dev_warn(&s->dev, "rescanning the bus failed\n");
 727 }
 728
 729
 730 #ifdef CONFIG_PCMCIA_LOAD_CIS
 731
 732 /**
 733  * pcmcia_load_firmware - load CIS from userspace if device-provided is broken
 734  * @dev: the pcmcia device which needs a CIS override
 735  * @filename: requested filename in /lib/firmware/
 736  *
 737  * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
 738  * the one provided by the card is broken. The firmware files reside in
 739  * /lib/firmware/ in userspace.
 740  */
 741 static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename)
 742 {
 743         struct pcmcia_socket *s = dev->socket;
 744         const struct firmware *fw;
 745         int ret = -ENOMEM;
 746         cistpl_longlink_mfc_t mfc;
 747         int old_funcs, new_funcs = 1;
 748
 749         if (!filename)
 750                 return -EINVAL;
 751
 752         dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename);
 753
 754         if (request_firmware(&fw, filename, &dev->dev) == 0) {
 755                 if (fw->size >= CISTPL_MAX_CIS_SIZE) {
 756                         ret = -EINVAL;
 757                         dev_err(&dev->dev, "pcmcia: CIS override is too big\n");
 758                         goto release;
 759                 }
 760
 761                 if (!pcmcia_replace_cis(s, fw->data, fw->size))
 762                         ret = 0;
 763                 else {
 764                         dev_err(&dev->dev, "pcmcia: CIS override failed\n");
 765                         goto release;
 766                 }
 767
 768                 /* we need to re-start if the number of functions changed */
 769                 old_funcs = s->functions;
 770                 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC,
 771                                         &mfc))
 772                         new_funcs = mfc.nfn;
 773
 774                 if (old_funcs != new_funcs)
 775                         ret = -EBUSY;
 776
 777                 /* update information */
 778                 pcmcia_device_query(dev);
 779
 780                 /* requery (as number of functions might have changed) */
 781                 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY);
 782         }
 783  release:
 784         release_firmware(fw);
 785
 786         return ret;
 787 }
 788
 789 #else /* !CONFIG_PCMCIA_LOAD_CIS */
 790
 791 static inline int pcmcia_load_firmware(struct pcmcia_device *dev,
 792                                        char *filename)
 793 {
 794         return -ENODEV;
 795 }
 796
 797 #endif
 798
 799
 800 static inline int pcmcia_devmatch(struct pcmcia_device *dev,
 801                                   const struct pcmcia_device_id *did)
 802 {
 803         if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) {
 804                 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id))
 805                         return 0;
 806         }
 807
 808         if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) {
 809                 if ((!dev->has_card_id) || (dev->card_id != did->card_id))
 810                         return 0;
 811         }
 812
 813         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) {
 814                 if (dev->func != did->function)
 815                         return 0;
 816         }
 817
 818         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) {
 819                 if (!dev->prod_id[0])
 820                         return 0;
 821                 if (strcmp(did->prod_id[0], dev->prod_id[0]))
 822                         return 0;
 823         }
 824
 825         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) {
 826                 if (!dev->prod_id[1])
 827                         return 0;
 828                 if (strcmp(did->prod_id[1], dev->prod_id[1]))
 829                         return 0;
 830         }
 831
 832         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) {
 833                 if (!dev->prod_id[2])
 834                         return 0;
 835                 if (strcmp(did->prod_id[2], dev->prod_id[2]))
 836                         return 0;
 837         }
 838
 839         if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) {
 840                 if (!dev->prod_id[3])
 841                         return 0;
 842                 if (strcmp(did->prod_id[3], dev->prod_id[3]))
 843                         return 0;
 844         }
 845
 846         if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) {
 847                 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n");
 848                 mutex_lock(&dev->socket->ops_mutex);
 849                 dev->socket->pcmcia_pfc = 1;
 850                 mutex_unlock(&dev->socket->ops_mutex);
 851                 if (dev->device_no != did->device_no)
 852                         return 0;
 853         }
 854
 855         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) {
 856                 int ret;
 857
 858                 if ((!dev->has_func_id) || (dev->func_id != did->func_id))
 859                         return 0;
 860
 861                 /* if this is a pseudo-multi-function device,
 862                  * we need explicit matches */
 863                 if (dev->socket->pcmcia_pfc)
 864                         return 0;
 865                 if (dev->device_no)
 866                         return 0;
 867
 868                 /* also, FUNC_ID matching needs to be activated by userspace
 869                  * after it has re-checked that there is no possible module
 870                  * with a prod_id/manf_id/card_id match.
 871                  */
 872                 mutex_lock(&dev->socket->ops_mutex);
 873                 ret = dev->allow_func_id_match;
 874                 mutex_unlock(&dev->socket->ops_mutex);
 875
 876                 if (!ret) {
 877                         dev_dbg(&dev->dev,
 878                                 "skipping FUNC_ID match until userspace ACK\n");
 879                         return 0;
 880                 }
 881         }
 882
 883         if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) {
 884                 dev_dbg(&dev->dev, "device needs a fake CIS\n");
 885                 if (!dev->socket->fake_cis)
 886                         if (pcmcia_load_firmware(dev, did->cisfile))
 887                                 return 0;
 888         }
 889
 890         if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) {
 891                 int i;
 892                 for (i = 0; i < 4; i++)
 893                         if (dev->prod_id[i])
 894                                 return 0;
 895                 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id)
 896                         return 0;
 897         }
 898
 899         return 1;
 900 }
 901
 902
 903 static int pcmcia_bus_match(struct device *dev, struct device_driver *drv)
 904 {
 905         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
 906         struct pcmcia_driver *p_drv = to_pcmcia_drv(drv);
 907         const struct pcmcia_device_id *did = p_drv->id_table;
 908         struct pcmcia_dynid *dynid;
 909
 910         /* match dynamic devices first */
 911         mutex_lock(&p_drv->dynids.lock);
 912         list_for_each_entry(dynid, &p_drv->dynids.list, node) {
 913                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 914                 if (pcmcia_devmatch(p_dev, &dynid->id)) {
 915                         dev_dbg(dev, "matched to %s\n", drv->name);
 916                         mutex_unlock(&p_drv->dynids.lock);
 917                         return 1;
 918                 }
 919         }
 920         mutex_unlock(&p_drv->dynids.lock);
 921
 922         while (did && did->match_flags) {
 923                 dev_dbg(dev, "trying to match to %s\n", drv->name);
 924                 if (pcmcia_devmatch(p_dev, did)) {
 925                         dev_dbg(dev, "matched to %s\n", drv->name);
 926                         return 1;
 927                 }
 928                 did++;
 929         }
 930
 931         return 0;
 932 }
 933
 934 static int pcmcia_bus_uevent(const struct device *dev, struct kobj_uevent_env *env)
 935 {
 936         const struct pcmcia_device *p_dev;
 937         int i;
 938         u32 hash[4] = { 0, 0, 0, 0};
 939
 940         if (!dev)
 941                 return -ENODEV;
 942
 943         p_dev = to_pcmcia_dev(dev);
 944
 945         /* calculate hashes */
 946         for (i = 0; i < 4; i++) {
 947                 if (!p_dev->prod_id[i])
 948                         continue;
 949                 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i]));
 950         }
 951
 952         if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock))
 953                 return -ENOMEM;
 954
 955         if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no))
 956                 return -ENOMEM;
 957
 958         if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X"
 959                            "pa%08Xpb%08Xpc%08Xpd%08X",
 960                            p_dev->has_manf_id ? p_dev->manf_id : 0,
 961                            p_dev->has_card_id ? p_dev->card_id : 0,
 962                            p_dev->has_func_id ? p_dev->func_id : 0,
 963                            p_dev->func,
 964                            p_dev->device_no,
 965                            hash[0],
 966                            hash[1],
 967                            hash[2],
 968                            hash[3]))
 969                 return -ENOMEM;
 970
 971         return 0;
 972 }
 973
 974 /************************ runtime PM support ***************************/
 975
 976 static int pcmcia_dev_suspend(struct device *dev);
 977 static int pcmcia_dev_resume(struct device *dev);
 978
 979 static int runtime_suspend(struct device *dev)
 980 {
 981         int rc;
 982
 983         device_lock(dev);
 984         rc = pcmcia_dev_suspend(dev);
 985         device_unlock(dev);
 986         return rc;
 987 }
 988
 989 static int runtime_resume(struct device *dev)
 990 {
 991         int rc;
 992
 993         device_lock(dev);
 994         rc = pcmcia_dev_resume(dev);
 995         device_unlock(dev);
 996         return rc;
 997 }
 998
 999 /************************ per-device sysfs output ***************************/
1000
1001 #define pcmcia_device_attr(field, test, format)                         \
1002 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf)              \
1003 {                                                                       \
1004         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1005         return p_dev->test ? sysfs_emit(buf, format, p_dev->field) : -ENODEV; \
1006 }                                                                       \
1007 static DEVICE_ATTR_RO(field);
1008
1009 #define pcmcia_device_stringattr(name, field)                                   \
1010 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf)               \
1011 {                                                                       \
1012         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);               \
1013         return p_dev->field ? sysfs_emit(buf, "%s\n", p_dev->field) : -ENODEV; \
1014 }                                                                       \
1015 static DEVICE_ATTR_RO(name);
1016
1017 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n");
1018 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n");
1019 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n");
1020 pcmcia_device_stringattr(prod_id1, prod_id[0]);
1021 pcmcia_device_stringattr(prod_id2, prod_id[1]);
1022 pcmcia_device_stringattr(prod_id3, prod_id[2]);
1023 pcmcia_device_stringattr(prod_id4, prod_id[3]);
1024
1025 static ssize_t function_show(struct device *dev, struct device_attribute *attr,
1026                              char *buf)
1027 {
1028         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1029         return p_dev->socket ? sysfs_emit(buf, "0x%02x\n", p_dev->func) : -ENODEV;
1030 }
1031 static DEVICE_ATTR_RO(function);
1032
1033 static ssize_t resources_show(struct device *dev,
1034                               struct device_attribute *attr, char *buf)
1035 {
1036         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1037         int i, at = 0;
1038
1039         for (i = 0; i < PCMCIA_NUM_RESOURCES; i++)
1040                 at += sysfs_emit_at(buf, at, "%pr\n", p_dev->resource[i]);
1041
1042         return at;
1043 }
1044 static DEVICE_ATTR_RO(resources);
1045
1046 static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf)
1047 {
1048         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1049
1050         if (p_dev->suspended)
1051                 return sysfs_emit(buf, "off\n");
1052         else
1053                 return sysfs_emit(buf, "on\n");
1054 }
1055
1056 static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr,
1057                               const char *buf, size_t count)
1058 {
1059         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1060         int ret = 0;
1061
1062         if (!count)
1063                 return -EINVAL;
1064
1065         if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
1066                 ret = runtime_suspend(dev);
1067         else if (p_dev->suspended && !strncmp(buf, "on", 2))
1068                 ret = runtime_resume(dev);
1069
1070         return ret ? ret : count;
1071 }
1072 static DEVICE_ATTR_RW(pm_state);
1073
1074 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
1075 {
1076         struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
1077         int i;
1078         u32 hash[4] = { 0, 0, 0, 0};
1079
1080         /* calculate hashes */
1081         for (i = 0; i < 4; i++) {
1082                 if (!p_dev->prod_id[i])
1083                         continue;
1084                 hash[i] = crc32(0, p_dev->prod_id[i],
1085                                 strlen(p_dev->prod_id[i]));
1086         }
1087         return sysfs_emit(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02Xpa%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 {
1344         struct pcmcia_socket *socket = dev_get_drvdata(dev);
1345         int ret;
1346
1347         socket = pcmcia_get_socket(socket);
1348         if (!socket) {
1349                 dev_err(dev, "PCMCIA obtaining reference to socket failed\n");
1350                 return -ENODEV;
1351         }
1352
1353         ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr);
1354         if (ret) {
1355                 dev_err(dev, "PCMCIA registration failed\n");
1356                 pcmcia_put_socket(socket);
1357                 return ret;
1358         }
1359
1360         INIT_LIST_HEAD(&socket->devices_list);
1361         socket->pcmcia_pfc = 0;
1362         socket->device_count = 0;
1363         atomic_set(&socket->present, 0);
1364
1365         ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
1366         if (ret) {
1367                 dev_err(dev, "PCMCIA registration failed\n");
1368                 pcmcia_put_socket(socket);
1369                 return ret;
1370         }
1371
1372         return 0;
1373 }
1374
1375 static void pcmcia_bus_remove_socket(struct device *dev)
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");