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