920 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * cs.c -- Kernel Card Services - core services4 *5 * The initial developer of the original code is David A. Hinds6 * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds7 * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.8 *9 * (C) 1999 David A. Hinds10 */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 40MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");41MODULE_DESCRIPTION("Linux Kernel Card Services");42MODULE_LICENSE("GPL");43 44#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)45 46INT_MODULE_PARM(setup_delay, 10); /* centiseconds */47INT_MODULE_PARM(resume_delay, 20); /* centiseconds */48INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */49INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */50INT_MODULE_PARM(reset_time, 10); /* usecs */51INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */52INT_MODULE_PARM(unreset_check, 10); /* centiseconds */53INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */54 55/* Access speed for attribute memory windows */56INT_MODULE_PARM(cis_speed, 300); /* ns */57 58 59socket_state_t dead_socket = {60 .csc_mask = SS_DETECT,61};62EXPORT_SYMBOL(dead_socket);63 64 65/* List of all sockets, protected by a rwsem */66LIST_HEAD(pcmcia_socket_list);67EXPORT_SYMBOL(pcmcia_socket_list);68 69DECLARE_RWSEM(pcmcia_socket_list_rwsem);70EXPORT_SYMBOL(pcmcia_socket_list_rwsem);71 72 73struct 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}80EXPORT_SYMBOL(pcmcia_get_socket);81 82 83void pcmcia_put_socket(struct pcmcia_socket *skt)84{85 put_device(&skt->dev);86}87EXPORT_SYMBOL(pcmcia_put_socket);88 89 90static 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 97static int pccardd(void *__skt);98 99/**100 * pcmcia_register_socket - add a new pcmcia socket device101 * @socket: the &socket to register102 */103int 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 we114 * register more than 2^sizeof(unsigned int) pcmcia115 * sockets... but the socket number is deprecated116 * 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_CARDBUS137 /*138 * If we do not support Cardbus, ensure that139 * the Cardbus socket capability is disabled.140 */141 socket->features &= ~SS_CAP_CARDBUS;142#endif143 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 CardBus187 * 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 */199EXPORT_SYMBOL(pcmcia_register_socket);200 201 202/**203 * pcmcia_unregister_socket - remove a pcmcia socket device204 * @socket: the &socket to unregister205 */206void 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 */229EXPORT_SYMBOL(pcmcia_unregister_socket);230 231 232struct pcmcia_socket *pcmcia_get_socket_by_nr(unsigned int nr)233{234 struct pcmcia_socket *s;235 236 down_read(&pcmcia_socket_list_rwsem);237 list_for_each_entry(s, &pcmcia_socket_list, socket_list)238 if (s->sock == nr) {239 up_read(&pcmcia_socket_list_rwsem);240 return s;241 }242 up_read(&pcmcia_socket_list_rwsem);243 244 return NULL;245 246}247EXPORT_SYMBOL(pcmcia_get_socket_by_nr);248 249static int socket_reset(struct pcmcia_socket *skt)250{251 int status, i;252 253 dev_dbg(&skt->dev, "reset\n");254 255 skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;256 skt->ops->set_socket(skt, &skt->socket);257 udelay((long)reset_time);258 259 skt->socket.flags &= ~SS_RESET;260 skt->ops->set_socket(skt, &skt->socket);261 262 msleep(unreset_delay * 10);263 for (i = 0; i < unreset_limit; i++) {264 skt->ops->get_status(skt, &status);265 266 if (!(status & SS_DETECT))267 return -ENODEV;268 269 if (status & SS_READY)270 return 0;271 272 msleep(unreset_check * 10);273 }274 275 dev_err(&skt->dev, "time out after reset\n");276 return -ETIMEDOUT;277}278 279/*280 * socket_setup() and socket_shutdown() are called by the main event handler281 * when card insertion and removal events are received.282 * socket_setup() turns on socket power and resets the socket, in two stages.283 * socket_shutdown() unconfigures a socket and turns off socket power.284 */285static void socket_shutdown(struct pcmcia_socket *s)286{287 int status;288 289 dev_dbg(&s->dev, "shutdown\n");290 291 if (s->callback)292 s->callback->remove(s);293 294 mutex_lock(&s->ops_mutex);295 s->state &= SOCKET_INUSE | SOCKET_PRESENT;296 msleep(shutdown_delay * 10);297 s->state &= SOCKET_INUSE;298 299 /* Blank out the socket state */300 s->socket = dead_socket;301 s->ops->init(s);302 s->ops->set_socket(s, &s->socket);303 s->lock_count = 0;304 kfree(s->fake_cis);305 s->fake_cis = NULL;306 s->functions = 0;307 308 /* From here on we can be sure that only we (that is, the309 * pccardd thread) accesses this socket, and all (16-bit)310 * PCMCIA interactions are gone. Therefore, release311 * ops_mutex so that we don't get a sysfs-related lockdep312 * warning.313 */314 mutex_unlock(&s->ops_mutex);315 316#ifdef CONFIG_CARDBUS317 cb_free(s);318#endif319 320 /* give socket some time to power down */321 msleep(100);322 323 s->ops->get_status(s, &status);324 if (status & SS_POWERON) {325 dev_err(&s->dev,326 "*** DANGER *** unable to remove socket power\n");327 }328 329 s->state &= ~SOCKET_INUSE;330}331 332static int socket_setup(struct pcmcia_socket *skt, int initial_delay)333{334 int status, i;335 336 dev_dbg(&skt->dev, "setup\n");337 338 skt->ops->get_status(skt, &status);339 if (!(status & SS_DETECT))340 return -ENODEV;341 342 msleep(initial_delay * 10);343 344 for (i = 0; i < 100; i++) {345 skt->ops->get_status(skt, &status);346 if (!(status & SS_DETECT))347 return -ENODEV;348 349 if (!(status & SS_PENDING))350 break;351 352 msleep(100);353 }354 355 if (status & SS_PENDING) {356 dev_err(&skt->dev, "voltage interrogation timed out\n");357 return -ETIMEDOUT;358 }359 360 if (status & SS_CARDBUS) {361 if (!(skt->features & SS_CAP_CARDBUS)) {362 dev_err(&skt->dev, "cardbus cards are not supported\n");363 return -EINVAL;364 }365 skt->state |= SOCKET_CARDBUS;366 } else367 skt->state &= ~SOCKET_CARDBUS;368 369 /*370 * Decode the card voltage requirements, and apply power to the card.371 */372 if (status & SS_3VCARD)373 skt->socket.Vcc = skt->socket.Vpp = 33;374 else if (!(status & SS_XVCARD))375 skt->socket.Vcc = skt->socket.Vpp = 50;376 else {377 dev_err(&skt->dev, "unsupported voltage key\n");378 return -EIO;379 }380 381 if (skt->power_hook)382 skt->power_hook(skt, HOOK_POWER_PRE);383 384 skt->socket.flags = 0;385 skt->ops->set_socket(skt, &skt->socket);386 387 /*388 * Wait "vcc_settle" for the supply to stabilise.389 */390 msleep(vcc_settle * 10);391 392 skt->ops->get_status(skt, &status);393 if (!(status & SS_POWERON)) {394 dev_err(&skt->dev, "unable to apply power\n");395 return -EIO;396 }397 398 status = socket_reset(skt);399 400 if (skt->power_hook)401 skt->power_hook(skt, HOOK_POWER_POST);402 403 return status;404}405 406/*407 * Handle card insertion. Setup the socket, reset the card,408 * and then tell the rest of PCMCIA that a card is present.409 */410static int socket_insert(struct pcmcia_socket *skt)411{412 int ret;413 414 dev_dbg(&skt->dev, "insert\n");415 416 mutex_lock(&skt->ops_mutex);417 if (skt->state & SOCKET_INUSE) {418 mutex_unlock(&skt->ops_mutex);419 return -EINVAL;420 }421 skt->state |= SOCKET_INUSE;422 423 ret = socket_setup(skt, setup_delay);424 if (ret == 0) {425 skt->state |= SOCKET_PRESENT;426 427 dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n",428 (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA",429 skt->sock);430 431#ifdef CONFIG_CARDBUS432 if (skt->state & SOCKET_CARDBUS) {433 cb_alloc(skt);434 skt->state |= SOCKET_CARDBUS_CONFIG;435 }436#endif437 dev_dbg(&skt->dev, "insert done\n");438 mutex_unlock(&skt->ops_mutex);439 440 if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))441 skt->callback->add(skt);442 } else {443 mutex_unlock(&skt->ops_mutex);444 socket_shutdown(skt);445 }446 447 return ret;448}449 450static int socket_suspend(struct pcmcia_socket *skt)451{452 if ((skt->state & SOCKET_SUSPEND) && !(skt->state & SOCKET_IN_RESUME))453 return -EBUSY;454 455 mutex_lock(&skt->ops_mutex);456 /* store state on first suspend, but not after spurious wakeups */457 if (!(skt->state & SOCKET_IN_RESUME))458 skt->suspended_state = skt->state;459 460 skt->socket = dead_socket;461 skt->ops->set_socket(skt, &skt->socket);462 if (skt->ops->suspend)463 skt->ops->suspend(skt);464 skt->state |= SOCKET_SUSPEND;465 skt->state &= ~SOCKET_IN_RESUME;466 mutex_unlock(&skt->ops_mutex);467 return 0;468}469 470static int socket_early_resume(struct pcmcia_socket *skt)471{472 mutex_lock(&skt->ops_mutex);473 skt->socket = dead_socket;474 skt->ops->init(skt);475 skt->ops->set_socket(skt, &skt->socket);476 if (skt->state & SOCKET_PRESENT)477 skt->resume_status = socket_setup(skt, resume_delay);478 skt->state |= SOCKET_IN_RESUME;479 mutex_unlock(&skt->ops_mutex);480 return 0;481}482 483static int socket_late_resume(struct pcmcia_socket *skt)484{485 int ret = 0;486 487 mutex_lock(&skt->ops_mutex);488 skt->state &= ~(SOCKET_SUSPEND | SOCKET_IN_RESUME);489 mutex_unlock(&skt->ops_mutex);490 491 if (!(skt->state & SOCKET_PRESENT)) {492 ret = socket_insert(skt);493 if (ret == -ENODEV)494 ret = 0;495 return ret;496 }497 498 if (skt->resume_status) {499 socket_shutdown(skt);500 return 0;501 }502 503 if (skt->suspended_state != skt->state) {504 dev_dbg(&skt->dev,505 "suspend state 0x%x != resume state 0x%x\n",506 skt->suspended_state, skt->state);507 508 socket_shutdown(skt);509 return socket_insert(skt);510 }511 512 if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))513 ret = skt->callback->early_resume(skt);514 return ret;515}516 517/*518 * Finalize the resume. In case of a cardbus socket, we have519 * to rebind the devices as we can't be certain that it has been520 * replaced, or not.521 */522static int socket_complete_resume(struct pcmcia_socket *skt)523{524 int ret = 0;525#ifdef CONFIG_CARDBUS526 if (skt->state & SOCKET_CARDBUS) {527 /* We can't be sure the CardBus card is the same528 * as the one previously inserted. Therefore, remove529 * and re-add... */530 cb_free(skt);531 ret = cb_alloc(skt);532 if (ret)533 cb_free(skt);534 }535#endif536 return ret;537}538 539/*540 * Resume a socket. If a card is present, verify its CIS against541 * our cached copy. If they are different, the card has been542 * replaced, and we need to tell the drivers.543 */544static int socket_resume(struct pcmcia_socket *skt)545{546 int err;547 if (!(skt->state & SOCKET_SUSPEND))548 return -EBUSY;549 550 socket_early_resume(skt);551 err = socket_late_resume(skt);552 if (!err)553 err = socket_complete_resume(skt);554 return err;555}556 557static void socket_remove(struct pcmcia_socket *skt)558{559 dev_notice(&skt->dev, "pccard: card ejected from slot %d\n", skt->sock);560 socket_shutdown(skt);561}562 563/*564 * Process a socket card detect status change.565 *566 * If we don't have a card already present, delay the detect event for567 * about 20ms (to be on the safe side) before reading the socket status.568 *569 * Some i82365-based systems send multiple SS_DETECT events during card570 * insertion, and the "card present" status bit seems to bounce. This571 * will probably be true with GPIO-based card detection systems after572 * the product has aged.573 */574static void socket_detect_change(struct pcmcia_socket *skt)575{576 if (!(skt->state & SOCKET_SUSPEND)) {577 int status;578 579 if (!(skt->state & SOCKET_PRESENT))580 msleep(20);581 582 skt->ops->get_status(skt, &status);583 if ((skt->state & SOCKET_PRESENT) &&584 !(status & SS_DETECT))585 socket_remove(skt);586 if (!(skt->state & SOCKET_PRESENT) &&587 (status & SS_DETECT))588 socket_insert(skt);589 }590}591 592static int pccardd(void *__skt)593{594 struct pcmcia_socket *skt = __skt;595 int ret;596 597 skt->thread = current;598 skt->socket = dead_socket;599 skt->ops->init(skt);600 skt->ops->set_socket(skt, &skt->socket);601 602 /* register with the device core */603 ret = device_register(&skt->dev);604 if (ret) {605 dev_warn(&skt->dev, "PCMCIA: unable to register socket\n");606 skt->thread = NULL;607 complete(&skt->thread_done);608 put_device(&skt->dev);609 return 0;610 }611 ret = pccard_sysfs_add_socket(&skt->dev);612 if (ret)613 dev_warn(&skt->dev, "err %d adding socket attributes\n", ret);614 615 complete(&skt->thread_done);616 617 /* wait for userspace to catch up */618 msleep(250);619 620 set_freezable();621 for (;;) {622 unsigned long flags;623 unsigned int events;624 unsigned int sysfs_events;625 626 spin_lock_irqsave(&skt->thread_lock, flags);627 events = skt->thread_events;628 skt->thread_events = 0;629 sysfs_events = skt->sysfs_events;630 skt->sysfs_events = 0;631 spin_unlock_irqrestore(&skt->thread_lock, flags);632 633 mutex_lock(&skt->skt_mutex);634 if (events & SS_DETECT)635 socket_detect_change(skt);636 637 if (sysfs_events) {638 if (sysfs_events & PCMCIA_UEVENT_EJECT)639 socket_remove(skt);640 if (sysfs_events & PCMCIA_UEVENT_INSERT)641 socket_insert(skt);642 if ((sysfs_events & PCMCIA_UEVENT_SUSPEND) &&643 !(skt->state & SOCKET_CARDBUS)) {644 if (skt->callback)645 ret = skt->callback->suspend(skt);646 else647 ret = 0;648 if (!ret) {649 socket_suspend(skt);650 msleep(100);651 }652 }653 if ((sysfs_events & PCMCIA_UEVENT_RESUME) &&654 !(skt->state & SOCKET_CARDBUS)) {655 ret = socket_resume(skt);656 if (!ret && skt->callback)657 skt->callback->resume(skt);658 }659 if ((sysfs_events & PCMCIA_UEVENT_REQUERY) &&660 !(skt->state & SOCKET_CARDBUS)) {661 if (!ret && skt->callback)662 skt->callback->requery(skt);663 }664 }665 mutex_unlock(&skt->skt_mutex);666 667 if (events || sysfs_events)668 continue;669 670 set_current_state(TASK_INTERRUPTIBLE);671 if (kthread_should_stop())672 break;673 674 schedule();675 676 try_to_freeze();677 }678 /* make sure we are running before we exit */679 __set_current_state(TASK_RUNNING);680 681 /* shut down socket, if a device is still present */682 if (skt->state & SOCKET_PRESENT) {683 mutex_lock(&skt->skt_mutex);684 socket_remove(skt);685 mutex_unlock(&skt->skt_mutex);686 }687 688 /* remove from the device core */689 pccard_sysfs_remove_socket(&skt->dev);690 device_unregister(&skt->dev);691 692 return 0;693}694 695/*696 * Yenta (at least) probes interrupts before registering the socket and697 * starting the handler thread.698 */699void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)700{701 unsigned long flags;702 dev_dbg(&s->dev, "parse_events: events %08x\n", events);703 if (s->thread) {704 spin_lock_irqsave(&s->thread_lock, flags);705 s->thread_events |= events;706 spin_unlock_irqrestore(&s->thread_lock, flags);707 708 wake_up_process(s->thread);709 }710} /* pcmcia_parse_events */711EXPORT_SYMBOL(pcmcia_parse_events);712 713/**714 * pcmcia_parse_uevents() - tell pccardd to issue manual commands715 * @s: the PCMCIA socket we wan't to command716 * @events: events to pass to pccardd717 *718 * userspace-issued insert, eject, suspend and resume commands must be719 * handled by pccardd to avoid any sysfs-related deadlocks. Valid events720 * are PCMCIA_UEVENT_EJECT (for eject), PCMCIA_UEVENT__INSERT (for insert),721 * PCMCIA_UEVENT_RESUME (for resume), PCMCIA_UEVENT_SUSPEND (for suspend)722 * and PCMCIA_UEVENT_REQUERY (for re-querying the PCMCIA card).723 */724void pcmcia_parse_uevents(struct pcmcia_socket *s, u_int events)725{726 unsigned long flags;727 dev_dbg(&s->dev, "parse_uevents: events %08x\n", events);728 if (s->thread) {729 spin_lock_irqsave(&s->thread_lock, flags);730 s->sysfs_events |= events;731 spin_unlock_irqrestore(&s->thread_lock, flags);732 733 wake_up_process(s->thread);734 }735}736EXPORT_SYMBOL(pcmcia_parse_uevents);737 738 739/* register pcmcia_callback */740int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)741{742 int ret = 0;743 744 /* s->skt_mutex also protects s->callback */745 mutex_lock(&s->skt_mutex);746 747 if (c) {748 /* registration */749 if (s->callback) {750 ret = -EBUSY;751 goto err;752 }753 754 s->callback = c;755 756 if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)757 s->callback->add(s);758 } else759 s->callback = NULL;760 err:761 mutex_unlock(&s->skt_mutex);762 763 return ret;764}765EXPORT_SYMBOL(pccard_register_pcmcia);766 767 768/* I'm not sure which "reset" function this is supposed to use,769 * but for now, it uses the low-level interface's reset, not the770 * CIS register.771 */772 773int pcmcia_reset_card(struct pcmcia_socket *skt)774{775 int ret;776 777 dev_dbg(&skt->dev, "resetting socket\n");778 779 mutex_lock(&skt->skt_mutex);780 do {781 if (!(skt->state & SOCKET_PRESENT)) {782 dev_dbg(&skt->dev, "can't reset, not present\n");783 ret = -ENODEV;784 break;785 }786 if (skt->state & SOCKET_SUSPEND) {787 dev_dbg(&skt->dev, "can't reset, suspended\n");788 ret = -EBUSY;789 break;790 }791 if (skt->state & SOCKET_CARDBUS) {792 dev_dbg(&skt->dev, "can't reset, is cardbus\n");793 ret = -EPERM;794 break;795 }796 797 if (skt->callback)798 skt->callback->suspend(skt);799 mutex_lock(&skt->ops_mutex);800 ret = socket_reset(skt);801 mutex_unlock(&skt->ops_mutex);802 if ((ret == 0) && (skt->callback))803 skt->callback->resume(skt);804 805 ret = 0;806 } while (0);807 mutex_unlock(&skt->skt_mutex);808 809 return ret;810} /* reset_card */811EXPORT_SYMBOL(pcmcia_reset_card);812 813 814static int pcmcia_socket_uevent(const struct device *dev,815 struct kobj_uevent_env *env)816{817 const struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);818 819 if (add_uevent_var(env, "SOCKET_NO=%u", s->sock))820 return -ENOMEM;821 822 return 0;823}824 825 826static struct completion pcmcia_unload;827 828static void pcmcia_release_socket_class(const struct class *data)829{830 complete(&pcmcia_unload);831}832 833 834#ifdef CONFIG_PM835 836static int __pcmcia_pm_op(struct device *dev,837 int (*callback) (struct pcmcia_socket *skt))838{839 struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);840 int ret;841 842 mutex_lock(&s->skt_mutex);843 ret = callback(s);844 mutex_unlock(&s->skt_mutex);845 846 return ret;847}848 849static int pcmcia_socket_dev_suspend_noirq(struct device *dev)850{851 return __pcmcia_pm_op(dev, socket_suspend);852}853 854static int pcmcia_socket_dev_resume_noirq(struct device *dev)855{856 return __pcmcia_pm_op(dev, socket_early_resume);857}858 859static int __used pcmcia_socket_dev_resume(struct device *dev)860{861 return __pcmcia_pm_op(dev, socket_late_resume);862}863 864static void __used pcmcia_socket_dev_complete(struct device *dev)865{866 WARN(__pcmcia_pm_op(dev, socket_complete_resume),867 "failed to complete resume");868}869 870static const struct dev_pm_ops pcmcia_socket_pm_ops = {871 /* dev_resume may be called with IRQs enabled */872 SET_SYSTEM_SLEEP_PM_OPS(NULL,873 pcmcia_socket_dev_resume)874 875 /* late suspend must be called with IRQs disabled */876 .suspend_noirq = pcmcia_socket_dev_suspend_noirq,877 .freeze_noirq = pcmcia_socket_dev_suspend_noirq,878 .poweroff_noirq = pcmcia_socket_dev_suspend_noirq,879 880 /* early resume must be called with IRQs disabled */881 .resume_noirq = pcmcia_socket_dev_resume_noirq,882 .thaw_noirq = pcmcia_socket_dev_resume_noirq,883 .restore_noirq = pcmcia_socket_dev_resume_noirq,884 .complete = pcmcia_socket_dev_complete,885};886 887#define PCMCIA_SOCKET_CLASS_PM_OPS (&pcmcia_socket_pm_ops)888 889#else /* CONFIG_PM */890 891#define PCMCIA_SOCKET_CLASS_PM_OPS NULL892 893#endif /* CONFIG_PM */894 895const struct class pcmcia_socket_class = {896 .name = "pcmcia_socket",897 .dev_uevent = pcmcia_socket_uevent,898 .dev_release = pcmcia_release_socket,899 .class_release = pcmcia_release_socket_class,900 .pm = PCMCIA_SOCKET_CLASS_PM_OPS,901};902EXPORT_SYMBOL(pcmcia_socket_class);903 904 905static int __init init_pcmcia_cs(void)906{907 init_completion(&pcmcia_unload);908 return class_register(&pcmcia_socket_class);909}910 911static void __exit exit_pcmcia_cs(void)912{913 class_unregister(&pcmcia_socket_class);914 wait_for_completion(&pcmcia_unload);915}916 917subsys_initcall(init_pcmcia_cs);918module_exit(exit_pcmcia_cs);919 920