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