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