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