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