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