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 #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                         unsigned long flags = GPIOF_IN;
 208
 209                         /* CD is active low by default */
 210                         if (i == SOC_STAT_CD)
 211                                 flags |= GPIOF_ACTIVE_LOW;
 212
 213                         ret = devm_gpio_request_one(skt->socket.dev.parent,
 214                                                     skt->stat[i].gpio, flags,
 215                                                     skt->stat[i].name);
 216                         if (ret) {
 217                                 __soc_pcmcia_hw_shutdown(skt, i);
 218                                 return ret;
 219                         }
 220
 221                         skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio);
 222                 }
 223
 224                 if (i < SOC_STAT_VS1 && skt->stat[i].desc) {
 225                         int irq = gpiod_to_irq(skt->stat[i].desc);
 226
 227                         if (irq > 0) {
 228                                 if (i == SOC_STAT_RDY)
 229                                         skt->socket.pci_irq = irq;
 230                                 else
 231                                         skt->stat[i].irq = irq;
 232                         }
 233                 }
 234
 235                 if (skt->stat[i].irq) {
 236                         ret = request_irq(skt->stat[i].irq,
 237                                           soc_common_pcmcia_interrupt,
 238                                           IRQF_TRIGGER_NONE,
 239                                           skt->stat[i].name, skt);
 240                         if (ret) {
 241                                 __soc_pcmcia_hw_shutdown(skt, i);
 242                                 return ret;
 243                         }
 244                 }
 245         }
 246
 247         return ret;
 248 }
 249
 250 static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt)
 251 {
 252         int i;
 253
 254         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
 255                 if (skt->stat[i].irq) {
 256                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING);
 257                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH);
 258                 }
 259 }
 260
 261 static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt)
 262 {
 263         int i;
 264
 265         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
 266                 if (skt->stat[i].irq)
 267                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE);
 268 }
 269
 270 /*
 271  * The CF 3.0 specification says that cards tie VS1 to ground and leave
 272  * VS2 open.  Many implementations do not wire up the VS signals, so we
 273  * provide hard-coded values as per the CF 3.0 spec.
 274  */
 275 void soc_common_cf_socket_state(struct soc_pcmcia_socket *skt,
 276         struct pcmcia_state *state)
 277 {
 278         state->vs_3v = 1;
 279 }
 280 EXPORT_SYMBOL_GPL(soc_common_cf_socket_state);
 281
 282 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
 283 {
 284         struct pcmcia_state state;
 285         unsigned int stat;
 286
 287         memset(&state, 0, sizeof(struct pcmcia_state));
 288
 289         /* Make battery voltage state report 'good' */
 290         state.bvd1 = 1;
 291         state.bvd2 = 1;
 292
 293         if (skt->stat[SOC_STAT_CD].desc)
 294                 state.detect = !!gpiod_get_value(skt->stat[SOC_STAT_CD].desc);
 295         if (skt->stat[SOC_STAT_RDY].desc)
 296                 state.ready = !!gpiod_get_value(skt->stat[SOC_STAT_RDY].desc);
 297         if (skt->stat[SOC_STAT_BVD1].desc)
 298                 state.bvd1 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD1].desc);
 299         if (skt->stat[SOC_STAT_BVD2].desc)
 300                 state.bvd2 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD2].desc);
 301         if (skt->stat[SOC_STAT_VS1].desc)
 302                 state.vs_3v = !!gpiod_get_value(skt->stat[SOC_STAT_VS1].desc);
 303         if (skt->stat[SOC_STAT_VS2].desc)
 304                 state.vs_Xv = !!gpiod_get_value(skt->stat[SOC_STAT_VS2].desc);
 305
 306         skt->ops->socket_state(skt, &state);
 307
 308         stat = state.detect  ? SS_DETECT : 0;
 309         stat |= state.ready  ? SS_READY  : 0;
 310         stat |= state.wrprot ? SS_WRPROT : 0;
 311         stat |= state.vs_3v  ? SS_3VCARD : 0;
 312         stat |= state.vs_Xv  ? SS_XVCARD : 0;
 313
 314         /* The power status of individual sockets is not available
 315          * explicitly from the hardware, so we just remember the state
 316          * and regurgitate it upon request:
 317          */
 318         stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
 319
 320         if (skt->cs_state.flags & SS_IOCARD)
 321                 stat |= state.bvd1 ? 0 : SS_STSCHG;
 322         else {
 323                 if (state.bvd1 == 0)
 324                         stat |= SS_BATDEAD;
 325                 else if (state.bvd2 == 0)
 326                         stat |= SS_BATWARN;
 327         }
 328         return stat;
 329 }
 330
 331 /*
 332  * soc_common_pcmcia_config_skt
 333  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 334  *
 335  * Convert PCMCIA socket state to our socket configure structure.
 336  */
 337 static int soc_common_pcmcia_config_skt(
 338         struct soc_pcmcia_socket *skt, socket_state_t *state)
 339 {
 340         int ret;
 341
 342         ret = skt->ops->configure_socket(skt, state);
 343         if (ret < 0) {
 344                 pr_err("soc_common_pcmcia: unable to configure socket %d\n",
 345                        skt->nr);
 346                 /* restore the previous state */
 347                 WARN_ON(skt->ops->configure_socket(skt, &skt->cs_state));
 348                 return ret;
 349         }
 350
 351         if (ret == 0) {
 352                 struct gpio_desc *descs[2];
 353                 DECLARE_BITMAP(values, 2);
 354                 int n = 0;
 355
 356                 if (skt->gpio_reset) {
 357                         descs[n] = skt->gpio_reset;
 358                         __assign_bit(n++, values, state->flags & SS_RESET);
 359                 }
 360                 if (skt->gpio_bus_enable) {
 361                         descs[n] = skt->gpio_bus_enable;
 362                         __assign_bit(n++, values, state->flags & SS_OUTPUT_ENA);
 363                 }
 364
 365                 if (n)
 366                         gpiod_set_array_value_cansleep(n, descs, NULL, 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(PCI_IOBASE + skt->res_io_io.start);
 787         release_resource(&skt->res_attr);
 788         release_resource(&skt->res_mem);
 789         release_resource(&skt->res_io);
 790         release_resource(&skt->res_skt);
 791 }
 792 EXPORT_SYMBOL(soc_pcmcia_remove_one);
 793
 794 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
 795 {
 796         int ret;
 797
 798         skt->cs_state = dead_socket;
 799
 800         timer_setup(&skt->poll_timer, soc_common_pcmcia_poll_event, 0);
 801         skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 802
 803         ret = request_resource(&iomem_resource, &skt->res_skt);
 804         if (ret)
 805                 goto out_err_1;
 806
 807         ret = request_resource(&skt->res_skt, &skt->res_io);
 808         if (ret)
 809                 goto out_err_2;
 810
 811         ret = request_resource(&skt->res_skt, &skt->res_mem);
 812         if (ret)
 813                 goto out_err_3;
 814
 815         ret = request_resource(&skt->res_skt, &skt->res_attr);
 816         if (ret)
 817                 goto out_err_4;
 818
 819         skt->res_io_io = (struct resource)
 820                  DEFINE_RES_IO_NAMED(skt->nr * 0x1000 + 0x10000, 0x1000,
 821                                      "PCMCIA I/O");
 822         ret = pci_remap_iospace(&skt->res_io_io, skt->res_io.start);
 823         if (ret)
 824                 goto out_err_5;
 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->res_io_io.start;
 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(PCI_IOBASE + skt->res_io_io.start);
 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");