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 * 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 */ 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->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 return 0; 394 } 395 396 397 /* 398 * pcmcia_device_query -- determine information about a pcmcia device 399 */ 400 static int pcmcia_device_query(struct pcmcia_device *p_dev) 401 { 402 cistpl_manfid_t manf_id; 403 cistpl_funcid_t func_id; 404 cistpl_vers_1_t *vers1; 405 unsigned int i; 406 407 vers1 = kmalloc(sizeof(*vers1), GFP_KERNEL); 408 if (!vers1) 409 return -ENOMEM; 410 411 if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, 412 CISTPL_MANFID, &manf_id)) { 413 mutex_lock(&p_dev->socket->ops_mutex); 414 p_dev->manf_id = manf_id.manf; 415 p_dev->card_id = manf_id.card; 416 p_dev->has_manf_id = 1; 417 p_dev->has_card_id = 1; 418 mutex_unlock(&p_dev->socket->ops_mutex); 419 } 420 421 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 422 CISTPL_FUNCID, &func_id)) { 423 mutex_lock(&p_dev->socket->ops_mutex); 424 p_dev->func_id = func_id.func; 425 p_dev->has_func_id = 1; 426 mutex_unlock(&p_dev->socket->ops_mutex); 427 } else { 428 /* rule of thumb: cards with no FUNCID, but with 429 * common memory device geometry information, are 430 * probably memory cards (from pcmcia-cs) */ 431 cistpl_device_geo_t *devgeo; 432 433 devgeo = kmalloc(sizeof(*devgeo), GFP_KERNEL); 434 if (!devgeo) { 435 kfree(vers1); 436 return -ENOMEM; 437 } 438 if (!pccard_read_tuple(p_dev->socket, p_dev->func, 439 CISTPL_DEVICE_GEO, devgeo)) { 440 dev_dbg(&p_dev->dev, 441 "mem device geometry probably means " 442 "FUNCID_MEMORY\n"); 443 mutex_lock(&p_dev->socket->ops_mutex); 444 p_dev->func_id = CISTPL_FUNCID_MEMORY; 445 p_dev->has_func_id = 1; 446 mutex_unlock(&p_dev->socket->ops_mutex); 447 } 448 kfree(devgeo); 449 } 450 451 if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1, 452 vers1)) { 453 mutex_lock(&p_dev->socket->ops_mutex); 454 for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) { 455 char *tmp; 456 unsigned int length; 457 char *new; 458 459 tmp = vers1->str + vers1->ofs[i]; 460 461 length = strlen(tmp) + 1; 462 if ((length < 2) || (length > 255)) 463 continue; 464 465 new = kstrdup(tmp, GFP_KERNEL); 466 if (!new) 467 continue; 468 469 tmp = p_dev->prod_id[i]; 470 p_dev->prod_id[i] = new; 471 kfree(tmp); 472 } 473 mutex_unlock(&p_dev->socket->ops_mutex); 474 } 475 476 kfree(vers1); 477 return 0; 478 } 479 480 481 static struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, 482 unsigned int function) 483 { 484 struct pcmcia_device *p_dev, *tmp_dev; 485 int i; 486 487 s = pcmcia_get_socket(s); 488 if (!s) 489 return NULL; 490 491 pr_debug("adding device to %d, function %d\n", s->sock, function); 492 493 p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL); 494 if (!p_dev) 495 goto err_put; 496 497 mutex_lock(&s->ops_mutex); 498 p_dev->device_no = (s->device_count++); 499 mutex_unlock(&s->ops_mutex); 500 501 /* max of 2 PFC devices */ 502 if ((p_dev->device_no >= 2) && (function == 0)) 503 goto err_free; 504 505 /* max of 4 devices overall */ 506 if (p_dev->device_no >= 4) 507 goto err_free; 508 509 p_dev->socket = s; 510 p_dev->func = function; 511 512 p_dev->dev.bus = &pcmcia_bus_type; 513 p_dev->dev.parent = s->dev.parent; 514 p_dev->dev.release = pcmcia_release_dev; 515 /* by default don't allow DMA */ 516 p_dev->dma_mask = 0; 517 p_dev->dev.dma_mask = &p_dev->dma_mask; 518 dev_set_name(&p_dev->dev, "%d.%d", p_dev->socket->sock, p_dev->device_no); 519 if (!dev_name(&p_dev->dev)) 520 goto err_free; 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 if (device_register(&p_dev->dev)) 579 goto err_unreg; 580 581 return p_dev; 582 583 err_unreg: 584 mutex_lock(&s->ops_mutex); 585 list_del(&p_dev->socket_device_list); 586 mutex_unlock(&s->ops_mutex); 587 588 err_free: 589 mutex_lock(&s->ops_mutex); 590 s->device_count--; 591 mutex_unlock(&s->ops_mutex); 592 593 for (i = 0; i < 4; i++) 594 kfree(p_dev->prod_id[i]); 595 kfree(p_dev->devname); 596 kfree(p_dev); 597 err_put: 598 pcmcia_put_socket(s); 599 600 return NULL; 601 } 602 603 604 static int pcmcia_card_add(struct pcmcia_socket *s) 605 { 606 cistpl_longlink_mfc_t mfc; 607 unsigned int no_funcs, i, no_chains; 608 int ret = -EAGAIN; 609 610 mutex_lock(&s->ops_mutex); 611 if (!(s->resource_setup_done)) { 612 dev_dbg(&s->dev, 613 "no resources available, delaying card_add\n"); 614 mutex_unlock(&s->ops_mutex); 615 return -EAGAIN; /* try again, but later... */ 616 } 617 618 if (pcmcia_validate_mem(s)) { 619 dev_dbg(&s->dev, "validating mem resources failed, " 620 "delaying card_add\n"); 621 mutex_unlock(&s->ops_mutex); 622 return -EAGAIN; /* try again, but later... */ 623 } 624 mutex_unlock(&s->ops_mutex); 625 626 ret = pccard_validate_cis(s, &no_chains); 627 if (ret || !no_chains) { 628 #if defined(CONFIG_MTD_PCMCIA_ANONYMOUS) 629 /* Set up as an anonymous card. If we don't have anonymous 630 memory support then just error the card as there is no 631 point trying to second guess. 632 633 Note: some cards have just a device entry, it may be 634 worth extending support to cover these in future */ 635 if (ret == -EIO) { 636 dev_info(&s->dev, "no CIS, assuming an anonymous memory card.\n"); 637 pcmcia_replace_cis(s, "\xFF", 1); 638 no_chains = 1; 639 ret = 0; 640 } else 641 #endif 642 { 643 dev_dbg(&s->dev, "invalid CIS or invalid resources\n"); 644 return -ENODEV; 645 } 646 } 647 648 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) 649 no_funcs = mfc.nfn; 650 else 651 no_funcs = 1; 652 s->functions = no_funcs; 653 654 for (i = 0; i < no_funcs; i++) 655 pcmcia_device_add(s, i); 656 657 return ret; 658 } 659 660 661 static int pcmcia_requery_callback(struct device *dev, void *_data) 662 { 663 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 664 if (!p_dev->dev.driver) { 665 dev_dbg(dev, "update device information\n"); 666 pcmcia_device_query(p_dev); 667 } 668 669 return 0; 670 } 671 672 673 static void pcmcia_requery(struct pcmcia_socket *s) 674 { 675 int has_pfc; 676 677 if (!(s->state & SOCKET_PRESENT)) 678 return; 679 680 if (s->functions == 0) { 681 pcmcia_card_add(s); 682 return; 683 } 684 685 /* some device information might have changed because of a CIS 686 * update or because we can finally read it correctly... so 687 * determine it again, overwriting old values if necessary. */ 688 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback); 689 690 /* if the CIS changed, we need to check whether the number of 691 * functions changed. */ 692 if (s->fake_cis) { 693 int old_funcs, new_funcs; 694 cistpl_longlink_mfc_t mfc; 695 696 /* does this cis override add or remove functions? */ 697 old_funcs = s->functions; 698 699 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, 700 &mfc)) 701 new_funcs = mfc.nfn; 702 else 703 new_funcs = 1; 704 if (old_funcs != new_funcs) { 705 /* we need to re-start */ 706 pcmcia_card_remove(s, NULL); 707 s->functions = 0; 708 pcmcia_card_add(s); 709 } 710 } 711 712 /* If the PCMCIA device consists of two pseudo devices, 713 * call pcmcia_device_add() -- which will fail if both 714 * devices are already registered. */ 715 mutex_lock(&s->ops_mutex); 716 has_pfc = s->pcmcia_pfc; 717 mutex_unlock(&s->ops_mutex); 718 if (has_pfc) 719 pcmcia_device_add(s, 0); 720 721 /* we re-scan all devices, not just the ones connected to this 722 * socket. This does not matter, though. */ 723 if (bus_rescan_devices(&pcmcia_bus_type)) 724 dev_warn(&s->dev, "rescanning the bus failed\n"); 725 } 726 727 728 #ifdef CONFIG_PCMCIA_LOAD_CIS 729 730 /** 731 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken 732 * @dev: the pcmcia device which needs a CIS override 733 * @filename: requested filename in /lib/firmware/ 734 * 735 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if 736 * the one provided by the card is broken. The firmware files reside in 737 * /lib/firmware/ in userspace. 738 */ 739 static int pcmcia_load_firmware(struct pcmcia_device *dev, char *filename) 740 { 741 struct pcmcia_socket *s = dev->socket; 742 const struct firmware *fw; 743 int ret = -ENOMEM; 744 cistpl_longlink_mfc_t mfc; 745 int old_funcs, new_funcs = 1; 746 747 if (!filename) 748 return -EINVAL; 749 750 dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename); 751 752 if (request_firmware(&fw, filename, &dev->dev) == 0) { 753 if (fw->size >= CISTPL_MAX_CIS_SIZE) { 754 ret = -EINVAL; 755 dev_err(&dev->dev, "pcmcia: CIS override is too big\n"); 756 goto release; 757 } 758 759 if (!pcmcia_replace_cis(s, fw->data, fw->size)) 760 ret = 0; 761 else { 762 dev_err(&dev->dev, "pcmcia: CIS override failed\n"); 763 goto release; 764 } 765 766 /* we need to re-start if the number of functions changed */ 767 old_funcs = s->functions; 768 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, 769 &mfc)) 770 new_funcs = mfc.nfn; 771 772 if (old_funcs != new_funcs) 773 ret = -EBUSY; 774 775 /* update information */ 776 pcmcia_device_query(dev); 777 778 /* requery (as number of functions might have changed) */ 779 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY); 780 } 781 release: 782 release_firmware(fw); 783 784 return ret; 785 } 786 787 #else /* !CONFIG_PCMCIA_LOAD_CIS */ 788 789 static inline int pcmcia_load_firmware(struct pcmcia_device *dev, 790 char *filename) 791 { 792 return -ENODEV; 793 } 794 795 #endif 796 797 798 static inline int pcmcia_devmatch(struct pcmcia_device *dev, 799 const struct pcmcia_device_id *did) 800 { 801 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) { 802 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id)) 803 return 0; 804 } 805 806 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) { 807 if ((!dev->has_card_id) || (dev->card_id != did->card_id)) 808 return 0; 809 } 810 811 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) { 812 if (dev->func != did->function) 813 return 0; 814 } 815 816 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) { 817 if (!dev->prod_id[0]) 818 return 0; 819 if (strcmp(did->prod_id[0], dev->prod_id[0])) 820 return 0; 821 } 822 823 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) { 824 if (!dev->prod_id[1]) 825 return 0; 826 if (strcmp(did->prod_id[1], dev->prod_id[1])) 827 return 0; 828 } 829 830 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) { 831 if (!dev->prod_id[2]) 832 return 0; 833 if (strcmp(did->prod_id[2], dev->prod_id[2])) 834 return 0; 835 } 836 837 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) { 838 if (!dev->prod_id[3]) 839 return 0; 840 if (strcmp(did->prod_id[3], dev->prod_id[3])) 841 return 0; 842 } 843 844 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) { 845 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n"); 846 mutex_lock(&dev->socket->ops_mutex); 847 dev->socket->pcmcia_pfc = 1; 848 mutex_unlock(&dev->socket->ops_mutex); 849 if (dev->device_no != did->device_no) 850 return 0; 851 } 852 853 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) { 854 int ret; 855 856 if ((!dev->has_func_id) || (dev->func_id != did->func_id)) 857 return 0; 858 859 /* if this is a pseudo-multi-function device, 860 * we need explicit matches */ 861 if (dev->socket->pcmcia_pfc) 862 return 0; 863 if (dev->device_no) 864 return 0; 865 866 /* also, FUNC_ID matching needs to be activated by userspace 867 * after it has re-checked that there is no possible module 868 * with a prod_id/manf_id/card_id match. 869 */ 870 mutex_lock(&dev->socket->ops_mutex); 871 ret = dev->allow_func_id_match; 872 mutex_unlock(&dev->socket->ops_mutex); 873 874 if (!ret) { 875 dev_dbg(&dev->dev, 876 "skipping FUNC_ID match until userspace ACK\n"); 877 return 0; 878 } 879 } 880 881 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) { 882 dev_dbg(&dev->dev, "device needs a fake CIS\n"); 883 if (!dev->socket->fake_cis) 884 if (pcmcia_load_firmware(dev, did->cisfile)) 885 return 0; 886 } 887 888 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) { 889 int i; 890 for (i = 0; i < 4; i++) 891 if (dev->prod_id[i]) 892 return 0; 893 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id) 894 return 0; 895 } 896 897 return 1; 898 } 899 900 901 static int pcmcia_bus_match(struct device *dev, struct device_driver *drv) 902 { 903 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 904 struct pcmcia_driver *p_drv = to_pcmcia_drv(drv); 905 const struct pcmcia_device_id *did = p_drv->id_table; 906 struct pcmcia_dynid *dynid; 907 908 /* match dynamic devices first */ 909 mutex_lock(&p_drv->dynids.lock); 910 list_for_each_entry(dynid, &p_drv->dynids.list, node) { 911 dev_dbg(dev, "trying to match to %s\n", drv->name); 912 if (pcmcia_devmatch(p_dev, &dynid->id)) { 913 dev_dbg(dev, "matched to %s\n", drv->name); 914 mutex_unlock(&p_drv->dynids.lock); 915 return 1; 916 } 917 } 918 mutex_unlock(&p_drv->dynids.lock); 919 920 while (did && did->match_flags) { 921 dev_dbg(dev, "trying to match to %s\n", drv->name); 922 if (pcmcia_devmatch(p_dev, did)) { 923 dev_dbg(dev, "matched to %s\n", drv->name); 924 return 1; 925 } 926 did++; 927 } 928 929 return 0; 930 } 931 932 static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 933 { 934 struct pcmcia_device *p_dev; 935 int i; 936 u32 hash[4] = { 0, 0, 0, 0}; 937 938 if (!dev) 939 return -ENODEV; 940 941 p_dev = to_pcmcia_dev(dev); 942 943 /* calculate hashes */ 944 for (i = 0; i < 4; i++) { 945 if (!p_dev->prod_id[i]) 946 continue; 947 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i])); 948 } 949 950 if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock)) 951 return -ENOMEM; 952 953 if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no)) 954 return -ENOMEM; 955 956 if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 957 "pa%08Xpb%08Xpc%08Xpd%08X", 958 p_dev->has_manf_id ? p_dev->manf_id : 0, 959 p_dev->has_card_id ? p_dev->card_id : 0, 960 p_dev->has_func_id ? p_dev->func_id : 0, 961 p_dev->func, 962 p_dev->device_no, 963 hash[0], 964 hash[1], 965 hash[2], 966 hash[3])) 967 return -ENOMEM; 968 969 return 0; 970 } 971 972 /************************ runtime PM support ***************************/ 973 974 static int pcmcia_dev_suspend(struct device *dev); 975 static int pcmcia_dev_resume(struct device *dev); 976 977 static int runtime_suspend(struct device *dev) 978 { 979 int rc; 980 981 device_lock(dev); 982 rc = pcmcia_dev_suspend(dev); 983 device_unlock(dev); 984 return rc; 985 } 986 987 static int runtime_resume(struct device *dev) 988 { 989 int rc; 990 991 device_lock(dev); 992 rc = pcmcia_dev_resume(dev); 993 device_unlock(dev); 994 return rc; 995 } 996 997 /************************ per-device sysfs output ***************************/ 998 999 #define pcmcia_device_attr(field, test, format) \ 1000 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 1001 { \ 1002 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 1003 return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \ 1004 } \ 1005 static DEVICE_ATTR_RO(field); 1006 1007 #define pcmcia_device_stringattr(name, field) \ 1008 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 1009 { \ 1010 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 1011 return p_dev->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \ 1012 } \ 1013 static DEVICE_ATTR_RO(name); 1014 1015 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n"); 1016 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n"); 1017 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n"); 1018 pcmcia_device_stringattr(prod_id1, prod_id[0]); 1019 pcmcia_device_stringattr(prod_id2, prod_id[1]); 1020 pcmcia_device_stringattr(prod_id3, prod_id[2]); 1021 pcmcia_device_stringattr(prod_id4, prod_id[3]); 1022 1023 static ssize_t function_show(struct device *dev, struct device_attribute *attr, 1024 char *buf) 1025 { 1026 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1027 return p_dev->socket ? sprintf(buf, "0x%02x\n", p_dev->func) : -ENODEV; 1028 } 1029 static DEVICE_ATTR_RO(function); 1030 1031 static ssize_t resources_show(struct device *dev, 1032 struct device_attribute *attr, char *buf) 1033 { 1034 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1035 char *str = buf; 1036 int i; 1037 1038 for (i = 0; i < PCMCIA_NUM_RESOURCES; i++) 1039 str += sprintf(str, "%pr\n", p_dev->resource[i]); 1040 1041 return str - buf; 1042 } 1043 static DEVICE_ATTR_RO(resources); 1044 1045 static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf) 1046 { 1047 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1048 1049 if (p_dev->suspended) 1050 return sprintf(buf, "off\n"); 1051 else 1052 return sprintf(buf, "on\n"); 1053 } 1054 1055 static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr, 1056 const char *buf, size_t count) 1057 { 1058 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1059 int ret = 0; 1060 1061 if (!count) 1062 return -EINVAL; 1063 1064 if ((!p_dev->suspended) && !strncmp(buf, "off", 3)) 1065 ret = runtime_suspend(dev); 1066 else if (p_dev->suspended && !strncmp(buf, "on", 2)) 1067 ret = runtime_resume(dev); 1068 1069 return ret ? ret : count; 1070 } 1071 static DEVICE_ATTR_RW(pm_state); 1072 1073 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 1074 { 1075 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1076 int i; 1077 u32 hash[4] = { 0, 0, 0, 0}; 1078 1079 /* calculate hashes */ 1080 for (i = 0; i < 4; i++) { 1081 if (!p_dev->prod_id[i]) 1082 continue; 1083 hash[i] = crc32(0, p_dev->prod_id[i], 1084 strlen(p_dev->prod_id[i])); 1085 } 1086 return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 1087 "pa%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 } 1094 static DEVICE_ATTR_RO(modalias); 1095 1096 static 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 } 1111 static DEVICE_ATTR_WO(allow_func_id_match); 1112 1113 static 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 }; 1128 ATTRIBUTE_GROUPS(pcmcia_dev); 1129 1130 /* PM support, also needed for reset */ 1131 1132 static 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 1177 static 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 1214 static 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 1225 static 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 1238 static 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 1245 static 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 1256 static 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 1269 static 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 1283 static 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 */ 1313 struct 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 } 1328 EXPORT_SYMBOL(pcmcia_dev_present); 1329 1330 1331 static 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 1342 static int pcmcia_bus_add_socket(struct device *dev, 1343 struct class_interface *class_intf) 1344 { 1345 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1346 int ret; 1347 1348 socket = pcmcia_get_socket(socket); 1349 if (!socket) { 1350 dev_err(dev, "PCMCIA obtaining reference to socket failed\n"); 1351 return -ENODEV; 1352 } 1353 1354 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); 1355 if (ret) { 1356 dev_err(dev, "PCMCIA registration failed\n"); 1357 pcmcia_put_socket(socket); 1358 return ret; 1359 } 1360 1361 INIT_LIST_HEAD(&socket->devices_list); 1362 socket->pcmcia_pfc = 0; 1363 socket->device_count = 0; 1364 atomic_set(&socket->present, 0); 1365 1366 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); 1367 if (ret) { 1368 dev_err(dev, "PCMCIA registration failed\n"); 1369 pcmcia_put_socket(socket); 1370 return ret; 1371 } 1372 1373 return 0; 1374 } 1375 1376 static void pcmcia_bus_remove_socket(struct device *dev, 1377 struct class_interface *class_intf) 1378 { 1379 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1380 1381 if (!socket) 1382 return; 1383 1384 pccard_register_pcmcia(socket, NULL); 1385 1386 /* unregister any unbound devices */ 1387 mutex_lock(&socket->skt_mutex); 1388 pcmcia_card_remove(socket, NULL); 1389 release_cis_mem(socket); 1390 mutex_unlock(&socket->skt_mutex); 1391 1392 sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr); 1393 1394 pcmcia_put_socket(socket); 1395 1396 return; 1397 } 1398 1399 1400 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */ 1401 static struct class_interface pcmcia_bus_interface __refdata = { 1402 .class = &pcmcia_socket_class, 1403 .add_dev = &pcmcia_bus_add_socket, 1404 .remove_dev = &pcmcia_bus_remove_socket, 1405 }; 1406 1407 static const struct dev_pm_ops pcmcia_bus_pm_ops = { 1408 SET_SYSTEM_SLEEP_PM_OPS(pcmcia_dev_suspend, pcmcia_dev_resume) 1409 }; 1410 1411 struct bus_type pcmcia_bus_type = { 1412 .name = "pcmcia", 1413 .uevent = pcmcia_bus_uevent, 1414 .match = pcmcia_bus_match, 1415 .dev_groups = pcmcia_dev_groups, 1416 .probe = pcmcia_device_probe, 1417 .remove = pcmcia_device_remove, 1418 .pm = &pcmcia_bus_pm_ops, 1419 }; 1420 1421 1422 static int __init init_pcmcia_bus(void) 1423 { 1424 int ret; 1425 1426 ret = bus_register(&pcmcia_bus_type); 1427 if (ret < 0) { 1428 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret); 1429 return ret; 1430 } 1431 ret = class_interface_register(&pcmcia_bus_interface); 1432 if (ret < 0) { 1433 printk(KERN_WARNING 1434 "pcmcia: class_interface_register error: %d\n", ret); 1435 bus_unregister(&pcmcia_bus_type); 1436 return ret; 1437 } 1438 1439 return 0; 1440 } 1441 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that 1442 * pcmcia_socket_class is already registered */ 1443 1444 1445 static void __exit exit_pcmcia_bus(void) 1446 { 1447 class_interface_unregister(&pcmcia_bus_interface); 1448 1449 bus_unregister(&pcmcia_bus_type); 1450 } 1451 module_exit(exit_pcmcia_bus); 1452 1453 1454 MODULE_ALIAS("ds"); 1455