drivers/pcmcia/soc_common.c

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