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 #ifdef CONFIG_HOTPLUG 924 925 static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 926 { 927 struct pcmcia_device *p_dev; 928 int i; 929 u32 hash[4] = { 0, 0, 0, 0}; 930 931 if (!dev) 932 return -ENODEV; 933 934 p_dev = to_pcmcia_dev(dev); 935 936 /* calculate hashes */ 937 for (i = 0; i < 4; i++) { 938 if (!p_dev->prod_id[i]) 939 continue; 940 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i])); 941 } 942 943 if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock)) 944 return -ENOMEM; 945 946 if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no)) 947 return -ENOMEM; 948 949 if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 950 "pa%08Xpb%08Xpc%08Xpd%08X", 951 p_dev->has_manf_id ? p_dev->manf_id : 0, 952 p_dev->has_card_id ? p_dev->card_id : 0, 953 p_dev->has_func_id ? p_dev->func_id : 0, 954 p_dev->func, 955 p_dev->device_no, 956 hash[0], 957 hash[1], 958 hash[2], 959 hash[3])) 960 return -ENOMEM; 961 962 return 0; 963 } 964 965 #else 966 967 static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 968 { 969 return -ENODEV; 970 } 971 972 #endif 973 974 /************************ runtime PM support ***************************/ 975 976 static int pcmcia_dev_suspend(struct device *dev, pm_message_t state); 977 static int pcmcia_dev_resume(struct device *dev); 978 979 static int runtime_suspend(struct device *dev) 980 { 981 int rc; 982 983 device_lock(dev); 984 rc = pcmcia_dev_suspend(dev, PMSG_SUSPEND); 985 device_unlock(dev); 986 return rc; 987 } 988 989 static int runtime_resume(struct device *dev) 990 { 991 int rc; 992 993 device_lock(dev); 994 rc = pcmcia_dev_resume(dev); 995 device_unlock(dev); 996 return rc; 997 } 998 999 /************************ per-device sysfs output ***************************/ 1000 1001 #define pcmcia_device_attr(field, test, format) \ 1002 static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 1003 { \ 1004 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 1005 return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \ 1006 } 1007 1008 #define pcmcia_device_stringattr(name, field) \ 1009 static ssize_t name##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 1010 { \ 1011 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 1012 return p_dev->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \ 1013 } 1014 1015 pcmcia_device_attr(func, socket, "0x%02x\n"); 1016 pcmcia_device_attr(func_id, has_func_id, "0x%02x\n"); 1017 pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n"); 1018 pcmcia_device_attr(card_id, has_card_id, "0x%04x\n"); 1019 pcmcia_device_stringattr(prod_id1, prod_id[0]); 1020 pcmcia_device_stringattr(prod_id2, prod_id[1]); 1021 pcmcia_device_stringattr(prod_id3, prod_id[2]); 1022 pcmcia_device_stringattr(prod_id4, prod_id[3]); 1023 1024 static ssize_t pcmcia_show_resources(struct device *dev, 1025 struct device_attribute *attr, char *buf) 1026 { 1027 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1028 char *str = buf; 1029 int i; 1030 1031 for (i = 0; i < PCMCIA_NUM_RESOURCES; i++) 1032 str += sprintf(str, "%pr\n", p_dev->resource[i]); 1033 1034 return str - buf; 1035 } 1036 1037 static ssize_t pcmcia_show_pm_state(struct device *dev, struct device_attribute *attr, char *buf) 1038 { 1039 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1040 1041 if (p_dev->suspended) 1042 return sprintf(buf, "off\n"); 1043 else 1044 return sprintf(buf, "on\n"); 1045 } 1046 1047 static ssize_t pcmcia_store_pm_state(struct device *dev, struct device_attribute *attr, 1048 const char *buf, size_t count) 1049 { 1050 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1051 int ret = 0; 1052 1053 if (!count) 1054 return -EINVAL; 1055 1056 if ((!p_dev->suspended) && !strncmp(buf, "off", 3)) 1057 ret = runtime_suspend(dev); 1058 else if (p_dev->suspended && !strncmp(buf, "on", 2)) 1059 ret = runtime_resume(dev); 1060 1061 return ret ? ret : count; 1062 } 1063 1064 1065 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 1066 { 1067 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1068 int i; 1069 u32 hash[4] = { 0, 0, 0, 0}; 1070 1071 /* calculate hashes */ 1072 for (i = 0; i < 4; i++) { 1073 if (!p_dev->prod_id[i]) 1074 continue; 1075 hash[i] = crc32(0, p_dev->prod_id[i], 1076 strlen(p_dev->prod_id[i])); 1077 } 1078 return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 1079 "pa%08Xpb%08Xpc%08Xpd%08X\n", 1080 p_dev->has_manf_id ? p_dev->manf_id : 0, 1081 p_dev->has_card_id ? p_dev->card_id : 0, 1082 p_dev->has_func_id ? p_dev->func_id : 0, 1083 p_dev->func, p_dev->device_no, 1084 hash[0], hash[1], hash[2], hash[3]); 1085 } 1086 1087 static ssize_t pcmcia_store_allow_func_id_match(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 1103 static struct device_attribute pcmcia_dev_attrs[] = { 1104 __ATTR(function, 0444, func_show, NULL), 1105 __ATTR(pm_state, 0644, pcmcia_show_pm_state, pcmcia_store_pm_state), 1106 __ATTR(resources, 0444, pcmcia_show_resources, NULL), 1107 __ATTR_RO(func_id), 1108 __ATTR_RO(manf_id), 1109 __ATTR_RO(card_id), 1110 __ATTR_RO(prod_id1), 1111 __ATTR_RO(prod_id2), 1112 __ATTR_RO(prod_id3), 1113 __ATTR_RO(prod_id4), 1114 __ATTR_RO(modalias), 1115 __ATTR(allow_func_id_match, 0200, NULL, pcmcia_store_allow_func_id_match), 1116 __ATTR_NULL, 1117 }; 1118 1119 /* PM support, also needed for reset */ 1120 1121 static int pcmcia_dev_suspend(struct device *dev, pm_message_t state) 1122 { 1123 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1124 struct pcmcia_driver *p_drv = NULL; 1125 int ret = 0; 1126 1127 mutex_lock(&p_dev->socket->ops_mutex); 1128 if (p_dev->suspended) { 1129 mutex_unlock(&p_dev->socket->ops_mutex); 1130 return 0; 1131 } 1132 p_dev->suspended = 1; 1133 mutex_unlock(&p_dev->socket->ops_mutex); 1134 1135 dev_dbg(dev, "suspending\n"); 1136 1137 if (dev->driver) 1138 p_drv = to_pcmcia_drv(dev->driver); 1139 1140 if (!p_drv) 1141 goto out; 1142 1143 if (p_drv->suspend) { 1144 ret = p_drv->suspend(p_dev); 1145 if (ret) { 1146 dev_printk(KERN_ERR, dev, 1147 "pcmcia: device %s (driver %s) did " 1148 "not want to go to sleep (%d)\n", 1149 p_dev->devname, p_drv->name, ret); 1150 mutex_lock(&p_dev->socket->ops_mutex); 1151 p_dev->suspended = 0; 1152 mutex_unlock(&p_dev->socket->ops_mutex); 1153 goto out; 1154 } 1155 } 1156 1157 if (p_dev->device_no == p_dev->func) { 1158 dev_dbg(dev, "releasing configuration\n"); 1159 pcmcia_release_configuration(p_dev); 1160 } 1161 1162 out: 1163 return ret; 1164 } 1165 1166 1167 static int pcmcia_dev_resume(struct device *dev) 1168 { 1169 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1170 struct pcmcia_driver *p_drv = NULL; 1171 int ret = 0; 1172 1173 mutex_lock(&p_dev->socket->ops_mutex); 1174 if (!p_dev->suspended) { 1175 mutex_unlock(&p_dev->socket->ops_mutex); 1176 return 0; 1177 } 1178 p_dev->suspended = 0; 1179 mutex_unlock(&p_dev->socket->ops_mutex); 1180 1181 dev_dbg(dev, "resuming\n"); 1182 1183 if (dev->driver) 1184 p_drv = to_pcmcia_drv(dev->driver); 1185 1186 if (!p_drv) 1187 goto out; 1188 1189 if (p_dev->device_no == p_dev->func) { 1190 dev_dbg(dev, "requesting configuration\n"); 1191 ret = pcmcia_enable_device(p_dev); 1192 if (ret) 1193 goto out; 1194 } 1195 1196 if (p_drv->resume) 1197 ret = p_drv->resume(p_dev); 1198 1199 out: 1200 return ret; 1201 } 1202 1203 1204 static int pcmcia_bus_suspend_callback(struct device *dev, void * _data) 1205 { 1206 struct pcmcia_socket *skt = _data; 1207 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1208 1209 if (p_dev->socket != skt || p_dev->suspended) 1210 return 0; 1211 1212 return runtime_suspend(dev); 1213 } 1214 1215 static int pcmcia_bus_resume_callback(struct device *dev, void * _data) 1216 { 1217 struct pcmcia_socket *skt = _data; 1218 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1219 1220 if (p_dev->socket != skt || !p_dev->suspended) 1221 return 0; 1222 1223 runtime_resume(dev); 1224 1225 return 0; 1226 } 1227 1228 static int pcmcia_bus_resume(struct pcmcia_socket *skt) 1229 { 1230 dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock); 1231 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback); 1232 return 0; 1233 } 1234 1235 static int pcmcia_bus_suspend(struct pcmcia_socket *skt) 1236 { 1237 dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock); 1238 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt, 1239 pcmcia_bus_suspend_callback)) { 1240 pcmcia_bus_resume(skt); 1241 return -EIO; 1242 } 1243 return 0; 1244 } 1245 1246 static int pcmcia_bus_remove(struct pcmcia_socket *skt) 1247 { 1248 atomic_set(&skt->present, 0); 1249 pcmcia_card_remove(skt, NULL); 1250 1251 mutex_lock(&skt->ops_mutex); 1252 destroy_cis_cache(skt); 1253 pcmcia_cleanup_irq(skt); 1254 mutex_unlock(&skt->ops_mutex); 1255 1256 return 0; 1257 } 1258 1259 static int pcmcia_bus_add(struct pcmcia_socket *skt) 1260 { 1261 atomic_set(&skt->present, 1); 1262 1263 mutex_lock(&skt->ops_mutex); 1264 skt->pcmcia_pfc = 0; 1265 destroy_cis_cache(skt); /* to be on the safe side... */ 1266 mutex_unlock(&skt->ops_mutex); 1267 1268 pcmcia_card_add(skt); 1269 1270 return 0; 1271 } 1272 1273 static int pcmcia_bus_early_resume(struct pcmcia_socket *skt) 1274 { 1275 if (!verify_cis_cache(skt)) 1276 return 0; 1277 1278 dev_dbg(&skt->dev, "cis mismatch - different card\n"); 1279 1280 /* first, remove the card */ 1281 pcmcia_bus_remove(skt); 1282 1283 mutex_lock(&skt->ops_mutex); 1284 destroy_cis_cache(skt); 1285 kfree(skt->fake_cis); 1286 skt->fake_cis = NULL; 1287 skt->functions = 0; 1288 mutex_unlock(&skt->ops_mutex); 1289 1290 /* now, add the new card */ 1291 pcmcia_bus_add(skt); 1292 return 0; 1293 } 1294 1295 1296 /* 1297 * NOTE: This is racy. There's no guarantee the card will still be 1298 * physically present, even if the call to this function returns 1299 * non-NULL. Furthermore, the device driver most likely is unbound 1300 * almost immediately, so the timeframe where pcmcia_dev_present 1301 * returns NULL is probably really really small. 1302 */ 1303 struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) 1304 { 1305 struct pcmcia_device *p_dev; 1306 struct pcmcia_device *ret = NULL; 1307 1308 p_dev = pcmcia_get_dev(_p_dev); 1309 if (!p_dev) 1310 return NULL; 1311 1312 if (atomic_read(&p_dev->socket->present) != 0) 1313 ret = p_dev; 1314 1315 pcmcia_put_dev(p_dev); 1316 return ret; 1317 } 1318 EXPORT_SYMBOL(pcmcia_dev_present); 1319 1320 1321 static struct pcmcia_callback pcmcia_bus_callback = { 1322 .owner = THIS_MODULE, 1323 .add = pcmcia_bus_add, 1324 .remove = pcmcia_bus_remove, 1325 .requery = pcmcia_requery, 1326 .validate = pccard_validate_cis, 1327 .suspend = pcmcia_bus_suspend, 1328 .early_resume = pcmcia_bus_early_resume, 1329 .resume = pcmcia_bus_resume, 1330 }; 1331 1332 static int __devinit pcmcia_bus_add_socket(struct device *dev, 1333 struct class_interface *class_intf) 1334 { 1335 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1336 int ret; 1337 1338 socket = pcmcia_get_socket(socket); 1339 if (!socket) { 1340 dev_printk(KERN_ERR, dev, 1341 "PCMCIA obtaining reference to socket failed\n"); 1342 return -ENODEV; 1343 } 1344 1345 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); 1346 if (ret) { 1347 dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1348 pcmcia_put_socket(socket); 1349 return ret; 1350 } 1351 1352 INIT_LIST_HEAD(&socket->devices_list); 1353 socket->pcmcia_pfc = 0; 1354 socket->device_count = 0; 1355 atomic_set(&socket->present, 0); 1356 1357 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); 1358 if (ret) { 1359 dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1360 pcmcia_put_socket(socket); 1361 return ret; 1362 } 1363 1364 return 0; 1365 } 1366 1367 static void pcmcia_bus_remove_socket(struct device *dev, 1368 struct class_interface *class_intf) 1369 { 1370 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1371 1372 if (!socket) 1373 return; 1374 1375 pccard_register_pcmcia(socket, NULL); 1376 1377 /* unregister any unbound devices */ 1378 mutex_lock(&socket->skt_mutex); 1379 pcmcia_card_remove(socket, NULL); 1380 release_cis_mem(socket); 1381 mutex_unlock(&socket->skt_mutex); 1382 1383 sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr); 1384 1385 pcmcia_put_socket(socket); 1386 1387 return; 1388 } 1389 1390 1391 /* the pcmcia_bus_interface is used to handle pcmcia socket devices */ 1392 static struct class_interface pcmcia_bus_interface __refdata = { 1393 .class = &pcmcia_socket_class, 1394 .add_dev = &pcmcia_bus_add_socket, 1395 .remove_dev = &pcmcia_bus_remove_socket, 1396 }; 1397 1398 1399 struct bus_type pcmcia_bus_type = { 1400 .name = "pcmcia", 1401 .uevent = pcmcia_bus_uevent, 1402 .match = pcmcia_bus_match, 1403 .dev_attrs = pcmcia_dev_attrs, 1404 .probe = pcmcia_device_probe, 1405 .remove = pcmcia_device_remove, 1406 .suspend = pcmcia_dev_suspend, 1407 .resume = pcmcia_dev_resume, 1408 }; 1409 1410 1411 static int __init init_pcmcia_bus(void) 1412 { 1413 int ret; 1414 1415 ret = bus_register(&pcmcia_bus_type); 1416 if (ret < 0) { 1417 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret); 1418 return ret; 1419 } 1420 ret = class_interface_register(&pcmcia_bus_interface); 1421 if (ret < 0) { 1422 printk(KERN_WARNING 1423 "pcmcia: class_interface_register error: %d\n", ret); 1424 bus_unregister(&pcmcia_bus_type); 1425 return ret; 1426 } 1427 1428 return 0; 1429 } 1430 fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that 1431 * pcmcia_socket_class is already registered */ 1432 1433 1434 static void __exit exit_pcmcia_bus(void) 1435 { 1436 class_interface_unregister(&pcmcia_bus_interface); 1437 1438 bus_unregister(&pcmcia_bus_type); 1439 } 1440 module_exit(exit_pcmcia_bus); 1441 1442 1443 MODULE_ALIAS("ds"); 1444