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