1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * cs.c -- Kernel Card Services - core services 4 * 5 * The initial developer of the original code is David A. Hinds 6 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds 7 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved. 8 * 9 * (C) 1999 David A. Hinds 10 */ 11 12 #include <linux/module.h> 13 #include <linux/moduleparam.h> 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/string.h> 17 #include <linux/major.h> 18 #include <linux/errno.h> 19 #include <linux/slab.h> 20 #include <linux/mm.h> 21 #include <linux/interrupt.h> 22 #include <linux/timer.h> 23 #include <linux/ioport.h> 24 #include <linux/delay.h> 25 #include <linux/pm.h> 26 #include <linux/device.h> 27 #include <linux/kthread.h> 28 #include <linux/freezer.h> 29 #include <asm/irq.h> 30 31 #include <pcmcia/ss.h> 32 #include <pcmcia/cistpl.h> 33 #include <pcmcia/cisreg.h> 34 #include <pcmcia/ds.h> 35 #include "cs_internal.h" 36 37 38 /* Module parameters */ 39 40 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>"); 41 MODULE_DESCRIPTION("Linux Kernel Card Services"); 42 MODULE_LICENSE("GPL"); 43 44 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444) 45 46 INT_MODULE_PARM(setup_delay, 10); /* centiseconds */ 47 INT_MODULE_PARM(resume_delay, 20); /* centiseconds */ 48 INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */ 49 INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */ 50 INT_MODULE_PARM(reset_time, 10); /* usecs */ 51 INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */ 52 INT_MODULE_PARM(unreset_check, 10); /* centiseconds */ 53 INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */ 54 55 /* Access speed for attribute memory windows */ 56 INT_MODULE_PARM(cis_speed, 300); /* ns */ 57 58 59 socket_state_t dead_socket = { 60 .csc_mask = SS_DETECT, 61 }; 62 EXPORT_SYMBOL(dead_socket); 63 64 65 /* List of all sockets, protected by a rwsem */ 66 LIST_HEAD(pcmcia_socket_list); 67 EXPORT_SYMBOL(pcmcia_socket_list); 68 69 DECLARE_RWSEM(pcmcia_socket_list_rwsem); 70 EXPORT_SYMBOL(pcmcia_socket_list_rwsem); 71 72 73 struct pcmcia_socket *pcmcia_get_socket(struct pcmcia_socket *skt) 74 { 75 struct device *dev = get_device(&skt->dev); 76 if (!dev) 77 return NULL; 78 return dev_get_drvdata(dev); 79 } 80 EXPORT_SYMBOL(pcmcia_get_socket); 81 82 83 void pcmcia_put_socket(struct pcmcia_socket *skt) 84 { 85 put_device(&skt->dev); 86 } 87 EXPORT_SYMBOL(pcmcia_put_socket); 88 89 90 static void pcmcia_release_socket(struct device *dev) 91 { 92 struct pcmcia_socket *socket = dev_get_drvdata(dev); 93 94 complete(&socket->socket_released); 95 } 96 97 static int pccardd(void *__skt); 98 99 /** 100 * pcmcia_register_socket - add a new pcmcia socket device 101 * @socket: the &socket to register 102 */ 103 int pcmcia_register_socket(struct pcmcia_socket *socket) 104 { 105 struct task_struct *tsk; 106 int ret; 107 108 if (!socket || !socket->ops || !socket->dev.parent || !socket->resource_ops) 109 return -EINVAL; 110 111 dev_dbg(&socket->dev, "pcmcia_register_socket(0x%p)\n", socket->ops); 112 113 /* try to obtain a socket number [yes, it gets ugly if we 114 * register more than 2^sizeof(unsigned int) pcmcia 115 * sockets... but the socket number is deprecated 116 * anyways, so I don't care] */ 117 down_write(&pcmcia_socket_list_rwsem); 118 if (list_empty(&pcmcia_socket_list)) 119 socket->sock = 0; 120 else { 121 unsigned int found, i = 1; 122 struct pcmcia_socket *tmp; 123 do { 124 found = 1; 125 list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) { 126 if (tmp->sock == i) 127 found = 0; 128 } 129 i++; 130 } while (!found); 131 socket->sock = i - 1; 132 } 133 list_add_tail(&socket->socket_list, &pcmcia_socket_list); 134 up_write(&pcmcia_socket_list_rwsem); 135 136 #ifndef CONFIG_CARDBUS 137 /* 138 * If we do not support Cardbus, ensure that 139 * the Cardbus socket capability is disabled. 140 */ 141 socket->features &= ~SS_CAP_CARDBUS; 142 #endif 143 144 /* set proper values in socket->dev */ 145 dev_set_drvdata(&socket->dev, socket); 146 socket->dev.class = &pcmcia_socket_class; 147 dev_set_name(&socket->dev, "pcmcia_socket%u", socket->sock); 148 149 /* base address = 0, map = 0 */ 150 socket->cis_mem.flags = 0; 151 socket->cis_mem.speed = cis_speed; 152 153 INIT_LIST_HEAD(&socket->cis_cache); 154 155 init_completion(&socket->socket_released); 156 init_completion(&socket->thread_done); 157 mutex_init(&socket->skt_mutex); 158 mutex_init(&socket->ops_mutex); 159 spin_lock_init(&socket->thread_lock); 160 161 if (socket->resource_ops->init) { 162 mutex_lock(&socket->ops_mutex); 163 ret = socket->resource_ops->init(socket); 164 mutex_unlock(&socket->ops_mutex); 165 if (ret) 166 goto err; 167 } 168 169 tsk = kthread_run(pccardd, socket, "pccardd"); 170 if (IS_ERR(tsk)) { 171 ret = PTR_ERR(tsk); 172 goto err; 173 } 174 175 wait_for_completion(&socket->thread_done); 176 if (!socket->thread) { 177 dev_warn(&socket->dev, 178 "PCMCIA: warning: socket thread did not start\n"); 179 return -EIO; 180 } 181 182 pcmcia_parse_events(socket, SS_DETECT); 183 184 /* 185 * Let's try to get the PCMCIA module for 16-bit PCMCIA support. 186 * If it fails, it doesn't matter -- we still have 32-bit CardBus 187 * support to offer, so this is not a failure mode. 188 */ 189 request_module_nowait("pcmcia"); 190 191 return 0; 192 193 err: 194 down_write(&pcmcia_socket_list_rwsem); 195 list_del(&socket->socket_list); 196 up_write(&pcmcia_socket_list_rwsem); 197 return ret; 198 } /* pcmcia_register_socket */ 199 EXPORT_SYMBOL(pcmcia_register_socket); 200 201 202 /** 203 * pcmcia_unregister_socket - remove a pcmcia socket device 204 * @socket: the &socket to unregister 205 */ 206 void pcmcia_unregister_socket(struct pcmcia_socket *socket) 207 { 208 if (!socket) 209 return; 210 211 dev_dbg(&socket->dev, "pcmcia_unregister_socket(0x%p)\n", socket->ops); 212 213 if (socket->thread) 214 kthread_stop(socket->thread); 215 216 /* remove from our own list */ 217 down_write(&pcmcia_socket_list_rwsem); 218 list_del(&socket->socket_list); 219 up_write(&pcmcia_socket_list_rwsem); 220 221 /* wait for sysfs to drop all references */ 222 if (socket->resource_ops->exit) { 223 mutex_lock(&socket->ops_mutex); 224 socket->resource_ops->exit(socket); 225 mutex_unlock(&socket->ops_mutex); 226 } 227 wait_for_completion(&socket->socket_released); 228 } /* pcmcia_unregister_socket */ 229 EXPORT_SYMBOL(pcmcia_unregister_socket); 230 231 232 static int socket_reset(struct pcmcia_socket *skt) 233 { 234 int status, i; 235 236 dev_dbg(&skt->dev, "reset\n"); 237 238 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET; 239 skt->ops->set_socket(skt, &skt->socket); 240 udelay((long)reset_time); 241 242 skt->socket.flags &= ~SS_RESET; 243 skt->ops->set_socket(skt, &skt->socket); 244 245 msleep(unreset_delay * 10); 246 for (i = 0; i < unreset_limit; i++) { 247 skt->ops->get_status(skt, &status); 248 249 if (!(status & SS_DETECT)) 250 return -ENODEV; 251 252 if (status & SS_READY) 253 return 0; 254 255 msleep(unreset_check * 10); 256 } 257 258 dev_err(&skt->dev, "time out after reset\n"); 259 return -ETIMEDOUT; 260 } 261 262 /* 263 * socket_setup() and socket_shutdown() are called by the main event handler 264 * when card insertion and removal events are received. 265 * socket_setup() turns on socket power and resets the socket, in two stages. 266 * socket_shutdown() unconfigures a socket and turns off socket power. 267 */ 268 static void socket_shutdown(struct pcmcia_socket *s) 269 { 270 int status; 271 272 dev_dbg(&s->dev, "shutdown\n"); 273 274 if (s->callback) 275 s->callback->remove(s); 276 277 mutex_lock(&s->ops_mutex); 278 s->state &= SOCKET_INUSE | SOCKET_PRESENT; 279 msleep(shutdown_delay * 10); 280 s->state &= SOCKET_INUSE; 281 282 /* Blank out the socket state */ 283 s->socket = dead_socket; 284 s->ops->init(s); 285 s->ops->set_socket(s, &s->socket); 286 s->lock_count = 0; 287 kfree(s->fake_cis); 288 s->fake_cis = NULL; 289 s->functions = 0; 290 291 /* From here on we can be sure that only we (that is, the 292 * pccardd thread) accesses this socket, and all (16-bit) 293 * PCMCIA interactions are gone. Therefore, release 294 * ops_mutex so that we don't get a sysfs-related lockdep 295 * warning. 296 */ 297 mutex_unlock(&s->ops_mutex); 298 299 #ifdef CONFIG_CARDBUS 300 cb_free(s); 301 #endif 302 303 /* give socket some time to power down */ 304 msleep(100); 305 306 s->ops->get_status(s, &status); 307 if (status & SS_POWERON) { 308 dev_err(&s->dev, 309 "*** DANGER *** unable to remove socket power\n"); 310 } 311 312 s->state &= ~SOCKET_INUSE; 313 } 314 315 static int socket_setup(struct pcmcia_socket *skt, int initial_delay) 316 { 317 int status, i; 318 319 dev_dbg(&skt->dev, "setup\n"); 320 321 skt->ops->get_status(skt, &status); 322 if (!(status & SS_DETECT)) 323 return -ENODEV; 324 325 msleep(initial_delay * 10); 326 327 for (i = 0; i < 100; i++) { 328 skt->ops->get_status(skt, &status); 329 if (!(status & SS_DETECT)) 330 return -ENODEV; 331 332 if (!(status & SS_PENDING)) 333 break; 334 335 msleep(100); 336 } 337 338 if (status & SS_PENDING) { 339 dev_err(&skt->dev, "voltage interrogation timed out\n"); 340 return -ETIMEDOUT; 341 } 342 343 if (status & SS_CARDBUS) { 344 if (!(skt->features & SS_CAP_CARDBUS)) { 345 dev_err(&skt->dev, "cardbus cards are not supported\n"); 346 return -EINVAL; 347 } 348 skt->state |= SOCKET_CARDBUS; 349 } else 350 skt->state &= ~SOCKET_CARDBUS; 351 352 /* 353 * Decode the card voltage requirements, and apply power to the card. 354 */ 355 if (status & SS_3VCARD) 356 skt->socket.Vcc = skt->socket.Vpp = 33; 357 else if (!(status & SS_XVCARD)) 358 skt->socket.Vcc = skt->socket.Vpp = 50; 359 else { 360 dev_err(&skt->dev, "unsupported voltage key\n"); 361 return -EIO; 362 } 363 364 if (skt->power_hook) 365 skt->power_hook(skt, HOOK_POWER_PRE); 366 367 skt->socket.flags = 0; 368 skt->ops->set_socket(skt, &skt->socket); 369 370 /* 371 * Wait "vcc_settle" for the supply to stabilise. 372 */ 373 msleep(vcc_settle * 10); 374 375 skt->ops->get_status(skt, &status); 376 if (!(status & SS_POWERON)) { 377 dev_err(&skt->dev, "unable to apply power\n"); 378 return -EIO; 379 } 380 381 status = socket_reset(skt); 382 383 if (skt->power_hook) 384 skt->power_hook(skt, HOOK_POWER_POST); 385 386 return status; 387 } 388 389 /* 390 * Handle card insertion. Setup the socket, reset the card, 391 * and then tell the rest of PCMCIA that a card is present. 392 */ 393 static int socket_insert(struct pcmcia_socket *skt) 394 { 395 int ret; 396 397 dev_dbg(&skt->dev, "insert\n"); 398 399 mutex_lock(&skt->ops_mutex); 400 if (skt->state & SOCKET_INUSE) { 401 mutex_unlock(&skt->ops_mutex); 402 return -EINVAL; 403 } 404 skt->state |= SOCKET_INUSE; 405 406 ret = socket_setup(skt, setup_delay); 407 if (ret == 0) { 408 skt->state |= SOCKET_PRESENT; 409 410 dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n", 411 (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA", 412 skt->sock); 413 414 #ifdef CONFIG_CARDBUS 415 if (skt->state & SOCKET_CARDBUS) { 416 cb_alloc(skt); 417 skt->state |= SOCKET_CARDBUS_CONFIG; 418 } 419 #endif 420 dev_dbg(&skt->dev, "insert done\n"); 421 mutex_unlock(&skt->ops_mutex); 422 423 if (!(skt->state & SOCKET_CARDBUS) && (skt->callback)) 424 skt->callback->add(skt); 425 } else { 426 mutex_unlock(&skt->ops_mutex); 427 socket_shutdown(skt); 428 } 429 430 return ret; 431 } 432 433 static int socket_suspend(struct pcmcia_socket *skt) 434 { 435 if ((skt->state & SOCKET_SUSPEND) && !(skt->state & SOCKET_IN_RESUME)) 436 return -EBUSY; 437 438 mutex_lock(&skt->ops_mutex); 439 /* store state on first suspend, but not after spurious wakeups */ 440 if (!(skt->state & SOCKET_IN_RESUME)) 441 skt->suspended_state = skt->state; 442 443 skt->socket = dead_socket; 444 skt->ops->set_socket(skt, &skt->socket); 445 if (skt->ops->suspend) 446 skt->ops->suspend(skt); 447 skt->state |= SOCKET_SUSPEND; 448 skt->state &= ~SOCKET_IN_RESUME; 449 mutex_unlock(&skt->ops_mutex); 450 return 0; 451 } 452 453 static int socket_early_resume(struct pcmcia_socket *skt) 454 { 455 mutex_lock(&skt->ops_mutex); 456 skt->socket = dead_socket; 457 skt->ops->init(skt); 458 skt->ops->set_socket(skt, &skt->socket); 459 if (skt->state & SOCKET_PRESENT) 460 skt->resume_status = socket_setup(skt, resume_delay); 461 skt->state |= SOCKET_IN_RESUME; 462 mutex_unlock(&skt->ops_mutex); 463 return 0; 464 } 465 466 static int socket_late_resume(struct pcmcia_socket *skt) 467 { 468 int ret = 0; 469 470 mutex_lock(&skt->ops_mutex); 471 skt->state &= ~(SOCKET_SUSPEND | SOCKET_IN_RESUME); 472 mutex_unlock(&skt->ops_mutex); 473 474 if (!(skt->state & SOCKET_PRESENT)) { 475 ret = socket_insert(skt); 476 if (ret == -ENODEV) 477 ret = 0; 478 return ret; 479 } 480 481 if (skt->resume_status) { 482 socket_shutdown(skt); 483 return 0; 484 } 485 486 if (skt->suspended_state != skt->state) { 487 dev_dbg(&skt->dev, 488 "suspend state 0x%x != resume state 0x%x\n", 489 skt->suspended_state, skt->state); 490 491 socket_shutdown(skt); 492 return socket_insert(skt); 493 } 494 495 if (!(skt->state & SOCKET_CARDBUS) && (skt->callback)) 496 ret = skt->callback->early_resume(skt); 497 return ret; 498 } 499 500 /* 501 * Finalize the resume. In case of a cardbus socket, we have 502 * to rebind the devices as we can't be certain that it has been 503 * replaced, or not. 504 */ 505 static int socket_complete_resume(struct pcmcia_socket *skt) 506 { 507 int ret = 0; 508 #ifdef CONFIG_CARDBUS 509 if (skt->state & SOCKET_CARDBUS) { 510 /* We can't be sure the CardBus card is the same 511 * as the one previously inserted. Therefore, remove 512 * and re-add... */ 513 cb_free(skt); 514 ret = cb_alloc(skt); 515 if (ret) 516 cb_free(skt); 517 } 518 #endif 519 return ret; 520 } 521 522 /* 523 * Resume a socket. If a card is present, verify its CIS against 524 * our cached copy. If they are different, the card has been 525 * replaced, and we need to tell the drivers. 526 */ 527 static int socket_resume(struct pcmcia_socket *skt) 528 { 529 int err; 530 if (!(skt->state & SOCKET_SUSPEND)) 531 return -EBUSY; 532 533 socket_early_resume(skt); 534 err = socket_late_resume(skt); 535 if (!err) 536 err = socket_complete_resume(skt); 537 return err; 538 } 539 540 static void socket_remove(struct pcmcia_socket *skt) 541 { 542 dev_notice(&skt->dev, "pccard: card ejected from slot %d\n", skt->sock); 543 socket_shutdown(skt); 544 } 545 546 /* 547 * Process a socket card detect status change. 548 * 549 * If we don't have a card already present, delay the detect event for 550 * about 20ms (to be on the safe side) before reading the socket status. 551 * 552 * Some i82365-based systems send multiple SS_DETECT events during card 553 * insertion, and the "card present" status bit seems to bounce. This 554 * will probably be true with GPIO-based card detection systems after 555 * the product has aged. 556 */ 557 static void socket_detect_change(struct pcmcia_socket *skt) 558 { 559 if (!(skt->state & SOCKET_SUSPEND)) { 560 int status; 561 562 if (!(skt->state & SOCKET_PRESENT)) 563 msleep(20); 564 565 skt->ops->get_status(skt, &status); 566 if ((skt->state & SOCKET_PRESENT) && 567 !(status & SS_DETECT)) 568 socket_remove(skt); 569 if (!(skt->state & SOCKET_PRESENT) && 570 (status & SS_DETECT)) 571 socket_insert(skt); 572 } 573 } 574 575 static int pccardd(void *__skt) 576 { 577 struct pcmcia_socket *skt = __skt; 578 int ret; 579 580 skt->thread = current; 581 skt->socket = dead_socket; 582 skt->ops->init(skt); 583 skt->ops->set_socket(skt, &skt->socket); 584 585 /* register with the device core */ 586 ret = device_register(&skt->dev); 587 if (ret) { 588 dev_warn(&skt->dev, "PCMCIA: unable to register socket\n"); 589 skt->thread = NULL; 590 complete(&skt->thread_done); 591 put_device(&skt->dev); 592 return 0; 593 } 594 ret = pccard_sysfs_add_socket(&skt->dev); 595 if (ret) 596 dev_warn(&skt->dev, "err %d adding socket attributes\n", ret); 597 598 complete(&skt->thread_done); 599 600 /* wait for userspace to catch up */ 601 msleep(250); 602 603 set_freezable(); 604 for (;;) { 605 unsigned long flags; 606 unsigned int events; 607 unsigned int sysfs_events; 608 609 spin_lock_irqsave(&skt->thread_lock, flags); 610 events = skt->thread_events; 611 skt->thread_events = 0; 612 sysfs_events = skt->sysfs_events; 613 skt->sysfs_events = 0; 614 spin_unlock_irqrestore(&skt->thread_lock, flags); 615 616 mutex_lock(&skt->skt_mutex); 617 if (events & SS_DETECT) 618 socket_detect_change(skt); 619 620 if (sysfs_events) { 621 if (sysfs_events & PCMCIA_UEVENT_EJECT) 622 socket_remove(skt); 623 if (sysfs_events & PCMCIA_UEVENT_INSERT) 624 socket_insert(skt); 625 if ((sysfs_events & PCMCIA_UEVENT_SUSPEND) && 626 !(skt->state & SOCKET_CARDBUS)) { 627 if (skt->callback) 628 ret = skt->callback->suspend(skt); 629 else 630 ret = 0; 631 if (!ret) { 632 socket_suspend(skt); 633 msleep(100); 634 } 635 } 636 if ((sysfs_events & PCMCIA_UEVENT_RESUME) && 637 !(skt->state & SOCKET_CARDBUS)) { 638 ret = socket_resume(skt); 639 if (!ret && skt->callback) 640 skt->callback->resume(skt); 641 } 642 if ((sysfs_events & PCMCIA_UEVENT_REQUERY) && 643 !(skt->state & SOCKET_CARDBUS)) { 644 if (!ret && skt->callback) 645 skt->callback->requery(skt); 646 } 647 } 648 mutex_unlock(&skt->skt_mutex); 649 650 if (events || sysfs_events) 651 continue; 652 653 set_current_state(TASK_INTERRUPTIBLE); 654 if (kthread_should_stop()) 655 break; 656 657 schedule(); 658 659 try_to_freeze(); 660 } 661 /* make sure we are running before we exit */ 662 __set_current_state(TASK_RUNNING); 663 664 /* shut down socket, if a device is still present */ 665 if (skt->state & SOCKET_PRESENT) { 666 mutex_lock(&skt->skt_mutex); 667 socket_remove(skt); 668 mutex_unlock(&skt->skt_mutex); 669 } 670 671 /* remove from the device core */ 672 pccard_sysfs_remove_socket(&skt->dev); 673 device_unregister(&skt->dev); 674 675 return 0; 676 } 677 678 /* 679 * Yenta (at least) probes interrupts before registering the socket and 680 * starting the handler thread. 681 */ 682 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events) 683 { 684 unsigned long flags; 685 dev_dbg(&s->dev, "parse_events: events %08x\n", events); 686 if (s->thread) { 687 spin_lock_irqsave(&s->thread_lock, flags); 688 s->thread_events |= events; 689 spin_unlock_irqrestore(&s->thread_lock, flags); 690 691 wake_up_process(s->thread); 692 } 693 } /* pcmcia_parse_events */ 694 EXPORT_SYMBOL(pcmcia_parse_events); 695 696 /** 697 * pcmcia_parse_uevents() - tell pccardd to issue manual commands 698 * @s: the PCMCIA socket we wan't to command 699 * @events: events to pass to pccardd 700 * 701 * userspace-issued insert, eject, suspend and resume commands must be 702 * handled by pccardd to avoid any sysfs-related deadlocks. Valid events 703 * are PCMCIA_UEVENT_EJECT (for eject), PCMCIA_UEVENT__INSERT (for insert), 704 * PCMCIA_UEVENT_RESUME (for resume), PCMCIA_UEVENT_SUSPEND (for suspend) 705 * and PCMCIA_UEVENT_REQUERY (for re-querying the PCMCIA card). 706 */ 707 void pcmcia_parse_uevents(struct pcmcia_socket *s, u_int events) 708 { 709 unsigned long flags; 710 dev_dbg(&s->dev, "parse_uevents: events %08x\n", events); 711 if (s->thread) { 712 spin_lock_irqsave(&s->thread_lock, flags); 713 s->sysfs_events |= events; 714 spin_unlock_irqrestore(&s->thread_lock, flags); 715 716 wake_up_process(s->thread); 717 } 718 } 719 EXPORT_SYMBOL(pcmcia_parse_uevents); 720 721 722 /* register pcmcia_callback */ 723 int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c) 724 { 725 int ret = 0; 726 727 /* s->skt_mutex also protects s->callback */ 728 mutex_lock(&s->skt_mutex); 729 730 if (c) { 731 /* registration */ 732 if (s->callback) { 733 ret = -EBUSY; 734 goto err; 735 } 736 737 s->callback = c; 738 739 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT) 740 s->callback->add(s); 741 } else 742 s->callback = NULL; 743 err: 744 mutex_unlock(&s->skt_mutex); 745 746 return ret; 747 } 748 EXPORT_SYMBOL(pccard_register_pcmcia); 749 750 751 /* I'm not sure which "reset" function this is supposed to use, 752 * but for now, it uses the low-level interface's reset, not the 753 * CIS register. 754 */ 755 756 int pcmcia_reset_card(struct pcmcia_socket *skt) 757 { 758 int ret; 759 760 dev_dbg(&skt->dev, "resetting socket\n"); 761 762 mutex_lock(&skt->skt_mutex); 763 do { 764 if (!(skt->state & SOCKET_PRESENT)) { 765 dev_dbg(&skt->dev, "can't reset, not present\n"); 766 ret = -ENODEV; 767 break; 768 } 769 if (skt->state & SOCKET_SUSPEND) { 770 dev_dbg(&skt->dev, "can't reset, suspended\n"); 771 ret = -EBUSY; 772 break; 773 } 774 if (skt->state & SOCKET_CARDBUS) { 775 dev_dbg(&skt->dev, "can't reset, is cardbus\n"); 776 ret = -EPERM; 777 break; 778 } 779 780 if (skt->callback) 781 skt->callback->suspend(skt); 782 mutex_lock(&skt->ops_mutex); 783 ret = socket_reset(skt); 784 mutex_unlock(&skt->ops_mutex); 785 if ((ret == 0) && (skt->callback)) 786 skt->callback->resume(skt); 787 788 ret = 0; 789 } while (0); 790 mutex_unlock(&skt->skt_mutex); 791 792 return ret; 793 } /* reset_card */ 794 EXPORT_SYMBOL(pcmcia_reset_card); 795 796 797 static int pcmcia_socket_uevent(const struct device *dev, 798 struct kobj_uevent_env *env) 799 { 800 const struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); 801 802 if (add_uevent_var(env, "SOCKET_NO=%u", s->sock)) 803 return -ENOMEM; 804 805 return 0; 806 } 807 808 809 static struct completion pcmcia_unload; 810 811 static void pcmcia_release_socket_class(const struct class *data) 812 { 813 complete(&pcmcia_unload); 814 } 815 816 817 #ifdef CONFIG_PM 818 819 static int __pcmcia_pm_op(struct device *dev, 820 int (*callback) (struct pcmcia_socket *skt)) 821 { 822 struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev); 823 int ret; 824 825 mutex_lock(&s->skt_mutex); 826 ret = callback(s); 827 mutex_unlock(&s->skt_mutex); 828 829 return ret; 830 } 831 832 static int pcmcia_socket_dev_suspend_noirq(struct device *dev) 833 { 834 return __pcmcia_pm_op(dev, socket_suspend); 835 } 836 837 static int pcmcia_socket_dev_resume_noirq(struct device *dev) 838 { 839 return __pcmcia_pm_op(dev, socket_early_resume); 840 } 841 842 static int __used pcmcia_socket_dev_resume(struct device *dev) 843 { 844 return __pcmcia_pm_op(dev, socket_late_resume); 845 } 846 847 static void __used pcmcia_socket_dev_complete(struct device *dev) 848 { 849 WARN(__pcmcia_pm_op(dev, socket_complete_resume), 850 "failed to complete resume"); 851 } 852 853 static const struct dev_pm_ops pcmcia_socket_pm_ops = { 854 /* dev_resume may be called with IRQs enabled */ 855 SET_SYSTEM_SLEEP_PM_OPS(NULL, 856 pcmcia_socket_dev_resume) 857 858 /* late suspend must be called with IRQs disabled */ 859 .suspend_noirq = pcmcia_socket_dev_suspend_noirq, 860 .freeze_noirq = pcmcia_socket_dev_suspend_noirq, 861 .poweroff_noirq = pcmcia_socket_dev_suspend_noirq, 862 863 /* early resume must be called with IRQs disabled */ 864 .resume_noirq = pcmcia_socket_dev_resume_noirq, 865 .thaw_noirq = pcmcia_socket_dev_resume_noirq, 866 .restore_noirq = pcmcia_socket_dev_resume_noirq, 867 .complete = pcmcia_socket_dev_complete, 868 }; 869 870 #define PCMCIA_SOCKET_CLASS_PM_OPS (&pcmcia_socket_pm_ops) 871 872 #else /* CONFIG_PM */ 873 874 #define PCMCIA_SOCKET_CLASS_PM_OPS NULL 875 876 #endif /* CONFIG_PM */ 877 878 const struct class pcmcia_socket_class = { 879 .name = "pcmcia_socket", 880 .dev_uevent = pcmcia_socket_uevent, 881 .dev_release = pcmcia_release_socket, 882 .class_release = pcmcia_release_socket_class, 883 .pm = PCMCIA_SOCKET_CLASS_PM_OPS, 884 }; 885 EXPORT_SYMBOL(pcmcia_socket_class); 886 887 888 static int __init init_pcmcia_cs(void) 889 { 890 init_completion(&pcmcia_unload); 891 return class_register(&pcmcia_socket_class); 892 } 893 894 static void __exit exit_pcmcia_cs(void) 895 { 896 class_unregister(&pcmcia_socket_class); 897 wait_for_completion(&pcmcia_unload); 898 } 899 900 subsys_initcall(init_pcmcia_cs); 901 module_exit(exit_pcmcia_cs); 902 903