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