drivers/pcmcia/cs.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * cs.c -- Kernel Card Services - core services
0004  *
0005  * The initial developer of the original code is David A. Hinds
0006  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
0007  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
0008  *
0009  * (C) 1999     David A. Hinds
0010  */
0011
0012 #include <linux/module.h>
0013 #include <linux/moduleparam.h>
0014 #include <linux/init.h>
0015 #include <linux/kernel.h>
0016 #include <linux/string.h>
0017 #include <linux/major.h>
0018 #include <linux/errno.h>
0019 #include <linux/slab.h>
0020 #include <linux/mm.h>
0021 #include <linux/interrupt.h>
0022 #include <linux/timer.h>
0023 #include <linux/ioport.h>
0024 #include <linux/delay.h>
0025 #include <linux/pm.h>
0026 #include <linux/device.h>
0027 #include <linux/kthread.h>
0028 #include <linux/freezer.h>
0029 #include <asm/irq.h>
0030
0031 #include <pcmcia/ss.h>
0032 #include <pcmcia/cistpl.h>
0033 #include <pcmcia/cisreg.h>
0034 #include <pcmcia/ds.h>
0035 #include "cs_internal.h"
0036
0037
0038 /* Module parameters */
0039
0040 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
0041 MODULE_DESCRIPTION("Linux Kernel Card Services");
0042 MODULE_LICENSE("GPL");
0043
0044 #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
0045
0046 INT_MODULE_PARM(setup_delay,    10);        /* centiseconds */
0047 INT_MODULE_PARM(resume_delay,   20);        /* centiseconds */
0048 INT_MODULE_PARM(shutdown_delay, 3);     /* centiseconds */
0049 INT_MODULE_PARM(vcc_settle, 40);        /* centiseconds */
0050 INT_MODULE_PARM(reset_time, 10);        /* usecs */
0051 INT_MODULE_PARM(unreset_delay,  10);        /* centiseconds */
0052 INT_MODULE_PARM(unreset_check,  10);        /* centiseconds */
0053 INT_MODULE_PARM(unreset_limit,  30);        /* unreset_check's */
0054
0055 /* Access speed for attribute memory windows */
0056 INT_MODULE_PARM(cis_speed,  300);       /* ns */
0057
0058
0059 socket_state_t dead_socket = {
0060     .csc_mask   = SS_DETECT,
0061 };
0062 EXPORT_SYMBOL(dead_socket);
0063
0064
0065 /* List of all sockets, protected by a rwsem */
0066 LIST_HEAD(pcmcia_socket_list);
0067 EXPORT_SYMBOL(pcmcia_socket_list);
0068
0069 DECLARE_RWSEM(pcmcia_socket_list_rwsem);
0070 EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
0071
0072
0073 struct pcmcia_socket *pcmcia_get_socket(struct pcmcia_socket *skt)
0074 {
0075     struct device *dev = get_device(&skt->dev);
0076     if (!dev)
0077         return NULL;
0078     return dev_get_drvdata(dev);
0079 }
0080 EXPORT_SYMBOL(pcmcia_get_socket);
0081
0082
0083 void pcmcia_put_socket(struct pcmcia_socket *skt)
0084 {
0085     put_device(&skt->dev);
0086 }
0087 EXPORT_SYMBOL(pcmcia_put_socket);
0088
0089
0090 static void pcmcia_release_socket(struct device *dev)
0091 {
0092     struct pcmcia_socket *socket = dev_get_drvdata(dev);
0093
0094     complete(&socket->socket_released);
0095 }
0096
0097 static int pccardd(void *__skt);
0098
0099 /**
0100  * pcmcia_register_socket - add a new pcmcia socket device
0101  * @socket: the &socket to register
0102  */
0103 int pcmcia_register_socket(struct pcmcia_socket *socket)
0104 {
0105     struct task_struct *tsk;
0106     int ret;
0107
0108     if (!socket || !socket->ops || !socket->dev.parent || !socket->resource_ops)
0109         return -EINVAL;
0110
0111     dev_dbg(&socket->dev, "pcmcia_register_socket(0x%p)\n", socket->ops);
0112
0113     /* try to obtain a socket number [yes, it gets ugly if we
0114      * register more than 2^sizeof(unsigned int) pcmcia
0115      * sockets... but the socket number is deprecated
0116      * anyways, so I don't care] */
0117     down_write(&pcmcia_socket_list_rwsem);
0118     if (list_empty(&pcmcia_socket_list))
0119         socket->sock = 0;
0120     else {
0121         unsigned int found, i = 1;
0122         struct pcmcia_socket *tmp;
0123         do {
0124             found = 1;
0125             list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
0126                 if (tmp->sock == i)
0127                     found = 0;
0128             }
0129             i++;
0130         } while (!found);
0131         socket->sock = i - 1;
0132     }
0133     list_add_tail(&socket->socket_list, &pcmcia_socket_list);
0134     up_write(&pcmcia_socket_list_rwsem);
0135
0136 #ifndef CONFIG_CARDBUS
0137     /*
0138      * If we do not support Cardbus, ensure that
0139      * the Cardbus socket capability is disabled.
0140      */
0141     socket->features &= ~SS_CAP_CARDBUS;
0142 #endif
0143
0144     /* set proper values in socket->dev */
0145     dev_set_drvdata(&socket->dev, socket);
0146     socket->dev.class = &pcmcia_socket_class;
0147     dev_set_name(&socket->dev, "pcmcia_socket%u", socket->sock);
0148
0149     /* base address = 0, map = 0 */
0150     socket->cis_mem.flags = 0;
0151     socket->cis_mem.speed = cis_speed;
0152
0153     INIT_LIST_HEAD(&socket->cis_cache);
0154
0155     init_completion(&socket->socket_released);
0156     init_completion(&socket->thread_done);
0157     mutex_init(&socket->skt_mutex);
0158     mutex_init(&socket->ops_mutex);
0159     spin_lock_init(&socket->thread_lock);
0160
0161     if (socket->resource_ops->init) {
0162         mutex_lock(&socket->ops_mutex);
0163         ret = socket->resource_ops->init(socket);
0164         mutex_unlock(&socket->ops_mutex);
0165         if (ret)
0166             goto err;
0167     }
0168
0169     tsk = kthread_run(pccardd, socket, "pccardd");
0170     if (IS_ERR(tsk)) {
0171         ret = PTR_ERR(tsk);
0172         goto err;
0173     }
0174
0175     wait_for_completion(&socket->thread_done);
0176     if (!socket->thread) {
0177         dev_warn(&socket->dev,
0178              "PCMCIA: warning: socket thread did not start\n");
0179         return -EIO;
0180     }
0181
0182     pcmcia_parse_events(socket, SS_DETECT);
0183
0184     /*
0185      * Let's try to get the PCMCIA module for 16-bit PCMCIA support.
0186      * If it fails, it doesn't matter -- we still have 32-bit CardBus
0187      * support to offer, so this is not a failure mode.
0188      */
0189     request_module_nowait("pcmcia");
0190
0191     return 0;
0192
0193  err:
0194     down_write(&pcmcia_socket_list_rwsem);
0195     list_del(&socket->socket_list);
0196     up_write(&pcmcia_socket_list_rwsem);
0197     return ret;
0198 } /* pcmcia_register_socket */
0199 EXPORT_SYMBOL(pcmcia_register_socket);
0200
0201
0202 /**
0203  * pcmcia_unregister_socket - remove a pcmcia socket device
0204  * @socket: the &socket to unregister
0205  */
0206 void pcmcia_unregister_socket(struct pcmcia_socket *socket)
0207 {
0208     if (!socket)
0209         return;
0210
0211     dev_dbg(&socket->dev, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
0212
0213     if (socket->thread)
0214         kthread_stop(socket->thread);
0215
0216     /* remove from our own list */
0217     down_write(&pcmcia_socket_list_rwsem);
0218     list_del(&socket->socket_list);
0219     up_write(&pcmcia_socket_list_rwsem);
0220
0221     /* wait for sysfs to drop all references */
0222     if (socket->resource_ops->exit) {
0223         mutex_lock(&socket->ops_mutex);
0224         socket->resource_ops->exit(socket);
0225         mutex_unlock(&socket->ops_mutex);
0226     }
0227     wait_for_completion(&socket->socket_released);
0228 } /* pcmcia_unregister_socket */
0229 EXPORT_SYMBOL(pcmcia_unregister_socket);
0230
0231
0232 struct pcmcia_socket *pcmcia_get_socket_by_nr(unsigned int nr)
0233 {
0234     struct pcmcia_socket *s;
0235
0236     down_read(&pcmcia_socket_list_rwsem);
0237     list_for_each_entry(s, &pcmcia_socket_list, socket_list)
0238         if (s->sock == nr) {
0239             up_read(&pcmcia_socket_list_rwsem);
0240             return s;
0241         }
0242     up_read(&pcmcia_socket_list_rwsem);
0243
0244     return NULL;
0245
0246 }
0247 EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
0248
0249 static int socket_reset(struct pcmcia_socket *skt)
0250 {
0251     int status, i;
0252
0253     dev_dbg(&skt->dev, "reset\n");
0254
0255     skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
0256     skt->ops->set_socket(skt, &skt->socket);
0257     udelay((long)reset_time);
0258
0259     skt->socket.flags &= ~SS_RESET;
0260     skt->ops->set_socket(skt, &skt->socket);
0261
0262     msleep(unreset_delay * 10);
0263     for (i = 0; i < unreset_limit; i++) {
0264         skt->ops->get_status(skt, &status);
0265
0266         if (!(status & SS_DETECT))
0267             return -ENODEV;
0268
0269         if (status & SS_READY)
0270             return 0;
0271
0272         msleep(unreset_check * 10);
0273     }
0274
0275     dev_err(&skt->dev, "time out after reset\n");
0276     return -ETIMEDOUT;
0277 }
0278
0279 /*
0280  * socket_setup() and socket_shutdown() are called by the main event handler
0281  * when card insertion and removal events are received.
0282  * socket_setup() turns on socket power and resets the socket, in two stages.
0283  * socket_shutdown() unconfigures a socket and turns off socket power.
0284  */
0285 static void socket_shutdown(struct pcmcia_socket *s)
0286 {
0287     int status;
0288
0289     dev_dbg(&s->dev, "shutdown\n");
0290
0291     if (s->callback)
0292         s->callback->remove(s);
0293
0294     mutex_lock(&s->ops_mutex);
0295     s->state &= SOCKET_INUSE | SOCKET_PRESENT;
0296     msleep(shutdown_delay * 10);
0297     s->state &= SOCKET_INUSE;
0298
0299     /* Blank out the socket state */
0300     s->socket = dead_socket;
0301     s->ops->init(s);
0302     s->ops->set_socket(s, &s->socket);
0303     s->lock_count = 0;
0304     kfree(s->fake_cis);
0305     s->fake_cis = NULL;
0306     s->functions = 0;
0307
0308     /* From here on we can be sure that only we (that is, the
0309      * pccardd thread) accesses this socket, and all (16-bit)
0310      * PCMCIA interactions are gone. Therefore, release
0311      * ops_mutex so that we don't get a sysfs-related lockdep
0312      * warning.
0313      */
0314     mutex_unlock(&s->ops_mutex);
0315
0316 #ifdef CONFIG_CARDBUS
0317     cb_free(s);
0318 #endif
0319
0320     /* give socket some time to power down */
0321     msleep(100);
0322
0323     s->ops->get_status(s, &status);
0324     if (status & SS_POWERON) {
0325         dev_err(&s->dev,
0326             "*** DANGER *** unable to remove socket power\n");
0327     }
0328
0329     s->state &= ~SOCKET_INUSE;
0330 }
0331
0332 static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
0333 {
0334     int status, i;
0335
0336     dev_dbg(&skt->dev, "setup\n");
0337
0338     skt->ops->get_status(skt, &status);
0339     if (!(status & SS_DETECT))
0340         return -ENODEV;
0341
0342     msleep(initial_delay * 10);
0343
0344     for (i = 0; i < 100; i++) {
0345         skt->ops->get_status(skt, &status);
0346         if (!(status & SS_DETECT))
0347             return -ENODEV;
0348
0349         if (!(status & SS_PENDING))
0350             break;
0351
0352         msleep(100);
0353     }
0354
0355     if (status & SS_PENDING) {
0356         dev_err(&skt->dev, "voltage interrogation timed out\n");
0357         return -ETIMEDOUT;
0358     }
0359
0360     if (status & SS_CARDBUS) {
0361         if (!(skt->features & SS_CAP_CARDBUS)) {
0362             dev_err(&skt->dev, "cardbus cards are not supported\n");
0363             return -EINVAL;
0364         }
0365         skt->state |= SOCKET_CARDBUS;
0366     } else
0367         skt->state &= ~SOCKET_CARDBUS;
0368
0369     /*
0370      * Decode the card voltage requirements, and apply power to the card.
0371      */
0372     if (status & SS_3VCARD)
0373         skt->socket.Vcc = skt->socket.Vpp = 33;
0374     else if (!(status & SS_XVCARD))
0375         skt->socket.Vcc = skt->socket.Vpp = 50;
0376     else {
0377         dev_err(&skt->dev, "unsupported voltage key\n");
0378         return -EIO;
0379     }
0380
0381     if (skt->power_hook)
0382         skt->power_hook(skt, HOOK_POWER_PRE);
0383
0384     skt->socket.flags = 0;
0385     skt->ops->set_socket(skt, &skt->socket);
0386
0387     /*
0388      * Wait "vcc_settle" for the supply to stabilise.
0389      */
0390     msleep(vcc_settle * 10);
0391
0392     skt->ops->get_status(skt, &status);
0393     if (!(status & SS_POWERON)) {
0394         dev_err(&skt->dev, "unable to apply power\n");
0395         return -EIO;
0396     }
0397
0398     status = socket_reset(skt);
0399
0400     if (skt->power_hook)
0401         skt->power_hook(skt, HOOK_POWER_POST);
0402
0403     return status;
0404 }
0405
0406 /*
0407  * Handle card insertion.  Setup the socket, reset the card,
0408  * and then tell the rest of PCMCIA that a card is present.
0409  */
0410 static int socket_insert(struct pcmcia_socket *skt)
0411 {
0412     int ret;
0413
0414     dev_dbg(&skt->dev, "insert\n");
0415
0416     mutex_lock(&skt->ops_mutex);
0417     if (skt->state & SOCKET_INUSE) {
0418         mutex_unlock(&skt->ops_mutex);
0419         return -EINVAL;
0420     }
0421     skt->state |= SOCKET_INUSE;
0422
0423     ret = socket_setup(skt, setup_delay);
0424     if (ret == 0) {
0425         skt->state |= SOCKET_PRESENT;
0426
0427         dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n",
0428                (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA",
0429                skt->sock);
0430
0431 #ifdef CONFIG_CARDBUS
0432         if (skt->state & SOCKET_CARDBUS) {
0433             cb_alloc(skt);
0434             skt->state |= SOCKET_CARDBUS_CONFIG;
0435         }
0436 #endif
0437         dev_dbg(&skt->dev, "insert done\n");
0438         mutex_unlock(&skt->ops_mutex);
0439
0440         if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))
0441             skt->callback->add(skt);
0442     } else {
0443         mutex_unlock(&skt->ops_mutex);
0444         socket_shutdown(skt);
0445     }
0446
0447     return ret;
0448 }
0449
0450 static int socket_suspend(struct pcmcia_socket *skt)
0451 {
0452     if ((skt->state & SOCKET_SUSPEND) && !(skt->state & SOCKET_IN_RESUME))
0453         return -EBUSY;
0454
0455     mutex_lock(&skt->ops_mutex);
0456     /* store state on first suspend, but not after spurious wakeups */
0457     if (!(skt->state & SOCKET_IN_RESUME))
0458         skt->suspended_state = skt->state;
0459
0460     skt->socket = dead_socket;
0461     skt->ops->set_socket(skt, &skt->socket);
0462     if (skt->ops->suspend)
0463         skt->ops->suspend(skt);
0464     skt->state |= SOCKET_SUSPEND;
0465     skt->state &= ~SOCKET_IN_RESUME;
0466     mutex_unlock(&skt->ops_mutex);
0467     return 0;
0468 }
0469
0470 static int socket_early_resume(struct pcmcia_socket *skt)
0471 {
0472     mutex_lock(&skt->ops_mutex);
0473     skt->socket = dead_socket;
0474     skt->ops->init(skt);
0475     skt->ops->set_socket(skt, &skt->socket);
0476     if (skt->state & SOCKET_PRESENT)
0477         skt->resume_status = socket_setup(skt, resume_delay);
0478     skt->state |= SOCKET_IN_RESUME;
0479     mutex_unlock(&skt->ops_mutex);
0480     return 0;
0481 }
0482
0483 static int socket_late_resume(struct pcmcia_socket *skt)
0484 {
0485     int ret = 0;
0486
0487     mutex_lock(&skt->ops_mutex);
0488     skt->state &= ~(SOCKET_SUSPEND | SOCKET_IN_RESUME);
0489     mutex_unlock(&skt->ops_mutex);
0490
0491     if (!(skt->state & SOCKET_PRESENT)) {
0492         ret = socket_insert(skt);
0493         if (ret == -ENODEV)
0494             ret = 0;
0495         return ret;
0496     }
0497
0498     if (skt->resume_status) {
0499         socket_shutdown(skt);
0500         return 0;
0501     }
0502
0503     if (skt->suspended_state != skt->state) {
0504         dev_dbg(&skt->dev,
0505             "suspend state 0x%x != resume state 0x%x\n",
0506             skt->suspended_state, skt->state);
0507
0508         socket_shutdown(skt);
0509         return socket_insert(skt);
0510     }
0511
0512     if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))
0513         ret = skt->callback->early_resume(skt);
0514     return ret;
0515 }
0516
0517 /*
0518  * Finalize the resume. In case of a cardbus socket, we have
0519  * to rebind the devices as we can't be certain that it has been
0520  * replaced, or not.
0521  */
0522 static int socket_complete_resume(struct pcmcia_socket *skt)
0523 {
0524     int ret = 0;
0525 #ifdef CONFIG_CARDBUS
0526     if (skt->state & SOCKET_CARDBUS) {
0527         /* We can't be sure the CardBus card is the same
0528          * as the one previously inserted. Therefore, remove
0529          * and re-add... */
0530         cb_free(skt);
0531         ret = cb_alloc(skt);
0532         if (ret)
0533             cb_free(skt);
0534     }
0535 #endif
0536     return ret;
0537 }
0538
0539 /*
0540  * Resume a socket.  If a card is present, verify its CIS against
0541  * our cached copy.  If they are different, the card has been
0542  * replaced, and we need to tell the drivers.
0543  */
0544 static int socket_resume(struct pcmcia_socket *skt)
0545 {
0546     int err;
0547     if (!(skt->state & SOCKET_SUSPEND))
0548         return -EBUSY;
0549
0550     socket_early_resume(skt);
0551     err = socket_late_resume(skt);
0552     if (!err)
0553         err = socket_complete_resume(skt);
0554     return err;
0555 }
0556
0557 static void socket_remove(struct pcmcia_socket *skt)
0558 {
0559     dev_notice(&skt->dev, "pccard: card ejected from slot %d\n", skt->sock);
0560     socket_shutdown(skt);
0561 }
0562
0563 /*
0564  * Process a socket card detect status change.
0565  *
0566  * If we don't have a card already present, delay the detect event for
0567  * about 20ms (to be on the safe side) before reading the socket status.
0568  *
0569  * Some i82365-based systems send multiple SS_DETECT events during card
0570  * insertion, and the "card present" status bit seems to bounce.  This
0571  * will probably be true with GPIO-based card detection systems after
0572  * the product has aged.
0573  */
0574 static void socket_detect_change(struct pcmcia_socket *skt)
0575 {
0576     if (!(skt->state & SOCKET_SUSPEND)) {
0577         int status;
0578
0579         if (!(skt->state & SOCKET_PRESENT))
0580             msleep(20);
0581
0582         skt->ops->get_status(skt, &status);
0583         if ((skt->state & SOCKET_PRESENT) &&
0584              !(status & SS_DETECT))
0585             socket_remove(skt);
0586         if (!(skt->state & SOCKET_PRESENT) &&
0587             (status & SS_DETECT))
0588             socket_insert(skt);
0589     }
0590 }
0591
0592 static int pccardd(void *__skt)
0593 {
0594     struct pcmcia_socket *skt = __skt;
0595     int ret;
0596
0597     skt->thread = current;
0598     skt->socket = dead_socket;
0599     skt->ops->init(skt);
0600     skt->ops->set_socket(skt, &skt->socket);
0601
0602     /* register with the device core */
0603     ret = device_register(&skt->dev);
0604     if (ret) {
0605         dev_warn(&skt->dev, "PCMCIA: unable to register socket\n");
0606         skt->thread = NULL;
0607         complete(&skt->thread_done);
0608         return 0;
0609     }
0610     ret = pccard_sysfs_add_socket(&skt->dev);
0611     if (ret)
0612         dev_warn(&skt->dev, "err %d adding socket attributes\n", ret);
0613
0614     complete(&skt->thread_done);
0615
0616     /* wait for userspace to catch up */
0617     msleep(250);
0618
0619     set_freezable();
0620     for (;;) {
0621         unsigned long flags;
0622         unsigned int events;
0623         unsigned int sysfs_events;
0624
0625         spin_lock_irqsave(&skt->thread_lock, flags);
0626         events = skt->thread_events;
0627         skt->thread_events = 0;
0628         sysfs_events = skt->sysfs_events;
0629         skt->sysfs_events = 0;
0630         spin_unlock_irqrestore(&skt->thread_lock, flags);
0631
0632         mutex_lock(&skt->skt_mutex);
0633         if (events & SS_DETECT)
0634             socket_detect_change(skt);
0635
0636         if (sysfs_events) {
0637             if (sysfs_events & PCMCIA_UEVENT_EJECT)
0638                 socket_remove(skt);
0639             if (sysfs_events & PCMCIA_UEVENT_INSERT)
0640                 socket_insert(skt);
0641             if ((sysfs_events & PCMCIA_UEVENT_SUSPEND) &&
0642                 !(skt->state & SOCKET_CARDBUS)) {
0643                 if (skt->callback)
0644                     ret = skt->callback->suspend(skt);
0645                 else
0646                     ret = 0;
0647                 if (!ret) {
0648                     socket_suspend(skt);
0649                     msleep(100);
0650                 }
0651             }
0652             if ((sysfs_events & PCMCIA_UEVENT_RESUME) &&
0653                 !(skt->state & SOCKET_CARDBUS)) {
0654                 ret = socket_resume(skt);
0655                 if (!ret && skt->callback)
0656                     skt->callback->resume(skt);
0657             }
0658             if ((sysfs_events & PCMCIA_UEVENT_REQUERY) &&
0659                 !(skt->state & SOCKET_CARDBUS)) {
0660                 if (!ret && skt->callback)
0661                     skt->callback->requery(skt);
0662             }
0663         }
0664         mutex_unlock(&skt->skt_mutex);
0665
0666         if (events || sysfs_events)
0667             continue;
0668
0669         set_current_state(TASK_INTERRUPTIBLE);
0670         if (kthread_should_stop())
0671             break;
0672
0673         schedule();
0674
0675         try_to_freeze();
0676     }
0677     /* make sure we are running before we exit */
0678     __set_current_state(TASK_RUNNING);
0679
0680     /* shut down socket, if a device is still present */
0681     if (skt->state & SOCKET_PRESENT) {
0682         mutex_lock(&skt->skt_mutex);
0683         socket_remove(skt);
0684         mutex_unlock(&skt->skt_mutex);
0685     }
0686
0687     /* remove from the device core */
0688     pccard_sysfs_remove_socket(&skt->dev);
0689     device_unregister(&skt->dev);
0690
0691     return 0;
0692 }
0693
0694 /*
0695  * Yenta (at least) probes interrupts before registering the socket and
0696  * starting the handler thread.
0697  */
0698 void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
0699 {
0700     unsigned long flags;
0701     dev_dbg(&s->dev, "parse_events: events %08x\n", events);
0702     if (s->thread) {
0703         spin_lock_irqsave(&s->thread_lock, flags);
0704         s->thread_events |= events;
0705         spin_unlock_irqrestore(&s->thread_lock, flags);
0706
0707         wake_up_process(s->thread);
0708     }
0709 } /* pcmcia_parse_events */
0710 EXPORT_SYMBOL(pcmcia_parse_events);
0711
0712 /**
0713  * pcmcia_parse_uevents() - tell pccardd to issue manual commands
0714  * @s:      the PCMCIA socket we wan't to command
0715  * @events: events to pass to pccardd
0716  *
0717  * userspace-issued insert, eject, suspend and resume commands must be
0718  * handled by pccardd to avoid any sysfs-related deadlocks. Valid events
0719  * are PCMCIA_UEVENT_EJECT (for eject), PCMCIA_UEVENT__INSERT (for insert),
0720  * PCMCIA_UEVENT_RESUME (for resume), PCMCIA_UEVENT_SUSPEND (for suspend)
0721  * and PCMCIA_UEVENT_REQUERY (for re-querying the PCMCIA card).
0722  */
0723 void pcmcia_parse_uevents(struct pcmcia_socket *s, u_int events)
0724 {
0725     unsigned long flags;
0726     dev_dbg(&s->dev, "parse_uevents: events %08x\n", events);
0727     if (s->thread) {
0728         spin_lock_irqsave(&s->thread_lock, flags);
0729         s->sysfs_events |= events;
0730         spin_unlock_irqrestore(&s->thread_lock, flags);
0731
0732         wake_up_process(s->thread);
0733     }
0734 }
0735 EXPORT_SYMBOL(pcmcia_parse_uevents);
0736
0737
0738 /* register pcmcia_callback */
0739 int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
0740 {
0741     int ret = 0;
0742
0743     /* s->skt_mutex also protects s->callback */
0744     mutex_lock(&s->skt_mutex);
0745
0746     if (c) {
0747         /* registration */
0748         if (s->callback) {
0749             ret = -EBUSY;
0750             goto err;
0751         }
0752
0753         s->callback = c;
0754
0755         if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
0756             s->callback->add(s);
0757     } else
0758         s->callback = NULL;
0759  err:
0760     mutex_unlock(&s->skt_mutex);
0761
0762     return ret;
0763 }
0764 EXPORT_SYMBOL(pccard_register_pcmcia);
0765
0766
0767 /* I'm not sure which "reset" function this is supposed to use,
0768  * but for now, it uses the low-level interface's reset, not the
0769  * CIS register.
0770  */
0771
0772 int pcmcia_reset_card(struct pcmcia_socket *skt)
0773 {
0774     int ret;
0775
0776     dev_dbg(&skt->dev, "resetting socket\n");
0777
0778     mutex_lock(&skt->skt_mutex);
0779     do {
0780         if (!(skt->state & SOCKET_PRESENT)) {
0781             dev_dbg(&skt->dev, "can't reset, not present\n");
0782             ret = -ENODEV;
0783             break;
0784         }
0785         if (skt->state & SOCKET_SUSPEND) {
0786             dev_dbg(&skt->dev, "can't reset, suspended\n");
0787             ret = -EBUSY;
0788             break;
0789         }
0790         if (skt->state & SOCKET_CARDBUS) {
0791             dev_dbg(&skt->dev, "can't reset, is cardbus\n");
0792             ret = -EPERM;
0793             break;
0794         }
0795
0796         if (skt->callback)
0797             skt->callback->suspend(skt);
0798         mutex_lock(&skt->ops_mutex);
0799         ret = socket_reset(skt);
0800         mutex_unlock(&skt->ops_mutex);
0801         if ((ret == 0) && (skt->callback))
0802             skt->callback->resume(skt);
0803
0804         ret = 0;
0805     } while (0);
0806     mutex_unlock(&skt->skt_mutex);
0807
0808     return ret;
0809 } /* reset_card */
0810 EXPORT_SYMBOL(pcmcia_reset_card);
0811
0812
0813 static int pcmcia_socket_uevent(struct device *dev,
0814                 struct kobj_uevent_env *env)
0815 {
0816     struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
0817
0818     if (add_uevent_var(env, "SOCKET_NO=%u", s->sock))
0819         return -ENOMEM;
0820
0821     return 0;
0822 }
0823
0824
0825 static struct completion pcmcia_unload;
0826
0827 static void pcmcia_release_socket_class(struct class *data)
0828 {
0829     complete(&pcmcia_unload);
0830 }
0831
0832
0833 #ifdef CONFIG_PM
0834
0835 static int __pcmcia_pm_op(struct device *dev,
0836               int (*callback) (struct pcmcia_socket *skt))
0837 {
0838     struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
0839     int ret;
0840
0841     mutex_lock(&s->skt_mutex);
0842     ret = callback(s);
0843     mutex_unlock(&s->skt_mutex);
0844
0845     return ret;
0846 }
0847
0848 static int pcmcia_socket_dev_suspend_noirq(struct device *dev)
0849 {
0850     return __pcmcia_pm_op(dev, socket_suspend);
0851 }
0852
0853 static int pcmcia_socket_dev_resume_noirq(struct device *dev)
0854 {
0855     return __pcmcia_pm_op(dev, socket_early_resume);
0856 }
0857
0858 static int __used pcmcia_socket_dev_resume(struct device *dev)
0859 {
0860     return __pcmcia_pm_op(dev, socket_late_resume);
0861 }
0862
0863 static void __used pcmcia_socket_dev_complete(struct device *dev)
0864 {
0865     WARN(__pcmcia_pm_op(dev, socket_complete_resume),
0866         "failed to complete resume");
0867 }
0868
0869 static const struct dev_pm_ops pcmcia_socket_pm_ops = {
0870     /* dev_resume may be called with IRQs enabled */
0871     SET_SYSTEM_SLEEP_PM_OPS(NULL,
0872                 pcmcia_socket_dev_resume)
0873
0874     /* late suspend must be called with IRQs disabled */
0875     .suspend_noirq = pcmcia_socket_dev_suspend_noirq,
0876     .freeze_noirq = pcmcia_socket_dev_suspend_noirq,
0877     .poweroff_noirq = pcmcia_socket_dev_suspend_noirq,
0878
0879     /* early resume must be called with IRQs disabled */
0880     .resume_noirq = pcmcia_socket_dev_resume_noirq,
0881     .thaw_noirq = pcmcia_socket_dev_resume_noirq,
0882     .restore_noirq = pcmcia_socket_dev_resume_noirq,
0883     .complete = pcmcia_socket_dev_complete,
0884 };
0885
0886 #define PCMCIA_SOCKET_CLASS_PM_OPS (&pcmcia_socket_pm_ops)
0887
0888 #else /* CONFIG_PM */
0889
0890 #define PCMCIA_SOCKET_CLASS_PM_OPS NULL
0891
0892 #endif /* CONFIG_PM */
0893
0894 struct class pcmcia_socket_class = {
0895     .name = "pcmcia_socket",
0896     .dev_uevent = pcmcia_socket_uevent,
0897     .dev_release = pcmcia_release_socket,
0898     .class_release = pcmcia_release_socket_class,
0899     .pm = PCMCIA_SOCKET_CLASS_PM_OPS,
0900 };
0901 EXPORT_SYMBOL(pcmcia_socket_class);
0902
0903
0904 static int __init init_pcmcia_cs(void)
0905 {
0906     init_completion(&pcmcia_unload);
0907     return class_register(&pcmcia_socket_class);
0908 }
0909
0910 static void __exit exit_pcmcia_cs(void)
0911 {
0912     class_unregister(&pcmcia_socket_class);
0913     wait_for_completion(&pcmcia_unload);
0914 }
0915
0916 subsys_initcall(init_pcmcia_cs);
0917 module_exit(exit_pcmcia_cs);
0918