linux/drivers/pcmcia/soc_common.c
<<
>>
Prefs
   1/*======================================================================
   2
   3    Common support code for the PCMCIA control functionality of
   4    integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
   5
   6    The contents of this file are subject to the Mozilla Public
   7    License Version 1.1 (the "License"); you may not use this file
   8    except in compliance with the License. You may obtain a copy of
   9    the License at http://www.mozilla.org/MPL/
  10
  11    Software distributed under the License is distributed on an "AS
  12    IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  13    implied. See the License for the specific language governing
  14    rights and limitations under the License.
  15
  16    The initial developer of the original code is John G. Dorsey
  17    <john+@cs.cmu.edu>.  Portions created by John G. Dorsey are
  18    Copyright (C) 1999 John G. Dorsey.  All Rights Reserved.
  19
  20    Alternatively, the contents of this file may be used under the
  21    terms of the GNU Public License version 2 (the "GPL"), in which
  22    case the provisions of the GPL are applicable instead of the
  23    above.  If you wish to allow the use of your version of this file
  24    only under the terms of the GPL and not to allow others to use
  25    your version of this file under the MPL, indicate your decision
  26    by deleting the provisions above and replace them with the notice
  27    and other provisions required by the GPL.  If you do not delete
  28    the provisions above, a recipient may use your version of this
  29    file under either the MPL or the GPL.
  30
  31======================================================================*/
  32
  33
  34#include <linux/cpufreq.h>
  35#include <linux/init.h>
  36#include <linux/interrupt.h>
  37#include <linux/io.h>
  38#include <linux/irq.h>
  39#include <linux/kernel.h>
  40#include <linux/mm.h>
  41#include <linux/module.h>
  42#include <linux/moduleparam.h>
  43#include <linux/mutex.h>
  44#include <linux/spinlock.h>
  45#include <linux/timer.h>
  46
  47#include <mach/hardware.h>
  48#include <asm/system.h>
  49
  50#include "soc_common.h"
  51
  52#ifdef CONFIG_PCMCIA_DEBUG
  53
  54static int pc_debug;
  55module_param(pc_debug, int, 0644);
  56
  57void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
  58                      int lvl, const char *fmt, ...)
  59{
  60        struct va_format vaf;
  61        va_list args;
  62        if (pc_debug > lvl) {
  63                va_start(args, fmt);
  64
  65                vaf.fmt = fmt;
  66                vaf.va = &args;
  67
  68                printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf);
  69
  70                va_end(args);
  71        }
  72}
  73EXPORT_SYMBOL(soc_pcmcia_debug);
  74
  75#endif
  76
  77#define to_soc_pcmcia_socket(x) \
  78        container_of(x, struct soc_pcmcia_socket, socket)
  79
  80static unsigned short
  81calc_speed(unsigned short *spds, int num, unsigned short dflt)
  82{
  83        unsigned short speed = 0;
  84        int i;
  85
  86        for (i = 0; i < num; i++)
  87                if (speed < spds[i])
  88                        speed = spds[i];
  89        if (speed == 0)
  90                speed = dflt;
  91
  92        return speed;
  93}
  94
  95void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
  96        struct soc_pcmcia_timing *timing)
  97{
  98        timing->io =
  99                calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
 100        timing->mem =
 101                calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
 102        timing->attr =
 103                calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
 104}
 105EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
 106
 107static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
 108{
 109        struct pcmcia_state state;
 110        unsigned int stat;
 111
 112        memset(&state, 0, sizeof(struct pcmcia_state));
 113
 114        skt->ops->socket_state(skt, &state);
 115
 116        stat = state.detect  ? SS_DETECT : 0;
 117        stat |= state.ready  ? SS_READY  : 0;
 118        stat |= state.wrprot ? SS_WRPROT : 0;
 119        stat |= state.vs_3v  ? SS_3VCARD : 0;
 120        stat |= state.vs_Xv  ? SS_XVCARD : 0;
 121
 122        /* The power status of individual sockets is not available
 123         * explicitly from the hardware, so we just remember the state
 124         * and regurgitate it upon request:
 125         */
 126        stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
 127
 128        if (skt->cs_state.flags & SS_IOCARD)
 129                stat |= state.bvd1 ? SS_STSCHG : 0;
 130        else {
 131                if (state.bvd1 == 0)
 132                        stat |= SS_BATDEAD;
 133                else if (state.bvd2 == 0)
 134                        stat |= SS_BATWARN;
 135        }
 136        return stat;
 137}
 138
 139/*
 140 * soc_common_pcmcia_config_skt
 141 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 142 *
 143 * Convert PCMCIA socket state to our socket configure structure.
 144 */
 145static int soc_common_pcmcia_config_skt(
 146        struct soc_pcmcia_socket *skt, socket_state_t *state)
 147{
 148        int ret;
 149
 150        ret = skt->ops->configure_socket(skt, state);
 151        if (ret == 0) {
 152                /*
 153                 * This really needs a better solution.  The IRQ
 154                 * may or may not be claimed by the driver.
 155                 */
 156                if (skt->irq_state != 1 && state->io_irq) {
 157                        skt->irq_state = 1;
 158                        set_irq_type(skt->socket.pci_irq,
 159                                IRQ_TYPE_EDGE_FALLING);
 160                } else if (skt->irq_state == 1 && state->io_irq == 0) {
 161                        skt->irq_state = 0;
 162                        set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
 163                }
 164
 165                skt->cs_state = *state;
 166        }
 167
 168        if (ret < 0)
 169                printk(KERN_ERR "soc_common_pcmcia: unable to configure "
 170                       "socket %d\n", skt->nr);
 171
 172        return ret;
 173}
 174
 175/* soc_common_pcmcia_sock_init()
 176 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 177 *
 178 * (Re-)Initialise the socket, turning on status interrupts
 179 * and PCMCIA bus.  This must wait for power to stabilise
 180 * so that the card status signals report correctly.
 181 *
 182 * Returns: 0
 183 */
 184static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
 185{
 186        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 187
 188        debug(skt, 2, "initializing socket\n");
 189
 190        skt->ops->socket_init(skt);
 191        return 0;
 192}
 193
 194
 195/*
 196 * soc_common_pcmcia_suspend()
 197 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 198 *
 199 * Remove power on the socket, disable IRQs from the card.
 200 * Turn off status interrupts, and disable the PCMCIA bus.
 201 *
 202 * Returns: 0
 203 */
 204static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
 205{
 206        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 207
 208        debug(skt, 2, "suspending socket\n");
 209
 210        skt->ops->socket_suspend(skt);
 211
 212        return 0;
 213}
 214
 215static DEFINE_SPINLOCK(status_lock);
 216
 217static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 218{
 219        unsigned int events;
 220
 221        debug(skt, 4, "entering PCMCIA monitoring thread\n");
 222
 223        do {
 224                unsigned int status;
 225                unsigned long flags;
 226
 227                status = soc_common_pcmcia_skt_state(skt);
 228
 229                spin_lock_irqsave(&status_lock, flags);
 230                events = (status ^ skt->status) & skt->cs_state.csc_mask;
 231                skt->status = status;
 232                spin_unlock_irqrestore(&status_lock, flags);
 233
 234                debug(skt, 4, "events: %s%s%s%s%s%s\n",
 235                        events == 0         ? "<NONE>"   : "",
 236                        events & SS_DETECT  ? "DETECT "  : "",
 237                        events & SS_READY   ? "READY "   : "",
 238                        events & SS_BATDEAD ? "BATDEAD " : "",
 239                        events & SS_BATWARN ? "BATWARN " : "",
 240                        events & SS_STSCHG  ? "STSCHG "  : "");
 241
 242                if (events)
 243                        pcmcia_parse_events(&skt->socket, events);
 244        } while (events);
 245}
 246
 247/* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 248static void soc_common_pcmcia_poll_event(unsigned long dummy)
 249{
 250        struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
 251        debug(skt, 4, "polling for events\n");
 252
 253        mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 254
 255        soc_common_check_status(skt);
 256}
 257
 258
 259/*
 260 * Service routine for socket driver interrupts (requested by the
 261 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 262 * The actual interrupt-servicing work is performed by
 263 * soc_common_pcmcia_thread(), largely because the Card Services event-
 264 * handling code performs scheduling operations which cannot be
 265 * executed from within an interrupt context.
 266 */
 267static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
 268{
 269        struct soc_pcmcia_socket *skt = dev;
 270
 271        debug(skt, 3, "servicing IRQ %d\n", irq);
 272
 273        soc_common_check_status(skt);
 274
 275        return IRQ_HANDLED;
 276}
 277
 278
 279/*
 280 *  Implements the get_status() operation for the in-kernel PCMCIA
 281 * service (formerly SS_GetStatus in Card Services). Essentially just
 282 * fills in bits in `status' according to internal driver state or
 283 * the value of the voltage detect chipselect register.
 284 *
 285 * As a debugging note, during card startup, the PCMCIA core issues
 286 * three set_socket() commands in a row the first with RESET deasserted,
 287 * the second with RESET asserted, and the last with RESET deasserted
 288 * again. Following the third set_socket(), a get_status() command will
 289 * be issued. The kernel is looking for the SS_READY flag (see
 290 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 291 *
 292 * Returns: 0
 293 */
 294static int
 295soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 296{
 297        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 298
 299        skt->status = soc_common_pcmcia_skt_state(skt);
 300        *status = skt->status;
 301
 302        return 0;
 303}
 304
 305
 306/*
 307 * Implements the set_socket() operation for the in-kernel PCMCIA
 308 * service (formerly SS_SetSocket in Card Services). We more or
 309 * less punt all of this work and let the kernel handle the details
 310 * of power configuration, reset, &c. We also record the value of
 311 * `state' in order to regurgitate it to the PCMCIA core later.
 312 */
 313static int soc_common_pcmcia_set_socket(
 314        struct pcmcia_socket *sock, socket_state_t *state)
 315{
 316        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 317
 318        debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
 319                        (state->csc_mask == 0)          ? "<NONE> " :   "",
 320                        (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
 321                        (state->csc_mask & SS_READY)    ? "READY " :    "",
 322                        (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
 323                        (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
 324                        (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
 325                        (state->flags == 0)             ? "<NONE> " :   "",
 326                        (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
 327                        (state->flags & SS_IOCARD)      ? "IOCARD " :   "",
 328                        (state->flags & SS_RESET)       ? "RESET " :    "",
 329                        (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
 330                        (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
 331                        state->Vcc, state->Vpp, state->io_irq);
 332
 333        return soc_common_pcmcia_config_skt(skt, state);
 334}
 335
 336
 337/*
 338 * Implements the set_io_map() operation for the in-kernel PCMCIA
 339 * service (formerly SS_SetIOMap in Card Services). We configure
 340 * the map speed as requested, but override the address ranges
 341 * supplied by Card Services.
 342 *
 343 * Returns: 0 on success, -1 on error
 344 */
 345static int soc_common_pcmcia_set_io_map(
 346        struct pcmcia_socket *sock, struct pccard_io_map *map)
 347{
 348        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 349        unsigned short speed = map->speed;
 350
 351        debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
 352                map->map, map->speed, (unsigned long long)map->start,
 353                (unsigned long long)map->stop);
 354        debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 355                (map->flags == 0)               ? "<NONE>"      : "",
 356                (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 357                (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 358                (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 359                (map->flags & MAP_0WS)          ? "0WS "        : "",
 360                (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 361                (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "",
 362                (map->flags & MAP_PREFETCH)     ? "PREFETCH "   : "");
 363
 364        if (map->map >= MAX_IO_WIN) {
 365                printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
 366                       map->map);
 367                return -1;
 368        }
 369
 370        if (map->flags & MAP_ACTIVE) {
 371                if (speed == 0)
 372                        speed = SOC_PCMCIA_IO_ACCESS;
 373        } else {
 374                speed = 0;
 375        }
 376
 377        skt->spd_io[map->map] = speed;
 378        skt->ops->set_timing(skt);
 379
 380        if (map->stop == 1)
 381                map->stop = PAGE_SIZE-1;
 382
 383        map->stop -= map->start;
 384        map->stop += skt->socket.io_offset;
 385        map->start = skt->socket.io_offset;
 386
 387        return 0;
 388}
 389
 390
 391/*
 392 * Implements the set_mem_map() operation for the in-kernel PCMCIA
 393 * service (formerly SS_SetMemMap in Card Services). We configure
 394 * the map speed as requested, but override the address ranges
 395 * supplied by Card Services.
 396 *
 397 * Returns: 0 on success, -ERRNO on error
 398 */
 399static int soc_common_pcmcia_set_mem_map(
 400        struct pcmcia_socket *sock, struct pccard_mem_map *map)
 401{
 402        struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 403        struct resource *res;
 404        unsigned short speed = map->speed;
 405
 406        debug(skt, 2, "map %u speed %u card_start %08x\n",
 407                map->map, map->speed, map->card_start);
 408        debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 409                (map->flags == 0)               ? "<NONE>"      : "",
 410                (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 411                (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 412                (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 413                (map->flags & MAP_0WS)          ? "0WS "        : "",
 414                (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 415                (map->flags & MAP_ATTRIB)       ? "ATTRIB "     : "",
 416                (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "");
 417
 418        if (map->map >= MAX_WIN)
 419                return -EINVAL;
 420
 421        if (map->flags & MAP_ACTIVE) {
 422                if (speed == 0)
 423                        speed = 300;
 424        } else {
 425                speed = 0;
 426        }
 427
 428        if (map->flags & MAP_ATTRIB) {
 429                res = &skt->res_attr;
 430                skt->spd_attr[map->map] = speed;
 431                skt->spd_mem[map->map] = 0;
 432        } else {
 433                res = &skt->res_mem;
 434                skt->spd_attr[map->map] = 0;
 435                skt->spd_mem[map->map] = speed;
 436        }
 437
 438        skt->ops->set_timing(skt);
 439
 440        map->static_start = res->start + map->card_start;
 441
 442        return 0;
 443}
 444
 445struct bittbl {
 446        unsigned int mask;
 447        const char *name;
 448};
 449
 450static struct bittbl status_bits[] = {
 451        { SS_WRPROT,            "SS_WRPROT"     },
 452        { SS_BATDEAD,           "SS_BATDEAD"    },
 453        { SS_BATWARN,           "SS_BATWARN"    },
 454        { SS_READY,             "SS_READY"      },
 455        { SS_DETECT,            "SS_DETECT"     },
 456        { SS_POWERON,           "SS_POWERON"    },
 457        { SS_STSCHG,            "SS_STSCHG"     },
 458        { SS_3VCARD,            "SS_3VCARD"     },
 459        { SS_XVCARD,            "SS_XVCARD"     },
 460};
 461
 462static struct bittbl conf_bits[] = {
 463        { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 464        { SS_IOCARD,            "SS_IOCARD"     },
 465        { SS_RESET,             "SS_RESET"      },
 466        { SS_DMA_MODE,          "SS_DMA_MODE"   },
 467        { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 468        { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 469};
 470
 471static void dump_bits(char **p, const char *prefix,
 472        unsigned int val, struct bittbl *bits, int sz)
 473{
 474        char *b = *p;
 475        int i;
 476
 477        b += sprintf(b, "%-9s:", prefix);
 478        for (i = 0; i < sz; i++)
 479                if (val & bits[i].mask)
 480                        b += sprintf(b, " %s", bits[i].name);
 481        *b++ = '\n';
 482        *p = b;
 483}
 484
 485/*
 486 * Implements the /sys/class/pcmcia_socket/??/status file.
 487 *
 488 * Returns: the number of characters added to the buffer
 489 */
 490static ssize_t show_status(
 491        struct device *dev, struct device_attribute *attr, char *buf)
 492{
 493        struct soc_pcmcia_socket *skt =
 494                container_of(dev, struct soc_pcmcia_socket, socket.dev);
 495        char *p = buf;
 496
 497        p += sprintf(p, "slot     : %d\n", skt->nr);
 498
 499        dump_bits(&p, "status", skt->status,
 500                  status_bits, ARRAY_SIZE(status_bits));
 501        dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 502                  status_bits, ARRAY_SIZE(status_bits));
 503        dump_bits(&p, "cs_flags", skt->cs_state.flags,
 504                  conf_bits, ARRAY_SIZE(conf_bits));
 505
 506        p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 507        p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 508        p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
 509                skt->socket.pci_irq);
 510        if (skt->ops->show_timing)
 511                p += skt->ops->show_timing(skt, p);
 512
 513        return p-buf;
 514}
 515static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 516
 517
 518static struct pccard_operations soc_common_pcmcia_operations = {
 519        .init                   = soc_common_pcmcia_sock_init,
 520        .suspend                = soc_common_pcmcia_suspend,
 521        .get_status             = soc_common_pcmcia_get_status,
 522        .set_socket             = soc_common_pcmcia_set_socket,
 523        .set_io_map             = soc_common_pcmcia_set_io_map,
 524        .set_mem_map            = soc_common_pcmcia_set_mem_map,
 525};
 526
 527
 528int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
 529                            struct pcmcia_irqs *irqs, int nr)
 530{
 531        int i, res = 0;
 532
 533        for (i = 0; i < nr; i++) {
 534                if (irqs[i].sock != skt->nr)
 535                        continue;
 536                res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
 537                                  IRQF_DISABLED, irqs[i].str, skt);
 538                if (res)
 539                        break;
 540                set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
 541        }
 542
 543        if (res) {
 544                printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
 545                        irqs[i].irq, res);
 546
 547                while (i--)
 548                        if (irqs[i].sock == skt->nr)
 549                                free_irq(irqs[i].irq, skt);
 550        }
 551        return res;
 552}
 553EXPORT_SYMBOL(soc_pcmcia_request_irqs);
 554
 555void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
 556                          struct pcmcia_irqs *irqs, int nr)
 557{
 558        int i;
 559
 560        for (i = 0; i < nr; i++)
 561                if (irqs[i].sock == skt->nr)
 562                        free_irq(irqs[i].irq, skt);
 563}
 564EXPORT_SYMBOL(soc_pcmcia_free_irqs);
 565
 566void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
 567                             struct pcmcia_irqs *irqs, int nr)
 568{
 569        int i;
 570
 571        for (i = 0; i < nr; i++)
 572                if (irqs[i].sock == skt->nr)
 573                        set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
 574}
 575EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
 576
 577void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
 578                            struct pcmcia_irqs *irqs, int nr)
 579{
 580        int i;
 581
 582        for (i = 0; i < nr; i++)
 583                if (irqs[i].sock == skt->nr) {
 584                        set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
 585                        set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
 586                }
 587}
 588EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
 589
 590
 591static LIST_HEAD(soc_pcmcia_sockets);
 592static DEFINE_MUTEX(soc_pcmcia_sockets_lock);
 593
 594#ifdef CONFIG_CPU_FREQ
 595static int
 596soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
 597{
 598        struct soc_pcmcia_socket *skt;
 599        struct cpufreq_freqs *freqs = data;
 600        int ret = 0;
 601
 602        mutex_lock(&soc_pcmcia_sockets_lock);
 603        list_for_each_entry(skt, &soc_pcmcia_sockets, node)
 604                if (skt->ops->frequency_change)
 605                        ret += skt->ops->frequency_change(skt, val, freqs);
 606        mutex_unlock(&soc_pcmcia_sockets_lock);
 607
 608        return ret;
 609}
 610
 611static struct notifier_block soc_pcmcia_notifier_block = {
 612        .notifier_call  = soc_pcmcia_notifier
 613};
 614
 615static int soc_pcmcia_cpufreq_register(void)
 616{
 617        int ret;
 618
 619        ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
 620                                        CPUFREQ_TRANSITION_NOTIFIER);
 621        if (ret < 0)
 622                printk(KERN_ERR "Unable to register CPU frequency change "
 623                                "notifier for PCMCIA (%d)\n", ret);
 624        return ret;
 625}
 626fs_initcall(soc_pcmcia_cpufreq_register);
 627
 628static void soc_pcmcia_cpufreq_unregister(void)
 629{
 630        cpufreq_unregister_notifier(&soc_pcmcia_notifier_block,
 631                CPUFREQ_TRANSITION_NOTIFIER);
 632}
 633module_exit(soc_pcmcia_cpufreq_unregister);
 634
 635#endif
 636
 637void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
 638{
 639        mutex_lock(&soc_pcmcia_sockets_lock);
 640        del_timer_sync(&skt->poll_timer);
 641
 642        pcmcia_unregister_socket(&skt->socket);
 643
 644        skt->ops->hw_shutdown(skt);
 645
 646        soc_common_pcmcia_config_skt(skt, &dead_socket);
 647
 648        list_del(&skt->node);
 649        mutex_unlock(&soc_pcmcia_sockets_lock);
 650
 651        iounmap(skt->virt_io);
 652        skt->virt_io = NULL;
 653        release_resource(&skt->res_attr);
 654        release_resource(&skt->res_mem);
 655        release_resource(&skt->res_io);
 656        release_resource(&skt->res_skt);
 657}
 658EXPORT_SYMBOL(soc_pcmcia_remove_one);
 659
 660int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
 661{
 662        int ret;
 663
 664        init_timer(&skt->poll_timer);
 665        skt->poll_timer.function = soc_common_pcmcia_poll_event;
 666        skt->poll_timer.data = (unsigned long)skt;
 667        skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 668
 669        ret = request_resource(&iomem_resource, &skt->res_skt);
 670        if (ret)
 671                goto out_err_1;
 672
 673        ret = request_resource(&skt->res_skt, &skt->res_io);
 674        if (ret)
 675                goto out_err_2;
 676
 677        ret = request_resource(&skt->res_skt, &skt->res_mem);
 678        if (ret)
 679                goto out_err_3;
 680
 681        ret = request_resource(&skt->res_skt, &skt->res_attr);
 682        if (ret)
 683                goto out_err_4;
 684
 685        skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 686        if (skt->virt_io == NULL) {
 687                ret = -ENOMEM;
 688                goto out_err_5;
 689        }
 690
 691        mutex_lock(&soc_pcmcia_sockets_lock);
 692
 693        list_add(&skt->node, &soc_pcmcia_sockets);
 694
 695        /*
 696         * We initialize default socket timing here, because
 697         * we are not guaranteed to see a SetIOMap operation at
 698         * runtime.
 699         */
 700        skt->ops->set_timing(skt);
 701
 702        ret = skt->ops->hw_init(skt);
 703        if (ret)
 704                goto out_err_6;
 705
 706        skt->socket.ops = &soc_common_pcmcia_operations;
 707        skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 708        skt->socket.resource_ops = &pccard_static_ops;
 709        skt->socket.irq_mask = 0;
 710        skt->socket.map_size = PAGE_SIZE;
 711        skt->socket.io_offset = (unsigned long)skt->virt_io;
 712
 713        skt->status = soc_common_pcmcia_skt_state(skt);
 714
 715        ret = pcmcia_register_socket(&skt->socket);
 716        if (ret)
 717                goto out_err_7;
 718
 719        add_timer(&skt->poll_timer);
 720
 721        mutex_unlock(&soc_pcmcia_sockets_lock);
 722
 723        ret = device_create_file(&skt->socket.dev, &dev_attr_status);
 724        if (ret)
 725                goto out_err_8;
 726
 727        return ret;
 728
 729 out_err_8:
 730        mutex_lock(&soc_pcmcia_sockets_lock);
 731        del_timer_sync(&skt->poll_timer);
 732        pcmcia_unregister_socket(&skt->socket);
 733
 734 out_err_7:
 735        skt->ops->hw_shutdown(skt);
 736 out_err_6:
 737        list_del(&skt->node);
 738        mutex_unlock(&soc_pcmcia_sockets_lock);
 739        iounmap(skt->virt_io);
 740 out_err_5:
 741        release_resource(&skt->res_attr);
 742 out_err_4:
 743        release_resource(&skt->res_mem);
 744 out_err_3:
 745        release_resource(&skt->res_io);
 746 out_err_2:
 747        release_resource(&skt->res_skt);
 748 out_err_1:
 749
 750        return ret;
 751}
 752EXPORT_SYMBOL(soc_pcmcia_add_one);
 753
 754MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
 755MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
 756MODULE_LICENSE("Dual MPL/GPL");
 757