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