drivers/pcmcia/ds.c

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

DEFINITIONS
