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         if (skt->ops->socket_init)
 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         if (skt->ops->socket_suspend)
 211                 skt->ops->socket_suspend(skt);
 212
 213         return 0;
 214 }
 215
 216 static DEFINE_SPINLOCK(status_lock);
 217
 218 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 219 {
 220         unsigned int events;
 221
 222         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 223
 224         do {
 225                 unsigned int status;
 226                 unsigned long flags;
 227
 228                 status = soc_common_pcmcia_skt_state(skt);
 229
 230                 spin_lock_irqsave(&status_lock, flags);
 231                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 232                 skt->status = status;
 233                 spin_unlock_irqrestore(&status_lock, flags);
 234
 235                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 236                         events == 0         ? "<NONE>"   : "",
 237                         events & SS_DETECT  ? "DETECT "  : "",
 238                         events & SS_READY   ? "READY "   : "",
 239                         events & SS_BATDEAD ? "BATDEAD " : "",
 240                         events & SS_BATWARN ? "BATWARN " : "",
 241                         events & SS_STSCHG  ? "STSCHG "  : "");
 242
 243                 if (events)
 244                         pcmcia_parse_events(&skt->socket, events);
 245         } while (events);
 246 }
 247
 248 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 249 static void soc_common_pcmcia_poll_event(unsigned long dummy)
 250 {
 251         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
 252         debug(skt, 4, "polling for events\n");
 253
 254         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 255
 256         soc_common_check_status(skt);
 257 }
 258
 259
 260 /*
 261  * Service routine for socket driver interrupts (requested by the
 262  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 263  * The actual interrupt-servicing work is performed by
 264  * soc_common_pcmcia_thread(), largely because the Card Services event-
 265  * handling code performs scheduling operations which cannot be
 266  * executed from within an interrupt context.
 267  */
 268 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
 269 {
 270         struct soc_pcmcia_socket *skt = dev;
 271
 272         debug(skt, 3, "servicing IRQ %d\n", irq);
 273
 274         soc_common_check_status(skt);
 275
 276         return IRQ_HANDLED;
 277 }
 278
 279
 280 /*
 281  *  Implements the get_status() operation for the in-kernel PCMCIA
 282  * service (formerly SS_GetStatus in Card Services). Essentially just
 283  * fills in bits in `status' according to internal driver state or
 284  * the value of the voltage detect chipselect register.
 285  *
 286  * As a debugging note, during card startup, the PCMCIA core issues
 287  * three set_socket() commands in a row the first with RESET deasserted,
 288  * the second with RESET asserted, and the last with RESET deasserted
 289  * again. Following the third set_socket(), a get_status() command will
 290  * be issued. The kernel is looking for the SS_READY flag (see
 291  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 292  *
 293  * Returns: 0
 294  */
 295 static int
 296 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 297 {
 298         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 299
 300         skt->status = soc_common_pcmcia_skt_state(skt);
 301         *status = skt->status;
 302
 303         return 0;
 304 }
 305
 306
 307 /*
 308  * Implements the set_socket() operation for the in-kernel PCMCIA
 309  * service (formerly SS_SetSocket in Card Services). We more or
 310  * less punt all of this work and let the kernel handle the details
 311  * of power configuration, reset, &c. We also record the value of
 312  * `state' in order to regurgitate it to the PCMCIA core later.
 313  */
 314 static int soc_common_pcmcia_set_socket(
 315         struct pcmcia_socket *sock, socket_state_t *state)
 316 {
 317         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 318
 319         debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
 320                         (state->csc_mask == 0)          ? "<NONE> " :   "",
 321                         (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
 322                         (state->csc_mask & SS_READY)    ? "READY " :    "",
 323                         (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
 324                         (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
 325                         (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
 326                         (state->flags == 0)             ? "<NONE> " :   "",
 327                         (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
 328                         (state->flags & SS_IOCARD)      ? "IOCARD " :   "",
 329                         (state->flags & SS_RESET)       ? "RESET " :    "",
 330                         (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
 331                         (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
 332                         state->Vcc, state->Vpp, state->io_irq);
 333
 334         return soc_common_pcmcia_config_skt(skt, state);
 335 }
 336
 337
 338 /*
 339  * Implements the set_io_map() operation for the in-kernel PCMCIA
 340  * service (formerly SS_SetIOMap in Card Services). We configure
 341  * the map speed as requested, but override the address ranges
 342  * supplied by Card Services.
 343  *
 344  * Returns: 0 on success, -1 on error
 345  */
 346 static int soc_common_pcmcia_set_io_map(
 347         struct pcmcia_socket *sock, struct pccard_io_map *map)
 348 {
 349         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 350         unsigned short speed = map->speed;
 351
 352         debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
 353                 map->map, map->speed, (unsigned long long)map->start,
 354                 (unsigned long long)map->stop);
 355         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 356                 (map->flags == 0)               ? "<NONE>"      : "",
 357                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 358                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 359                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 360                 (map->flags & MAP_0WS)          ? "0WS "        : "",
 361                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 362                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "",
 363                 (map->flags & MAP_PREFETCH)     ? "PREFETCH "   : "");
 364
 365         if (map->map >= MAX_IO_WIN) {
 366                 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
 367                        map->map);
 368                 return -1;
 369         }
 370
 371         if (map->flags & MAP_ACTIVE) {
 372                 if (speed == 0)
 373                         speed = SOC_PCMCIA_IO_ACCESS;
 374         } else {
 375                 speed = 0;
 376         }
 377
 378         skt->spd_io[map->map] = speed;
 379         skt->ops->set_timing(skt);
 380
 381         if (map->stop == 1)
 382                 map->stop = PAGE_SIZE-1;
 383
 384         map->stop -= map->start;
 385         map->stop += skt->socket.io_offset;
 386         map->start = skt->socket.io_offset;
 387
 388         return 0;
 389 }
 390
 391
 392 /*
 393  * Implements the set_mem_map() operation for the in-kernel PCMCIA
 394  * service (formerly SS_SetMemMap in Card Services). We configure
 395  * the map speed as requested, but override the address ranges
 396  * supplied by Card Services.
 397  *
 398  * Returns: 0 on success, -ERRNO on error
 399  */
 400 static int soc_common_pcmcia_set_mem_map(
 401         struct pcmcia_socket *sock, struct pccard_mem_map *map)
 402 {
 403         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 404         struct resource *res;
 405         unsigned short speed = map->speed;
 406
 407         debug(skt, 2, "map %u speed %u card_start %08x\n",
 408                 map->map, map->speed, map->card_start);
 409         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 410                 (map->flags == 0)               ? "<NONE>"      : "",
 411                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
 412                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
 413                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
 414                 (map->flags & MAP_0WS)          ? "0WS "        : "",
 415                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
 416                 (map->flags & MAP_ATTRIB)       ? "ATTRIB "     : "",
 417                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "");
 418
 419         if (map->map >= MAX_WIN)
 420                 return -EINVAL;
 421
 422         if (map->flags & MAP_ACTIVE) {
 423                 if (speed == 0)
 424                         speed = 300;
 425         } else {
 426                 speed = 0;
 427         }
 428
 429         if (map->flags & MAP_ATTRIB) {
 430                 res = &skt->res_attr;
 431                 skt->spd_attr[map->map] = speed;
 432                 skt->spd_mem[map->map] = 0;
 433         } else {
 434                 res = &skt->res_mem;
 435                 skt->spd_attr[map->map] = 0;
 436                 skt->spd_mem[map->map] = speed;
 437         }
 438
 439         skt->ops->set_timing(skt);
 440
 441         map->static_start = res->start + map->card_start;
 442
 443         return 0;
 444 }
 445
 446 struct bittbl {
 447         unsigned int mask;
 448         const char *name;
 449 };
 450
 451 static struct bittbl status_bits[] = {
 452         { SS_WRPROT,            "SS_WRPROT"     },
 453         { SS_BATDEAD,           "SS_BATDEAD"    },
 454         { SS_BATWARN,           "SS_BATWARN"    },
 455         { SS_READY,             "SS_READY"      },
 456         { SS_DETECT,            "SS_DETECT"     },
 457         { SS_POWERON,           "SS_POWERON"    },
 458         { SS_STSCHG,            "SS_STSCHG"     },
 459         { SS_3VCARD,            "SS_3VCARD"     },
 460         { SS_XVCARD,            "SS_XVCARD"     },
 461 };
 462
 463 static struct bittbl conf_bits[] = {
 464         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 465         { SS_IOCARD,            "SS_IOCARD"     },
 466         { SS_RESET,             "SS_RESET"      },
 467         { SS_DMA_MODE,          "SS_DMA_MODE"   },
 468         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 469         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 470 };
 471
 472 static void dump_bits(char **p, const char *prefix,
 473         unsigned int val, struct bittbl *bits, int sz)
 474 {
 475         char *b = *p;
 476         int i;
 477
 478         b += sprintf(b, "%-9s:", prefix);
 479         for (i = 0; i < sz; i++)
 480                 if (val & bits[i].mask)
 481                         b += sprintf(b, " %s", bits[i].name);
 482         *b++ = '\n';
 483         *p = b;
 484 }
 485
 486 /*
 487  * Implements the /sys/class/pcmcia_socket/??/status file.
 488  *
 489  * Returns: the number of characters added to the buffer
 490  */
 491 static ssize_t show_status(
 492         struct device *dev, struct device_attribute *attr, char *buf)
 493 {
 494         struct soc_pcmcia_socket *skt =
 495                 container_of(dev, struct soc_pcmcia_socket, socket.dev);
 496         char *p = buf;
 497
 498         p += sprintf(p, "slot     : %d\n", skt->nr);
 499
 500         dump_bits(&p, "status", skt->status,
 501                   status_bits, ARRAY_SIZE(status_bits));
 502         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 503                   status_bits, ARRAY_SIZE(status_bits));
 504         dump_bits(&p, "cs_flags", skt->cs_state.flags,
 505                   conf_bits, ARRAY_SIZE(conf_bits));
 506
 507         p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 508         p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 509         p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
 510                 skt->socket.pci_irq);
 511         if (skt->ops->show_timing)
 512                 p += skt->ops->show_timing(skt, p);
 513
 514         return p-buf;
 515 }
 516 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 517
 518
 519 static struct pccard_operations soc_common_pcmcia_operations = {
 520         .init                   = soc_common_pcmcia_sock_init,
 521         .suspend                = soc_common_pcmcia_suspend,
 522         .get_status             = soc_common_pcmcia_get_status,
 523         .set_socket             = soc_common_pcmcia_set_socket,
 524         .set_io_map             = soc_common_pcmcia_set_io_map,
 525         .set_mem_map            = soc_common_pcmcia_set_mem_map,
 526 };
 527
 528
 529 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
 530                             struct pcmcia_irqs *irqs, int nr)
 531 {
 532         int i, res = 0;
 533
 534         for (i = 0; i < nr; i++) {
 535                 if (irqs[i].sock != skt->nr)
 536                         continue;
 537                 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
 538                                   IRQF_DISABLED, irqs[i].str, skt);
 539                 if (res)
 540                         break;
 541                 irq_set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
 542         }
 543
 544         if (res) {
 545                 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
 546                         irqs[i].irq, res);
 547
 548                 while (i--)
 549                         if (irqs[i].sock == skt->nr)
 550                                 free_irq(irqs[i].irq, skt);
 551         }
 552         return res;
 553 }
 554 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
 555
 556 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
 557                           struct pcmcia_irqs *irqs, int nr)
 558 {
 559         int i;
 560
 561         for (i = 0; i < nr; i++)
 562                 if (irqs[i].sock == skt->nr)
 563                         free_irq(irqs[i].irq, skt);
 564 }
 565 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
 566
 567 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
 568                              struct pcmcia_irqs *irqs, int nr)
 569 {
 570         int i;
 571
 572         for (i = 0; i < nr; i++)
 573                 if (irqs[i].sock == skt->nr)
 574                         irq_set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
 575 }
 576 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
 577
 578 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
 579                             struct pcmcia_irqs *irqs, int nr)
 580 {
 581         int i;
 582
 583         for (i = 0; i < nr; i++)
 584                 if (irqs[i].sock == skt->nr) {
 585                         irq_set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
 586                         irq_set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
 587                 }
 588 }
 589 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
 590
 591
 592 static LIST_HEAD(soc_pcmcia_sockets);
 593 static DEFINE_MUTEX(soc_pcmcia_sockets_lock);
 594
 595 #ifdef CONFIG_CPU_FREQ
 596 static int
 597 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
 598 {
 599         struct soc_pcmcia_socket *skt;
 600         struct cpufreq_freqs *freqs = data;
 601         int ret = 0;
 602
 603         mutex_lock(&soc_pcmcia_sockets_lock);
 604         list_for_each_entry(skt, &soc_pcmcia_sockets, node)
 605                 if (skt->ops->frequency_change)
 606                         ret += skt->ops->frequency_change(skt, val, freqs);
 607         mutex_unlock(&soc_pcmcia_sockets_lock);
 608
 609         return ret;
 610 }
 611
 612 static struct notifier_block soc_pcmcia_notifier_block = {
 613         .notifier_call  = soc_pcmcia_notifier
 614 };
 615
 616 static int soc_pcmcia_cpufreq_register(void)
 617 {
 618         int ret;
 619
 620         ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
 621                                         CPUFREQ_TRANSITION_NOTIFIER);
 622         if (ret < 0)
 623                 printk(KERN_ERR "Unable to register CPU frequency change "
 624                                 "notifier for PCMCIA (%d)\n", ret);
 625         return ret;
 626 }
 627 fs_initcall(soc_pcmcia_cpufreq_register);
 628
 629 static void soc_pcmcia_cpufreq_unregister(void)
 630 {
 631         cpufreq_unregister_notifier(&soc_pcmcia_notifier_block,
 632                 CPUFREQ_TRANSITION_NOTIFIER);
 633 }
 634 module_exit(soc_pcmcia_cpufreq_unregister);
 635
 636 #endif
 637
 638 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
 639 {
 640         mutex_lock(&soc_pcmcia_sockets_lock);
 641         del_timer_sync(&skt->poll_timer);
 642
 643         pcmcia_unregister_socket(&skt->socket);
 644
 645         skt->ops->hw_shutdown(skt);
 646
 647         soc_common_pcmcia_config_skt(skt, &dead_socket);
 648
 649         list_del(&skt->node);
 650         mutex_unlock(&soc_pcmcia_sockets_lock);
 651
 652         iounmap(skt->virt_io);
 653         skt->virt_io = NULL;
 654         release_resource(&skt->res_attr);
 655         release_resource(&skt->res_mem);
 656         release_resource(&skt->res_io);
 657         release_resource(&skt->res_skt);
 658 }
 659 EXPORT_SYMBOL(soc_pcmcia_remove_one);
 660
 661 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
 662 {
 663         int ret;
 664
 665         init_timer(&skt->poll_timer);
 666         skt->poll_timer.function = soc_common_pcmcia_poll_event;
 667         skt->poll_timer.data = (unsigned long)skt;
 668         skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 669
 670         ret = request_resource(&iomem_resource, &skt->res_skt);
 671         if (ret)
 672                 goto out_err_1;
 673
 674         ret = request_resource(&skt->res_skt, &skt->res_io);
 675         if (ret)
 676                 goto out_err_2;
 677
 678         ret = request_resource(&skt->res_skt, &skt->res_mem);
 679         if (ret)
 680                 goto out_err_3;
 681
 682         ret = request_resource(&skt->res_skt, &skt->res_attr);
 683         if (ret)
 684                 goto out_err_4;
 685
 686         skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 687         if (skt->virt_io == NULL) {
 688                 ret = -ENOMEM;
 689                 goto out_err_5;
 690         }
 691
 692         mutex_lock(&soc_pcmcia_sockets_lock);
 693
 694         list_add(&skt->node, &soc_pcmcia_sockets);
 695
 696         /*
 697          * We initialize default socket timing here, because
 698          * we are not guaranteed to see a SetIOMap operation at
 699          * runtime.
 700          */
 701         skt->ops->set_timing(skt);
 702
 703         ret = skt->ops->hw_init(skt);
 704         if (ret)
 705                 goto out_err_6;
 706
 707         skt->socket.ops = &soc_common_pcmcia_operations;
 708         skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 709         skt->socket.resource_ops = &pccard_static_ops;
 710         skt->socket.irq_mask = 0;
 711         skt->socket.map_size = PAGE_SIZE;
 712         skt->socket.io_offset = (unsigned long)skt->virt_io;
 713
 714         skt->status = soc_common_pcmcia_skt_state(skt);
 715
 716         ret = pcmcia_register_socket(&skt->socket);
 717         if (ret)
 718                 goto out_err_7;
 719
 720         add_timer(&skt->poll_timer);
 721
 722         mutex_unlock(&soc_pcmcia_sockets_lock);
 723
 724         ret = device_create_file(&skt->socket.dev, &dev_attr_status);
 725         if (ret)
 726                 goto out_err_8;
 727
 728         return ret;
 729
 730  out_err_8:
 731         mutex_lock(&soc_pcmcia_sockets_lock);
 732         del_timer_sync(&skt->poll_timer);
 733         pcmcia_unregister_socket(&skt->socket);
 734
 735  out_err_7:
 736         skt->ops->hw_shutdown(skt);
 737  out_err_6:
 738         list_del(&skt->node);
 739         mutex_unlock(&soc_pcmcia_sockets_lock);
 740         iounmap(skt->virt_io);
 741  out_err_5:
 742         release_resource(&skt->res_attr);
 743  out_err_4:
 744         release_resource(&skt->res_mem);
 745  out_err_3:
 746         release_resource(&skt->res_io);
 747  out_err_2:
 748         release_resource(&skt->res_skt);
 749  out_err_1:
 750
 751         return ret;
 752 }
 753 EXPORT_SYMBOL(soc_pcmcia_add_one);
 754
 755 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
 756 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
 757 MODULE_LICENSE("Dual MPL/GPL");