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