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