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