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                 int values[2], n = 0;
 355
 356                 if (skt->gpio_reset) {
 357                         descs[n] = skt->gpio_reset;
 358                         values[n++] = !!(state->flags & SS_RESET);
 359                 }
 360                 if (skt->gpio_bus_enable) {
 361                         descs[n] = skt->gpio_bus_enable;
 362                         values[n++] = !!(state->flags & SS_OUTPUT_ENA);
 363                 }
 364
 365                 if (n)
 366                         gpiod_set_array_value_cansleep(n, descs, values);
 367
 368                 /*
 369                  * This really needs a better solution.  The IRQ
 370                  * may or may not be claimed by the driver.
 371                  */
 372                 if (skt->irq_state != 1 && state->io_irq) {
 373                         skt->irq_state = 1;
 374                         irq_set_irq_type(skt->socket.pci_irq,
 375                                          IRQ_TYPE_EDGE_FALLING);
 376                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
 377                         skt->irq_state = 0;
 378                         irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
 379                 }
 380
 381                 skt->cs_state = *state;
 382         }
 383
 384         return ret;
 385 }
 386
 387 /* soc_common_pcmcia_sock_init()
 388  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 389  *
 390  * (Re-)Initialise the socket, turning on status interrupts
 391  * and PCMCIA bus.  This must wait for power to stabilise
 392  * so that the card status signals report correctly.
 393  *
 394  * Returns: 0
 395  */
 396 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
 397 {
 398         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 399
 400         debug(skt, 2, "initializing socket\n");
 401         if (skt->ops->socket_init)
 402                 skt->ops->socket_init(skt);
 403         soc_pcmcia_hw_enable(skt);
 404         return 0;
 405 }
 406
 407
 408 /*
 409  * soc_common_pcmcia_suspend()
 410  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 411  *
 412  * Remove power on the socket, disable IRQs from the card.
 413  * Turn off status interrupts, and disable the PCMCIA bus.
 414  *
 415  * Returns: 0
 416  */
 417 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
 418 {
 419         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 420
 421         debug(skt, 2, "suspending socket\n");
 422
 423         soc_pcmcia_hw_disable(skt);
 424         if (skt->ops->socket_suspend)
 425                 skt->ops->socket_suspend(skt);
 426
 427         return 0;
 428 }
 429
 430 static DEFINE_SPINLOCK(status_lock);
 431
 432 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 433 {
 434         unsigned int events;
 435
 436         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 437
 438         do {
 439                 unsigned int status;
 440                 unsigned long flags;
 441
 442                 status = soc_common_pcmcia_skt_state(skt);
 443
 444                 spin_lock_irqsave(&status_lock, flags);
 445                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 446                 skt->status = status;
 447                 spin_unlock_irqrestore(&status_lock, flags);
 448
 449                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 450                         events == 0         ? "<NONE>"   : "",
 451                         events & SS_DETECT  ? "DETECT "  : "",
 452                         events & SS_READY   ? "READY "   : "",
 453                         events & SS_BATDEAD ? "BATDEAD " : "",
 454                         events & SS_BATWARN ? "BATWARN " : "",
 455                         events & SS_STSCHG  ? "STSCHG "  : "");
 456
 457                 if (events)
 458                         pcmcia_parse_events(&skt->socket, events);
 459         } while (events);
 460 }
 461
 462 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 463 static void soc_common_pcmcia_poll_event(struct timer_list *t)
 464 {
 465         struct soc_pcmcia_socket *skt = from_timer(skt, t, poll_timer);
 466         debug(skt, 4, "polling for events\n");
 467
 468         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 469
 470         soc_common_check_status(skt);
 471 }
 472
 473
 474 /*
 475  * Service routine for socket driver interrupts (requested by the
 476  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 477  * The actual interrupt-servicing work is performed by
 478  * soc_common_pcmcia_thread(), largely because the Card Services event-
 479  * handling code performs scheduling operations which cannot be
 480  * executed from within an interrupt context.
 481  */
 482 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
 483 {
 484         struct soc_pcmcia_socket *skt = dev;
 485
 486         debug(skt, 3, "servicing IRQ %d\n", irq);
 487
 488         soc_common_check_status(skt);
 489
 490         return IRQ_HANDLED;
 491 }
 492
 493
 494 /*
 495  *  Implements the get_status() operation for the in-kernel PCMCIA
 496  * service (formerly SS_GetStatus in Card Services). Essentially just
 497  * fills in bits in `status' according to internal driver state or
 498  * the value of the voltage detect chipselect register.
 499  *
 500  * As a debugging note, during card startup, the PCMCIA core issues
 501  * three set_socket() commands in a row the first with RESET deasserted,
 502  * the second with RESET asserted, and the last with RESET deasserted
 503  * again. Following the third set_socket(), a get_status() command will
 504  * be issued. The kernel is looking for the SS_READY flag (see
 505  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 506  *
 507  * Returns: 0
 508  */
 509 static int
 510 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 511 {
 512         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 513
 514         skt->status = soc_common_pcmcia_skt_state(skt);
 515         *status = skt->status;
 516
 517         return 0;
 518 }
 519
 520
 521 /*
 522  * Implements the set_socket() operation for the in-kernel PCMCIA
 523  * service (formerly SS_SetSocket in Card Services). We more or
 524  * less punt all of this work and let the kernel handle the details
 525  * of power configuration, reset, &c. We also record the value of
 526  * `state' in order to regurgitate it to the PCMCIA core later.
 527  */
 528 static int soc_common_pcmcia_set_socket(
 529         struct pcmcia_socket *sock, socket_state_t *state)
 530 {
 531         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 532
 533         debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
 534                         (state->csc_mask == 0)          ? "<NONE> " :   "",
 535                         (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
 536                         (state->csc_mask & SS_READY)    ? "READY " :    "",
 537                         (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
 538                         (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
 539                         (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
 540                         (state->flags == 0)             ? "<NONE> " :   "",
 541                         (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
 542                         (state->flags & SS_IOCARD)      ? "IOCARD " :   "",
 543                         (state->flags & SS_RESET)       ? "RESET " :    "",
 544                         (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
 545                         (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
 546                         state->Vcc, state->Vpp, state->io_irq);
 547
 548         return soc_common_pcmcia_config_skt(skt, state);
 549 }
 550
 551
 552 /*
 553  * Implements the set_io_map() operation for the in-kernel PCMCIA
 554  * service (formerly SS_SetIOMap in Card Services). We configure
 555  * the map speed as requested, but override the address ranges
 556  * supplied by Card Services.
 557  *
 558  * Returns: 0 on success, -1 on error
 559  */
 560 static int soc_common_pcmcia_set_io_map(
 561         struct pcmcia_socket *sock, struct pccard_io_map *map)
 562 {
 563         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 564         unsigned short speed = map->speed;
 565
 566         debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
 567                 map->map, map->speed, (unsigned long long)map->start,
 568                 (unsigned long long)map->stop);
 569         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 570                 (map->flags == 0)               ? "<NONE>"      : "",
 571                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 572                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 573                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 574                 (map->flags & MAP_0WS)          ? "0WS "        : "",
 575                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 576                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "",
 577                 (map->flags & MAP_PREFETCH)     ? "PREFETCH "   : "");
 578
 579         if (map->map >= MAX_IO_WIN) {
 580                 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
 581                        map->map);
 582                 return -1;
 583         }
 584
 585         if (map->flags & MAP_ACTIVE) {
 586                 if (speed == 0)
 587                         speed = SOC_PCMCIA_IO_ACCESS;
 588         } else {
 589                 speed = 0;
 590         }
 591
 592         skt->spd_io[map->map] = speed;
 593         skt->ops->set_timing(skt);
 594
 595         if (map->stop == 1)
 596                 map->stop = PAGE_SIZE-1;
 597
 598         map->stop -= map->start;
 599         map->stop += skt->socket.io_offset;
 600         map->start = skt->socket.io_offset;
 601
 602         return 0;
 603 }
 604
 605
 606 /*
 607  * Implements the set_mem_map() operation for the in-kernel PCMCIA
 608  * service (formerly SS_SetMemMap in Card Services). We configure
 609  * the map speed as requested, but override the address ranges
 610  * supplied by Card Services.
 611  *
 612  * Returns: 0 on success, -ERRNO on error
 613  */
 614 static int soc_common_pcmcia_set_mem_map(
 615         struct pcmcia_socket *sock, struct pccard_mem_map *map)
 616 {
 617         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 618         struct resource *res;
 619         unsigned short speed = map->speed;
 620
 621         debug(skt, 2, "map %u speed %u card_start %08x\n",
 622                 map->map, map->speed, map->card_start);
 623         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 624                 (map->flags == 0)               ? "<NONE>"      : "",
 625                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 626                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 627                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 628                 (map->flags & MAP_0WS)          ? "0WS "        : "",
 629                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 630                 (map->flags & MAP_ATTRIB)       ? "ATTRIB "     : "",
 631                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "");
 632
 633         if (map->map >= MAX_WIN)
 634                 return -EINVAL;
 635
 636         if (map->flags & MAP_ACTIVE) {
 637                 if (speed == 0)
 638                         speed = 300;
 639         } else {
 640                 speed = 0;
 641         }
 642
 643         if (map->flags & MAP_ATTRIB) {
 644                 res = &skt->res_attr;
 645                 skt->spd_attr[map->map] = speed;
 646                 skt->spd_mem[map->map] = 0;
 647         } else {
 648                 res = &skt->res_mem;
 649                 skt->spd_attr[map->map] = 0;
 650                 skt->spd_mem[map->map] = speed;
 651         }
 652
 653         skt->ops->set_timing(skt);
 654
 655         map->static_start = res->start + map->card_start;
 656
 657         return 0;
 658 }
 659
 660 struct bittbl {
 661         unsigned int mask;
 662         const char *name;
 663 };
 664
 665 static struct bittbl status_bits[] = {
 666         { SS_WRPROT,            "SS_WRPROT"     },
 667         { SS_BATDEAD,           "SS_BATDEAD"    },
 668         { SS_BATWARN,           "SS_BATWARN"    },
 669         { SS_READY,             "SS_READY"      },
 670         { SS_DETECT,            "SS_DETECT"     },
 671         { SS_POWERON,           "SS_POWERON"    },
 672         { SS_STSCHG,            "SS_STSCHG"     },
 673         { SS_3VCARD,            "SS_3VCARD"     },
 674         { SS_XVCARD,            "SS_XVCARD"     },
 675 };
 676
 677 static struct bittbl conf_bits[] = {
 678         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 679         { SS_IOCARD,            "SS_IOCARD"     },
 680         { SS_RESET,             "SS_RESET"      },
 681         { SS_DMA_MODE,          "SS_DMA_MODE"   },
 682         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 683         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 684 };
 685
 686 static void dump_bits(char **p, const char *prefix,
 687         unsigned int val, struct bittbl *bits, int sz)
 688 {
 689         char *b = *p;
 690         int i;
 691
 692         b += sprintf(b, "%-9s:", prefix);
 693         for (i = 0; i < sz; i++)
 694                 if (val & bits[i].mask)
 695                         b += sprintf(b, " %s", bits[i].name);
 696         *b++ = '\n';
 697         *p = b;
 698 }
 699
 700 /*
 701  * Implements the /sys/class/pcmcia_socket/??/status file.
 702  *
 703  * Returns: the number of characters added to the buffer
 704  */
 705 static ssize_t show_status(
 706         struct device *dev, struct device_attribute *attr, char *buf)
 707 {
 708         struct soc_pcmcia_socket *skt =
 709                 container_of(dev, struct soc_pcmcia_socket, socket.dev);
 710         char *p = buf;
 711
 712         p += sprintf(p, "slot     : %d\n", skt->nr);
 713
 714         dump_bits(&p, "status", skt->status,
 715                   status_bits, ARRAY_SIZE(status_bits));
 716         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 717                   status_bits, ARRAY_SIZE(status_bits));
 718         dump_bits(&p, "cs_flags", skt->cs_state.flags,
 719                   conf_bits, ARRAY_SIZE(conf_bits));
 720
 721         p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 722         p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 723         p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
 724                 skt->socket.pci_irq);
 725         if (skt->ops->show_timing)
 726                 p += skt->ops->show_timing(skt, p);
 727
 728         return p-buf;
 729 }
 730 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 731
 732
 733 static struct pccard_operations soc_common_pcmcia_operations = {
 734         .init                   = soc_common_pcmcia_sock_init,
 735         .suspend                = soc_common_pcmcia_suspend,
 736         .get_status             = soc_common_pcmcia_get_status,
 737         .set_socket             = soc_common_pcmcia_set_socket,
 738         .set_io_map             = soc_common_pcmcia_set_io_map,
 739         .set_mem_map            = soc_common_pcmcia_set_mem_map,
 740 };
 741
 742
 743 #ifdef CONFIG_CPU_FREQ
 744 static int soc_common_pcmcia_cpufreq_nb(struct notifier_block *nb,
 745         unsigned long val, void *data)
 746 {
 747         struct soc_pcmcia_socket *skt = container_of(nb, struct soc_pcmcia_socket, cpufreq_nb);
 748         struct cpufreq_freqs *freqs = data;
 749
 750         return skt->ops->frequency_change(skt, val, freqs);
 751 }
 752 #endif
 753
 754 void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt,
 755         const struct pcmcia_low_level *ops, struct device *dev)
 756 {
 757         int i;
 758
 759         skt->ops = ops;
 760         skt->socket.owner = ops->owner;
 761         skt->socket.dev.parent = dev;
 762         skt->socket.pci_irq = NO_IRQ;
 763
 764         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
 765                 skt->stat[i].gpio = -EINVAL;
 766 }
 767 EXPORT_SYMBOL(soc_pcmcia_init_one);
 768
 769 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
 770 {
 771         del_timer_sync(&skt->poll_timer);
 772
 773         pcmcia_unregister_socket(&skt->socket);
 774
 775 #ifdef CONFIG_CPU_FREQ
 776         if (skt->ops->frequency_change)
 777                 cpufreq_unregister_notifier(&skt->cpufreq_nb,
 778                                             CPUFREQ_TRANSITION_NOTIFIER);
 779 #endif
 780
 781         soc_pcmcia_hw_shutdown(skt);
 782
 783         /* should not be required; violates some lowlevel drivers */
 784         soc_common_pcmcia_config_skt(skt, &dead_socket);
 785
 786         iounmap(skt->virt_io);
 787         skt->virt_io = NULL;
 788         release_resource(&skt->res_attr);
 789         release_resource(&skt->res_mem);
 790         release_resource(&skt->res_io);
 791         release_resource(&skt->res_skt);
 792 }
 793 EXPORT_SYMBOL(soc_pcmcia_remove_one);
 794
 795 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
 796 {
 797         int ret;
 798
 799         skt->cs_state = dead_socket;
 800
 801         timer_setup(&skt->poll_timer, soc_common_pcmcia_poll_event, 0);
 802         skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 803
 804         ret = request_resource(&iomem_resource, &skt->res_skt);
 805         if (ret)
 806                 goto out_err_1;
 807
 808         ret = request_resource(&skt->res_skt, &skt->res_io);
 809         if (ret)
 810                 goto out_err_2;
 811
 812         ret = request_resource(&skt->res_skt, &skt->res_mem);
 813         if (ret)
 814                 goto out_err_3;
 815
 816         ret = request_resource(&skt->res_skt, &skt->res_attr);
 817         if (ret)
 818                 goto out_err_4;
 819
 820         skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 821         if (skt->virt_io == NULL) {
 822                 ret = -ENOMEM;
 823                 goto out_err_5;
 824         }
 825
 826         /*
 827          * We initialize default socket timing here, because
 828          * we are not guaranteed to see a SetIOMap operation at
 829          * runtime.
 830          */
 831         skt->ops->set_timing(skt);
 832
 833         ret = soc_pcmcia_hw_init(skt);
 834         if (ret)
 835                 goto out_err_6;
 836
 837         skt->socket.ops = &soc_common_pcmcia_operations;
 838         skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 839         skt->socket.resource_ops = &pccard_static_ops;
 840         skt->socket.irq_mask = 0;
 841         skt->socket.map_size = PAGE_SIZE;
 842         skt->socket.io_offset = (unsigned long)skt->virt_io;
 843
 844         skt->status = soc_common_pcmcia_skt_state(skt);
 845
 846 #ifdef CONFIG_CPU_FREQ
 847         if (skt->ops->frequency_change) {
 848                 skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb;
 849
 850                 ret = cpufreq_register_notifier(&skt->cpufreq_nb,
 851                                                 CPUFREQ_TRANSITION_NOTIFIER);
 852                 if (ret < 0)
 853                         dev_err(skt->socket.dev.parent,
 854                                 "unable to register CPU frequency change notifier for PCMCIA (%d)\n",
 855                                 ret);
 856         }
 857 #endif
 858
 859         ret = pcmcia_register_socket(&skt->socket);
 860         if (ret)
 861                 goto out_err_7;
 862
 863         ret = device_create_file(&skt->socket.dev, &dev_attr_status);
 864         if (ret)
 865                 goto out_err_8;
 866
 867         return ret;
 868
 869  out_err_8:
 870         del_timer_sync(&skt->poll_timer);
 871         pcmcia_unregister_socket(&skt->socket);
 872
 873  out_err_7:
 874         soc_pcmcia_hw_shutdown(skt);
 875  out_err_6:
 876         iounmap(skt->virt_io);
 877  out_err_5:
 878         release_resource(&skt->res_attr);
 879  out_err_4:
 880         release_resource(&skt->res_mem);
 881  out_err_3:
 882         release_resource(&skt->res_io);
 883  out_err_2:
 884         release_resource(&skt->res_skt);
 885  out_err_1:
 886
 887         return ret;
 888 }
 889 EXPORT_SYMBOL(soc_pcmcia_add_one);
 890
 891 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
 892 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
 893 MODULE_LICENSE("Dual MPL/GPL");