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