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 39MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 40MODULE_DESCRIPTION("PCMCIA Driver Services"); 41MODULE_LICENSE("GPL"); 42 43 44/*====================================================================*/ 45 46static 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 83struct 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 */ 97static ssize_t 98pcmcia_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} 136static DRIVER_ATTR(new_id, S_IWUSR, NULL, pcmcia_store_new_id); 137 138static void 139pcmcia_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 151static int 152pcmcia_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 160static void 161pcmcia_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 */ 172int 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} 200EXPORT_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 */ 206void 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} 213EXPORT_SYMBOL(pcmcia_unregister_driver); 214 215 216/* pcmcia_device handling */ 217 218static 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 227static void pcmcia_put_dev(struct pcmcia_device *p_dev) 228{ 229 if (p_dev) 230 put_device(&p_dev->dev); 231} 232 233static 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 240static 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 254static 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 311put_module: 312 if (ret) 313 module_put(p_drv->owner); 314put_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 */ 324static 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 356static 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 */ 406static 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 489static 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 613static 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 654static 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 666static void pcmcia_requery(struct pcmcia_socket *s) 667{ 668 int has_pfc; 669 670 if (!(s->state & SOCKET_PRESENT)) 671 return; 672 673 if (s->functions == 0) { 674 pcmcia_card_add(s); 675 return; 676 } 677 678 /* some device information might have changed because of a CIS 679 * update or because we can finally read it correctly... so 680 * determine it again, overwriting old values if necessary. */ 681 bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback); 682 683 /* if the CIS changed, we need to check whether the number of 684 * functions changed. */ 685 if (s->fake_cis) { 686 int old_funcs, new_funcs; 687 cistpl_longlink_mfc_t mfc; 688 689 /* does this cis override add or remove functions? */ 690 old_funcs = s->functions; 691 692 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, 693 &mfc)) 694 new_funcs = mfc.nfn; 695 else 696 new_funcs = 1; 697 if (old_funcs != new_funcs) { 698 /* we need to re-start */ 699 pcmcia_card_remove(s, NULL); 700 s->functions = 0; 701 pcmcia_card_add(s); 702 } 703 } 704 705 /* If the PCMCIA device consists of two pseudo devices, 706 * call pcmcia_device_add() -- which will fail if both 707 * devices are already registered. */ 708 mutex_lock(&s->ops_mutex); 709 has_pfc = s->pcmcia_pfc; 710 mutex_unlock(&s->ops_mutex); 711 if (has_pfc) 712 pcmcia_device_add(s, 0); 713 714 /* we re-scan all devices, not just the ones connected to this 715 * socket. This does not matter, though. */ 716 if (bus_rescan_devices(&pcmcia_bus_type)) 717 dev_warn(&s->dev, "rescanning the bus failed\n"); 718} 719 720 721#ifdef CONFIG_PCMCIA_LOAD_CIS 722 723/** 724 * pcmcia_load_firmware - load CIS from userspace if device-provided is broken 725 * @dev: the pcmcia device which needs a CIS override 726 * @filename: requested filename in /lib/firmware/ 727 * 728 * This uses the in-kernel firmware loading mechanism to use a "fake CIS" if 729 * the one provided by the card is broken. The firmware files reside in 730 * /lib/firmware/ in userspace. 731 */ 732static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) 733{ 734 struct pcmcia_socket *s = dev->socket; 735 const struct firmware *fw; 736 int ret = -ENOMEM; 737 cistpl_longlink_mfc_t mfc; 738 int old_funcs, new_funcs = 1; 739 740 if (!filename) 741 return -EINVAL; 742 743 dev_dbg(&dev->dev, "trying to load CIS file %s\n", filename); 744 745 if (request_firmware(&fw, filename, &dev->dev) == 0) { 746 if (fw->size >= CISTPL_MAX_CIS_SIZE) { 747 ret = -EINVAL; 748 dev_printk(KERN_ERR, &dev->dev, 749 "pcmcia: CIS override is too big\n"); 750 goto release; 751 } 752 753 if (!pcmcia_replace_cis(s, fw->data, fw->size)) 754 ret = 0; 755 else { 756 dev_printk(KERN_ERR, &dev->dev, 757 "pcmcia: CIS override failed\n"); 758 goto release; 759 } 760 761 /* we need to re-start if the number of functions changed */ 762 old_funcs = s->functions; 763 if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, 764 &mfc)) 765 new_funcs = mfc.nfn; 766 767 if (old_funcs != new_funcs) 768 ret = -EBUSY; 769 770 /* update information */ 771 pcmcia_device_query(dev); 772 773 /* requery (as number of functions might have changed) */ 774 pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY); 775 } 776 release: 777 release_firmware(fw); 778 779 return ret; 780} 781 782#else /* !CONFIG_PCMCIA_LOAD_CIS */ 783 784static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) 785{ 786 return -ENODEV; 787} 788 789#endif 790 791 792static inline int pcmcia_devmatch(struct pcmcia_device *dev, 793 const struct pcmcia_device_id *did) 794{ 795 if (did->match_flags & PCMCIA_DEV_ID_MATCH_MANF_ID) { 796 if ((!dev->has_manf_id) || (dev->manf_id != did->manf_id)) 797 return 0; 798 } 799 800 if (did->match_flags & PCMCIA_DEV_ID_MATCH_CARD_ID) { 801 if ((!dev->has_card_id) || (dev->card_id != did->card_id)) 802 return 0; 803 } 804 805 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNCTION) { 806 if (dev->func != did->function) 807 return 0; 808 } 809 810 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID1) { 811 if (!dev->prod_id[0]) 812 return 0; 813 if (strcmp(did->prod_id[0], dev->prod_id[0])) 814 return 0; 815 } 816 817 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID2) { 818 if (!dev->prod_id[1]) 819 return 0; 820 if (strcmp(did->prod_id[1], dev->prod_id[1])) 821 return 0; 822 } 823 824 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID3) { 825 if (!dev->prod_id[2]) 826 return 0; 827 if (strcmp(did->prod_id[2], dev->prod_id[2])) 828 return 0; 829 } 830 831 if (did->match_flags & PCMCIA_DEV_ID_MATCH_PROD_ID4) { 832 if (!dev->prod_id[3]) 833 return 0; 834 if (strcmp(did->prod_id[3], dev->prod_id[3])) 835 return 0; 836 } 837 838 if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) { 839 dev_dbg(&dev->dev, "this is a pseudo-multi-function device\n"); 840 mutex_lock(&dev->socket->ops_mutex); 841 dev->socket->pcmcia_pfc = 1; 842 mutex_unlock(&dev->socket->ops_mutex); 843 if (dev->device_no != did->device_no) 844 return 0; 845 } 846 847 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) { 848 int ret; 849 850 if ((!dev->has_func_id) || (dev->func_id != did->func_id)) 851 return 0; 852 853 /* if this is a pseudo-multi-function device, 854 * we need explicit matches */ 855 if (dev->socket->pcmcia_pfc) 856 return 0; 857 if (dev->device_no) 858 return 0; 859 860 /* also, FUNC_ID matching needs to be activated by userspace 861 * after it has re-checked that there is no possible module 862 * with a prod_id/manf_id/card_id match. 863 */ 864 mutex_lock(&dev->socket->ops_mutex); 865 ret = dev->allow_func_id_match; 866 mutex_unlock(&dev->socket->ops_mutex); 867 868 if (!ret) { 869 dev_dbg(&dev->dev, 870 "skipping FUNC_ID match until userspace ACK\n"); 871 return 0; 872 } 873 } 874 875 if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) { 876 dev_dbg(&dev->dev, "device needs a fake CIS\n"); 877 if (!dev->socket->fake_cis) 878 if (pcmcia_load_firmware(dev, did->cisfile)) 879 return 0; 880 } 881 882 if (did->match_flags & PCMCIA_DEV_ID_MATCH_ANONYMOUS) { 883 int i; 884 for (i = 0; i < 4; i++) 885 if (dev->prod_id[i]) 886 return 0; 887 if (dev->has_manf_id || dev->has_card_id || dev->has_func_id) 888 return 0; 889 } 890 891 return 1; 892} 893 894 895static int pcmcia_bus_match(struct device *dev, struct device_driver *drv) 896{ 897 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 898 struct pcmcia_driver *p_drv = to_pcmcia_drv(drv); 899 const struct pcmcia_device_id *did = p_drv->id_table; 900 struct pcmcia_dynid *dynid; 901 902 /* match dynamic devices first */ 903 mutex_lock(&p_drv->dynids.lock); 904 list_for_each_entry(dynid, &p_drv->dynids.list, node) { 905 dev_dbg(dev, "trying to match to %s\n", drv->name); 906 if (pcmcia_devmatch(p_dev, &dynid->id)) { 907 dev_dbg(dev, "matched to %s\n", drv->name); 908 mutex_unlock(&p_drv->dynids.lock); 909 return 1; 910 } 911 } 912 mutex_unlock(&p_drv->dynids.lock); 913 914 while (did && did->match_flags) { 915 dev_dbg(dev, "trying to match to %s\n", drv->name); 916 if (pcmcia_devmatch(p_dev, did)) { 917 dev_dbg(dev, "matched to %s\n", drv->name); 918 return 1; 919 } 920 did++; 921 } 922 923 return 0; 924} 925 926static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 927{ 928 struct pcmcia_device *p_dev; 929 int i; 930 u32 hash[4] = { 0, 0, 0, 0}; 931 932 if (!dev) 933 return -ENODEV; 934 935 p_dev = to_pcmcia_dev(dev); 936 937 /* calculate hashes */ 938 for (i = 0; i < 4; i++) { 939 if (!p_dev->prod_id[i]) 940 continue; 941 hash[i] = crc32(0, p_dev->prod_id[i], strlen(p_dev->prod_id[i])); 942 } 943 944 if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock)) 945 return -ENOMEM; 946 947 if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no)) 948 return -ENOMEM; 949 950 if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 951 "pa%08Xpb%08Xpc%08Xpd%08X", 952 p_dev->has_manf_id ? p_dev->manf_id : 0, 953 p_dev->has_card_id ? p_dev->card_id : 0, 954 p_dev->has_func_id ? p_dev->func_id : 0, 955 p_dev->func, 956 p_dev->device_no, 957 hash[0], 958 hash[1], 959 hash[2], 960 hash[3])) 961 return -ENOMEM; 962 963 return 0; 964} 965 966/************************ runtime PM support ***************************/ 967 968static int pcmcia_dev_suspend(struct device *dev, pm_message_t state); 969static int pcmcia_dev_resume(struct device *dev); 970 971static int runtime_suspend(struct device *dev) 972{ 973 int rc; 974 975 device_lock(dev); 976 rc = pcmcia_dev_suspend(dev, PMSG_SUSPEND); 977 device_unlock(dev); 978 return rc; 979} 980 981static int runtime_resume(struct device *dev) 982{ 983 int rc; 984 985 device_lock(dev); 986 rc = pcmcia_dev_resume(dev); 987 device_unlock(dev); 988 return rc; 989} 990 991/************************ per-device sysfs output ***************************/ 992 993#define pcmcia_device_attr(field, test, format) \ 994static ssize_t field##_show (struct device *dev, struct device_attribute *attr, char *buf) \ 995{ \ 996 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); \ 997 return p_dev->test ? sprintf(buf, format, p_dev->field) : -ENODEV; \ 998} \ 999static DEVICE_ATTR_RO(field); 1000 1001#define pcmcia_device_stringattr(name, field) \ 1002static ssize_t name##_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->field ? sprintf(buf, "%s\n", p_dev->field) : -ENODEV; \ 1006} \ 1007static DEVICE_ATTR_RO(name); 1008 1009pcmcia_device_attr(func_id, has_func_id, "0x%02x\n"); 1010pcmcia_device_attr(manf_id, has_manf_id, "0x%04x\n"); 1011pcmcia_device_attr(card_id, has_card_id, "0x%04x\n"); 1012pcmcia_device_stringattr(prod_id1, prod_id[0]); 1013pcmcia_device_stringattr(prod_id2, prod_id[1]); 1014pcmcia_device_stringattr(prod_id3, prod_id[2]); 1015pcmcia_device_stringattr(prod_id4, prod_id[3]); 1016 1017static ssize_t function_show(struct device *dev, struct device_attribute *attr, 1018 char *buf) 1019{ 1020 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1021 return p_dev->socket ? sprintf(buf, "0x%02x\n", p_dev->func) : -ENODEV; 1022} 1023static DEVICE_ATTR_RO(function); 1024 1025static ssize_t resources_show(struct device *dev, 1026 struct device_attribute *attr, char *buf) 1027{ 1028 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1029 char *str = buf; 1030 int i; 1031 1032 for (i = 0; i < PCMCIA_NUM_RESOURCES; i++) 1033 str += sprintf(str, "%pr\n", p_dev->resource[i]); 1034 1035 return str - buf; 1036} 1037static DEVICE_ATTR_RO(resources); 1038 1039static ssize_t pm_state_show(struct device *dev, struct device_attribute *attr, char *buf) 1040{ 1041 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1042 1043 if (p_dev->suspended) 1044 return sprintf(buf, "off\n"); 1045 else 1046 return sprintf(buf, "on\n"); 1047} 1048 1049static ssize_t pm_state_store(struct device *dev, struct device_attribute *attr, 1050 const char *buf, size_t count) 1051{ 1052 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1053 int ret = 0; 1054 1055 if (!count) 1056 return -EINVAL; 1057 1058 if ((!p_dev->suspended) && !strncmp(buf, "off", 3)) 1059 ret = runtime_suspend(dev); 1060 else if (p_dev->suspended && !strncmp(buf, "on", 2)) 1061 ret = runtime_resume(dev); 1062 1063 return ret ? ret : count; 1064} 1065static DEVICE_ATTR_RW(pm_state); 1066 1067static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 1068{ 1069 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1070 int i; 1071 u32 hash[4] = { 0, 0, 0, 0}; 1072 1073 /* calculate hashes */ 1074 for (i = 0; i < 4; i++) { 1075 if (!p_dev->prod_id[i]) 1076 continue; 1077 hash[i] = crc32(0, p_dev->prod_id[i], 1078 strlen(p_dev->prod_id[i])); 1079 } 1080 return sprintf(buf, "pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" 1081 "pa%08Xpb%08Xpc%08Xpd%08X\n", 1082 p_dev->has_manf_id ? p_dev->manf_id : 0, 1083 p_dev->has_card_id ? p_dev->card_id : 0, 1084 p_dev->has_func_id ? p_dev->func_id : 0, 1085 p_dev->func, p_dev->device_no, 1086 hash[0], hash[1], hash[2], hash[3]); 1087} 1088static DEVICE_ATTR_RO(modalias); 1089 1090static ssize_t allow_func_id_match_store(struct device *dev, 1091 struct device_attribute *attr, const char *buf, size_t count) 1092{ 1093 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1094 1095 if (!count) 1096 return -EINVAL; 1097 1098 mutex_lock(&p_dev->socket->ops_mutex); 1099 p_dev->allow_func_id_match = 1; 1100 mutex_unlock(&p_dev->socket->ops_mutex); 1101 pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY); 1102 1103 return count; 1104} 1105static DEVICE_ATTR_WO(allow_func_id_match); 1106 1107static struct attribute *pcmcia_dev_attrs[] = { 1108 &dev_attr_resources.attr, 1109 &dev_attr_pm_state.attr, 1110 &dev_attr_function.attr, 1111 &dev_attr_func_id.attr, 1112 &dev_attr_manf_id.attr, 1113 &dev_attr_card_id.attr, 1114 &dev_attr_prod_id1.attr, 1115 &dev_attr_prod_id2.attr, 1116 &dev_attr_prod_id3.attr, 1117 &dev_attr_prod_id4.attr, 1118 &dev_attr_modalias.attr, 1119 &dev_attr_allow_func_id_match.attr, 1120 NULL, 1121}; 1122ATTRIBUTE_GROUPS(pcmcia_dev); 1123 1124/* PM support, also needed for reset */ 1125 1126static int pcmcia_dev_suspend(struct device *dev, pm_message_t state) 1127{ 1128 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1129 struct pcmcia_driver *p_drv = NULL; 1130 int ret = 0; 1131 1132 mutex_lock(&p_dev->socket->ops_mutex); 1133 if (p_dev->suspended) { 1134 mutex_unlock(&p_dev->socket->ops_mutex); 1135 return 0; 1136 } 1137 p_dev->suspended = 1; 1138 mutex_unlock(&p_dev->socket->ops_mutex); 1139 1140 dev_dbg(dev, "suspending\n"); 1141 1142 if (dev->driver) 1143 p_drv = to_pcmcia_drv(dev->driver); 1144 1145 if (!p_drv) 1146 goto out; 1147 1148 if (p_drv->suspend) { 1149 ret = p_drv->suspend(p_dev); 1150 if (ret) { 1151 dev_printk(KERN_ERR, dev, 1152 "pcmcia: device %s (driver %s) did " 1153 "not want to go to sleep (%d)\n", 1154 p_dev->devname, p_drv->name, ret); 1155 mutex_lock(&p_dev->socket->ops_mutex); 1156 p_dev->suspended = 0; 1157 mutex_unlock(&p_dev->socket->ops_mutex); 1158 goto out; 1159 } 1160 } 1161 1162 if (p_dev->device_no == p_dev->func) { 1163 dev_dbg(dev, "releasing configuration\n"); 1164 pcmcia_release_configuration(p_dev); 1165 } 1166 1167 out: 1168 return ret; 1169} 1170 1171 1172static int pcmcia_dev_resume(struct device *dev) 1173{ 1174 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1175 struct pcmcia_driver *p_drv = NULL; 1176 int ret = 0; 1177 1178 mutex_lock(&p_dev->socket->ops_mutex); 1179 if (!p_dev->suspended) { 1180 mutex_unlock(&p_dev->socket->ops_mutex); 1181 return 0; 1182 } 1183 p_dev->suspended = 0; 1184 mutex_unlock(&p_dev->socket->ops_mutex); 1185 1186 dev_dbg(dev, "resuming\n"); 1187 1188 if (dev->driver) 1189 p_drv = to_pcmcia_drv(dev->driver); 1190 1191 if (!p_drv) 1192 goto out; 1193 1194 if (p_dev->device_no == p_dev->func) { 1195 dev_dbg(dev, "requesting configuration\n"); 1196 ret = pcmcia_enable_device(p_dev); 1197 if (ret) 1198 goto out; 1199 } 1200 1201 if (p_drv->resume) 1202 ret = p_drv->resume(p_dev); 1203 1204 out: 1205 return ret; 1206} 1207 1208 1209static int pcmcia_bus_suspend_callback(struct device *dev, void * _data) 1210{ 1211 struct pcmcia_socket *skt = _data; 1212 struct pcmcia_device *p_dev = to_pcmcia_dev(dev); 1213 1214 if (p_dev->socket != skt || p_dev->suspended) 1215 return 0; 1216 1217 return runtime_suspend(dev); 1218} 1219 1220static int pcmcia_bus_resume_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 runtime_resume(dev); 1229 1230 return 0; 1231} 1232 1233static int pcmcia_bus_resume(struct pcmcia_socket *skt) 1234{ 1235 dev_dbg(&skt->dev, "resuming socket %d\n", skt->sock); 1236 bus_for_each_dev(&pcmcia_bus_type, NULL, skt, pcmcia_bus_resume_callback); 1237 return 0; 1238} 1239 1240static int pcmcia_bus_suspend(struct pcmcia_socket *skt) 1241{ 1242 dev_dbg(&skt->dev, "suspending socket %d\n", skt->sock); 1243 if (bus_for_each_dev(&pcmcia_bus_type, NULL, skt, 1244 pcmcia_bus_suspend_callback)) { 1245 pcmcia_bus_resume(skt); 1246 return -EIO; 1247 } 1248 return 0; 1249} 1250 1251static int pcmcia_bus_remove(struct pcmcia_socket *skt) 1252{ 1253 atomic_set(&skt->present, 0); 1254 pcmcia_card_remove(skt, NULL); 1255 1256 mutex_lock(&skt->ops_mutex); 1257 destroy_cis_cache(skt); 1258 pcmcia_cleanup_irq(skt); 1259 mutex_unlock(&skt->ops_mutex); 1260 1261 return 0; 1262} 1263 1264static int pcmcia_bus_add(struct pcmcia_socket *skt) 1265{ 1266 atomic_set(&skt->present, 1); 1267 1268 mutex_lock(&skt->ops_mutex); 1269 skt->pcmcia_pfc = 0; 1270 destroy_cis_cache(skt); /* to be on the safe side... */ 1271 mutex_unlock(&skt->ops_mutex); 1272 1273 pcmcia_card_add(skt); 1274 1275 return 0; 1276} 1277 1278static int pcmcia_bus_early_resume(struct pcmcia_socket *skt) 1279{ 1280 if (!verify_cis_cache(skt)) 1281 return 0; 1282 1283 dev_dbg(&skt->dev, "cis mismatch - different card\n"); 1284 1285 /* first, remove the card */ 1286 pcmcia_bus_remove(skt); 1287 1288 mutex_lock(&skt->ops_mutex); 1289 destroy_cis_cache(skt); 1290 kfree(skt->fake_cis); 1291 skt->fake_cis = NULL; 1292 skt->functions = 0; 1293 mutex_unlock(&skt->ops_mutex); 1294 1295 /* now, add the new card */ 1296 pcmcia_bus_add(skt); 1297 return 0; 1298} 1299 1300 1301/* 1302 * NOTE: This is racy. There's no guarantee the card will still be 1303 * physically present, even if the call to this function returns 1304 * non-NULL. Furthermore, the device driver most likely is unbound 1305 * almost immediately, so the timeframe where pcmcia_dev_present 1306 * returns NULL is probably really really small. 1307 */ 1308struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) 1309{ 1310 struct pcmcia_device *p_dev; 1311 struct pcmcia_device *ret = NULL; 1312 1313 p_dev = pcmcia_get_dev(_p_dev); 1314 if (!p_dev) 1315 return NULL; 1316 1317 if (atomic_read(&p_dev->socket->present) != 0) 1318 ret = p_dev; 1319 1320 pcmcia_put_dev(p_dev); 1321 return ret; 1322} 1323EXPORT_SYMBOL(pcmcia_dev_present); 1324 1325 1326static struct pcmcia_callback pcmcia_bus_callback = { 1327 .owner = THIS_MODULE, 1328 .add = pcmcia_bus_add, 1329 .remove = pcmcia_bus_remove, 1330 .requery = pcmcia_requery, 1331 .validate = pccard_validate_cis, 1332 .suspend = pcmcia_bus_suspend, 1333 .early_resume = pcmcia_bus_early_resume, 1334 .resume = pcmcia_bus_resume, 1335}; 1336 1337static int pcmcia_bus_add_socket(struct device *dev, 1338 struct class_interface *class_intf) 1339{ 1340 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1341 int ret; 1342 1343 socket = pcmcia_get_socket(socket); 1344 if (!socket) { 1345 dev_printk(KERN_ERR, dev, 1346 "PCMCIA obtaining reference to socket failed\n"); 1347 return -ENODEV; 1348 } 1349 1350 ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); 1351 if (ret) { 1352 dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1353 pcmcia_put_socket(socket); 1354 return ret; 1355 } 1356 1357 INIT_LIST_HEAD(&socket->devices_list); 1358 socket->pcmcia_pfc = 0; 1359 socket->device_count = 0; 1360 atomic_set(&socket->present, 0); 1361 1362 ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); 1363 if (ret) { 1364 dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); 1365 pcmcia_put_socket(socket); 1366 return ret; 1367 } 1368 1369 return 0; 1370} 1371 1372static void pcmcia_bus_remove_socket(struct device *dev, 1373 struct class_interface *class_intf) 1374{ 1375 struct pcmcia_socket *socket = dev_get_drvdata(dev); 1376 1377 if (!socket) 1378 return; 1379 1380 pccard_register_pcmcia(socket, NULL); 1381 1382 /* unregister any unbound devices */ 1383 mutex_lock(&socket->skt_mutex); 1384 pcmcia_card_remove(socket, NULL); 1385 release_cis_mem(socket); 1386 mutex_unlock(&socket->skt_mutex); 1387 1388 sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr); 1389 1390 pcmcia_put_socket(socket); 1391 1392 return; 1393} 1394 1395 1396/* the pcmcia_bus_interface is used to handle pcmcia socket devices */ 1397static struct class_interface pcmcia_bus_interface __refdata = { 1398 .class = &pcmcia_socket_class, 1399 .add_dev = &pcmcia_bus_add_socket, 1400 .remove_dev = &pcmcia_bus_remove_socket, 1401}; 1402 1403 1404struct bus_type pcmcia_bus_type = { 1405 .name = "pcmcia", 1406 .uevent = pcmcia_bus_uevent, 1407 .match = pcmcia_bus_match, 1408 .dev_groups = pcmcia_dev_groups, 1409 .probe = pcmcia_device_probe, 1410 .remove = pcmcia_device_remove, 1411 .suspend = pcmcia_dev_suspend, 1412 .resume = pcmcia_dev_resume, 1413}; 1414 1415 1416static int __init init_pcmcia_bus(void) 1417{ 1418 int ret; 1419 1420 ret = bus_register(&pcmcia_bus_type); 1421 if (ret < 0) { 1422 printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret); 1423 return ret; 1424 } 1425 ret = class_interface_register(&pcmcia_bus_interface); 1426 if (ret < 0) { 1427 printk(KERN_WARNING 1428 "pcmcia: class_interface_register error: %d\n", ret); 1429 bus_unregister(&pcmcia_bus_type); 1430 return ret; 1431 } 1432 1433 return 0; 1434} 1435fs_initcall(init_pcmcia_bus); /* one level after subsys_initcall so that 1436 * pcmcia_socket_class is already registered */ 1437 1438 1439static void __exit exit_pcmcia_bus(void) 1440{ 1441 class_interface_unregister(&pcmcia_bus_interface); 1442 1443 bus_unregister(&pcmcia_bus_type); 1444} 1445module_exit(exit_pcmcia_bus); 1446 1447 1448MODULE_ALIAS("ds"); 1449