drivers/pcmcia/ds.c

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