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