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