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/config.h>
  35 #include <linux/module.h>
  36 #include <linux/moduleparam.h>
  37 #include <linux/init.h>
  38 #include <linux/kernel.h>
  39 #include <linux/timer.h>
  40 #include <linux/mm.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/spinlock.h>
  43 #include <linux/cpufreq.h>
  44
  45 #include <asm/hardware.h>
  46 #include <asm/io.h>
  47 #include <asm/irq.h>
  48 #include <asm/system.h>
  49
  50 #include "soc_common.h"
  51
  52 #ifdef 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                 printk(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, IRQT_FALLING);
 148                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
 149                         skt->irq_state = 0;
 150                         set_irq_type(skt->irq, IRQT_NOEDGE);
 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         int ret;
 196
 197         debug(skt, 2, "suspending socket\n");
 198
 199         ret = soc_common_pcmcia_config_skt(skt, &dead_socket);
 200         if (ret == 0)
 201                 skt->ops->socket_suspend(skt);
 202
 203         return ret;
 204 }
 205
 206 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
 207
 208 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 209 {
 210         unsigned int events;
 211
 212         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 213
 214         do {
 215                 unsigned int status;
 216                 unsigned long flags;
 217
 218                 status = soc_common_pcmcia_skt_state(skt);
 219
 220                 spin_lock_irqsave(&status_lock, flags);
 221                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 222                 skt->status = status;
 223                 spin_unlock_irqrestore(&status_lock, flags);
 224
 225                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 226                         events == 0         ? "<NONE>"   : "",
 227                         events & SS_DETECT  ? "DETECT "  : "",
 228                         events & SS_READY   ? "READY "   : "",
 229                         events & SS_BATDEAD ? "BATDEAD " : "",
 230                         events & SS_BATWARN ? "BATWARN " : "",
 231                         events & SS_STSCHG  ? "STSCHG "  : "");
 232
 233                 if (events)
 234                         pcmcia_parse_events(&skt->socket, events);
 235         } while (events);
 236 }
 237
 238 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 239 static void soc_common_pcmcia_poll_event(unsigned long dummy)
 240 {
 241         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
 242         debug(skt, 4, "polling for events\n");
 243
 244         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 245
 246         soc_common_check_status(skt);
 247 }
 248
 249
 250 /*
 251  * Service routine for socket driver interrupts (requested by the
 252  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 253  * The actual interrupt-servicing work is performed by
 254  * soc_common_pcmcia_thread(), largely because the Card Services event-
 255  * handling code performs scheduling operations which cannot be
 256  * executed from within an interrupt context.
 257  */
 258 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
 259 {
 260         struct soc_pcmcia_socket *skt = dev;
 261
 262         debug(skt, 3, "servicing IRQ %d\n", irq);
 263
 264         soc_common_check_status(skt);
 265
 266         return IRQ_HANDLED;
 267 }
 268
 269
 270 /*
 271  *  Implements the get_status() operation for the in-kernel PCMCIA
 272  * service (formerly SS_GetStatus in Card Services). Essentially just
 273  * fills in bits in `status' according to internal driver state or
 274  * the value of the voltage detect chipselect register.
 275  *
 276  * As a debugging note, during card startup, the PCMCIA core issues
 277  * three set_socket() commands in a row the first with RESET deasserted,
 278  * the second with RESET asserted, and the last with RESET deasserted
 279  * again. Following the third set_socket(), a get_status() command will
 280  * be issued. The kernel is looking for the SS_READY flag (see
 281  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 282  *
 283  * Returns: 0
 284  */
 285 static int
 286 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 287 {
 288         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 289
 290         skt->status = soc_common_pcmcia_skt_state(skt);
 291         *status = skt->status;
 292
 293         return 0;
 294 }
 295
 296
 297 /*
 298  * Implements the get_socket() operation for the in-kernel PCMCIA
 299  * service (formerly SS_GetSocket in Card Services). Not a very
 300  * exciting routine.
 301  *
 302  * Returns: 0
 303  */
 304 static int
 305 soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 306 {
 307         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 308
 309         debug(skt, 2, "\n");
 310
 311         *state = skt->cs_state;
 312
 313         return 0;
 314 }
 315
 316 /*
 317  * Implements the set_socket() operation for the in-kernel PCMCIA
 318  * service (formerly SS_SetSocket in Card Services). We more or
 319  * less punt all of this work and let the kernel handle the details
 320  * of power configuration, reset, &c. We also record the value of
 321  * `state' in order to regurgitate it to the PCMCIA core later.
 322  *
 323  * Returns: 0
 324  */
 325 static int
 326 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 327 {
 328         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 329
 330         debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
 331                         (state->csc_mask==0)?"<NONE> ":"",
 332                         (state->csc_mask&SS_DETECT)?"DETECT ":"",
 333                         (state->csc_mask&SS_READY)?"READY ":"",
 334                         (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
 335                         (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
 336                         (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
 337                         (state->flags==0)?"<NONE> ":"",
 338                         (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
 339                         (state->flags&SS_IOCARD)?"IOCARD ":"",
 340                         (state->flags&SS_RESET)?"RESET ":"",
 341                         (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
 342                         (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
 343                         state->Vcc, state->Vpp, state->io_irq);
 344
 345         return soc_common_pcmcia_config_skt(skt, state);
 346 }
 347
 348
 349 /*
 350  * Implements the set_io_map() operation for the in-kernel PCMCIA
 351  * service (formerly SS_SetIOMap in Card Services). We configure
 352  * the map speed as requested, but override the address ranges
 353  * supplied by Card Services.
 354  *
 355  * Returns: 0 on success, -1 on error
 356  */
 357 static int
 358 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
 359 {
 360         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 361         unsigned short speed = map->speed;
 362
 363         debug(skt, 2, "map %u  speed %u start 0x%08x stop 0x%08x\n",
 364                 map->map, map->speed, map->start, map->stop);
 365         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 366                 (map->flags==0)?"<NONE>":"",
 367                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 368                 (map->flags&MAP_16BIT)?"16BIT ":"",
 369                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 370                 (map->flags&MAP_0WS)?"0WS ":"",
 371                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 372                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
 373                 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
 374
 375         if (map->map >= MAX_IO_WIN) {
 376                 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
 377                        map->map);
 378                 return -1;
 379         }
 380
 381         if (map->flags & MAP_ACTIVE) {
 382                 if (speed == 0)
 383                         speed = SOC_PCMCIA_IO_ACCESS;
 384         } else {
 385                 speed = 0;
 386         }
 387
 388         skt->spd_io[map->map] = speed;
 389         skt->ops->set_timing(skt);
 390
 391         if (map->stop == 1)
 392                 map->stop = PAGE_SIZE-1;
 393
 394         map->stop -= map->start;
 395         map->stop += (unsigned long)skt->virt_io;
 396         map->start = (unsigned long)skt->virt_io;
 397
 398         return 0;
 399 }
 400
 401
 402 /*
 403  * Implements the set_mem_map() operation for the in-kernel PCMCIA
 404  * service (formerly SS_SetMemMap in Card Services). We configure
 405  * the map speed as requested, but override the address ranges
 406  * supplied by Card Services.
 407  *
 408  * Returns: 0 on success, -1 on error
 409  */
 410 static int
 411 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
 412 {
 413         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 414         struct resource *res;
 415         unsigned short speed = map->speed;
 416
 417         debug(skt, 2, "map %u speed %u card_start %08x\n",
 418                 map->map, map->speed, map->card_start);
 419         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 420                 (map->flags==0)?"<NONE>":"",
 421                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 422                 (map->flags&MAP_16BIT)?"16BIT ":"",
 423                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 424                 (map->flags&MAP_0WS)?"0WS ":"",
 425                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 426                 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
 427                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
 428
 429         if (map->map >= MAX_WIN)
 430                 return -EINVAL;
 431
 432         if (map->flags & MAP_ACTIVE) {
 433                 if (speed == 0)
 434                         speed = 300;
 435         } else {
 436                 speed = 0;
 437         }
 438
 439         if (map->flags & MAP_ATTRIB) {
 440                 res = &skt->res_attr;
 441                 skt->spd_attr[map->map] = speed;
 442                 skt->spd_mem[map->map] = 0;
 443         } else {
 444                 res = &skt->res_mem;
 445                 skt->spd_attr[map->map] = 0;
 446                 skt->spd_mem[map->map] = speed;
 447         }
 448
 449         skt->ops->set_timing(skt);
 450
 451         map->sys_stop -= map->sys_start;
 452         map->sys_stop += res->start + map->card_start;
 453         map->sys_start = res->start + map->card_start;
 454
 455         return 0;
 456 }
 457
 458 struct bittbl {
 459         unsigned int mask;
 460         const char *name;
 461 };
 462
 463 static struct bittbl status_bits[] = {
 464         { SS_WRPROT,            "SS_WRPROT"     },
 465         { SS_BATDEAD,           "SS_BATDEAD"    },
 466         { SS_BATWARN,           "SS_BATWARN"    },
 467         { SS_READY,             "SS_READY"      },
 468         { SS_DETECT,            "SS_DETECT"     },
 469         { SS_POWERON,           "SS_POWERON"    },
 470         { SS_STSCHG,            "SS_STSCHG"     },
 471         { SS_3VCARD,            "SS_3VCARD"     },
 472         { SS_XVCARD,            "SS_XVCARD"     },
 473 };
 474
 475 static struct bittbl conf_bits[] = {
 476         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 477         { SS_IOCARD,            "SS_IOCARD"     },
 478         { SS_RESET,             "SS_RESET"      },
 479         { SS_DMA_MODE,          "SS_DMA_MODE"   },
 480         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 481         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 482 };
 483
 484 static void
 485 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
 486 {
 487         char *b = *p;
 488         int i;
 489
 490         b += sprintf(b, "%-9s:", prefix);
 491         for (i = 0; i < sz; i++)
 492                 if (val & bits[i].mask)
 493                         b += sprintf(b, " %s", bits[i].name);
 494         *b++ = '\n';
 495         *p = b;
 496 }
 497
 498 /*
 499  * Implements the /sys/class/pcmcia_socket/??/status file.
 500  *
 501  * Returns: the number of characters added to the buffer
 502  */
 503 static ssize_t show_status(struct class_device *class_dev, char *buf)
 504 {
 505         struct soc_pcmcia_socket *skt =
 506                 container_of(class_dev, struct soc_pcmcia_socket, socket.dev);
 507         char *p = buf;
 508
 509         p+=sprintf(p, "slot     : %d\n", skt->nr);
 510
 511         dump_bits(&p, "status", skt->status,
 512                   status_bits, ARRAY_SIZE(status_bits));
 513         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 514                   status_bits, ARRAY_SIZE(status_bits));
 515         dump_bits(&p, "cs_flags", skt->cs_state.flags,
 516                   conf_bits, ARRAY_SIZE(conf_bits));
 517
 518         p+=sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 519         p+=sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 520         p+=sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
 521         if (skt->ops->show_timing)
 522                 p+=skt->ops->show_timing(skt, p);
 523
 524         return p-buf;
 525 }
 526 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 527
 528
 529 static struct pccard_operations soc_common_pcmcia_operations = {
 530         .init                   = soc_common_pcmcia_sock_init,
 531         .suspend                = soc_common_pcmcia_suspend,
 532         .get_status             = soc_common_pcmcia_get_status,
 533         .get_socket             = soc_common_pcmcia_get_socket,
 534         .set_socket             = soc_common_pcmcia_set_socket,
 535         .set_io_map             = soc_common_pcmcia_set_io_map,
 536         .set_mem_map            = soc_common_pcmcia_set_mem_map,
 537 };
 538
 539
 540 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
 541                             struct pcmcia_irqs *irqs, int nr)
 542 {
 543         int i, res = 0;
 544
 545         for (i = 0; i < nr; i++) {
 546                 if (irqs[i].sock != skt->nr)
 547                         continue;
 548                 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
 549                                   SA_INTERRUPT, irqs[i].str, skt);
 550                 if (res)
 551                         break;
 552                 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 553         }
 554
 555         if (res) {
 556                 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
 557                         irqs[i].irq, res);
 558
 559                 while (i--)
 560                         if (irqs[i].sock == skt->nr)
 561                                 free_irq(irqs[i].irq, skt);
 562         }
 563         return res;
 564 }
 565 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
 566
 567 void soc_pcmcia_free_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                         free_irq(irqs[i].irq, skt);
 575 }
 576 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
 577
 578 void soc_pcmcia_disable_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                         set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 586 }
 587 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
 588
 589 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
 590                             struct pcmcia_irqs *irqs, int nr)
 591 {
 592         int i;
 593
 594         for (i = 0; i < nr; i++)
 595                 if (irqs[i].sock == skt->nr) {
 596                         set_irq_type(irqs[i].irq, IRQT_RISING);
 597                         set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
 598                 }
 599 }
 600 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
 601
 602
 603 LIST_HEAD(soc_pcmcia_sockets);
 604 DECLARE_MUTEX(soc_pcmcia_sockets_lock);
 605
 606 static const char *skt_names[] = {
 607         "PCMCIA socket 0",
 608         "PCMCIA socket 1",
 609 };
 610
 611 struct skt_dev_info {
 612         int nskt;
 613         struct soc_pcmcia_socket skt[0];
 614 };
 615
 616 #define SKT_DEV_INFO_SIZE(n) \
 617         (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
 618
 619 #ifdef CONFIG_CPU_FREQ
 620 static int
 621 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
 622 {
 623         struct soc_pcmcia_socket *skt;
 624         struct cpufreq_freqs *freqs = data;
 625         int ret = 0;
 626
 627         down(&soc_pcmcia_sockets_lock);
 628         list_for_each_entry(skt, &soc_pcmcia_sockets, node)
 629                 if ( skt->ops->frequency_change )
 630                         ret += skt->ops->frequency_change(skt, val, freqs);
 631         up(&soc_pcmcia_sockets_lock);
 632
 633         return ret;
 634 }
 635
 636 static struct notifier_block soc_pcmcia_notifier_block = {
 637         .notifier_call  = soc_pcmcia_notifier
 638 };
 639
 640 static int soc_pcmcia_cpufreq_register(void)
 641 {
 642         int ret;
 643
 644         ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
 645                                         CPUFREQ_TRANSITION_NOTIFIER);
 646         if (ret < 0)
 647                 printk(KERN_ERR "Unable to register CPU frequency change "
 648                                 "notifier for PCMCIA (%d)\n", ret);
 649         return ret;
 650 }
 651
 652 static void soc_pcmcia_cpufreq_unregister(void)
 653 {
 654         cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
 655 }
 656
 657 #else
 658 #define soc_pcmcia_cpufreq_register()
 659 #define soc_pcmcia_cpufreq_unregister()
 660 #endif
 661
 662 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
 663 {
 664         struct skt_dev_info *sinfo;
 665         int ret, i;
 666
 667         down(&soc_pcmcia_sockets_lock);
 668
 669         sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
 670         if (!sinfo) {
 671                 ret = -ENOMEM;
 672                 goto out;
 673         }
 674
 675         memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
 676         sinfo->nskt = nr;
 677
 678         /*
 679          * Initialise the per-socket structure.
 680          */
 681         for (i = 0; i < nr; i++) {
 682                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 683
 684                 skt->socket.ops = &soc_common_pcmcia_operations;
 685                 skt->socket.owner = ops->owner;
 686                 skt->socket.dev.dev = dev;
 687
 688                 init_timer(&skt->poll_timer);
 689                 skt->poll_timer.function = soc_common_pcmcia_poll_event;
 690                 skt->poll_timer.data = (unsigned long)skt;
 691                 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 692
 693                 skt->nr         = first + i;
 694                 skt->irq        = NO_IRQ;
 695                 skt->dev        = dev;
 696                 skt->ops        = ops;
 697
 698                 skt->res_skt.start      = _PCMCIA(skt->nr);
 699                 skt->res_skt.end        = _PCMCIA(skt->nr) + PCMCIASp - 1;
 700                 skt->res_skt.name       = skt_names[skt->nr];
 701                 skt->res_skt.flags      = IORESOURCE_MEM;
 702
 703                 ret = request_resource(&iomem_resource, &skt->res_skt);
 704                 if (ret)
 705                         goto out_err_1;
 706
 707                 skt->res_io.start       = _PCMCIAIO(skt->nr);
 708                 skt->res_io.end         = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
 709                 skt->res_io.name        = "io";
 710                 skt->res_io.flags       = IORESOURCE_MEM | IORESOURCE_BUSY;
 711
 712                 ret = request_resource(&skt->res_skt, &skt->res_io);
 713                 if (ret)
 714                         goto out_err_2;
 715
 716                 skt->res_mem.start      = _PCMCIAMem(skt->nr);
 717                 skt->res_mem.end        = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
 718                 skt->res_mem.name       = "memory";
 719                 skt->res_mem.flags      = IORESOURCE_MEM;
 720
 721                 ret = request_resource(&skt->res_skt, &skt->res_mem);
 722                 if (ret)
 723                         goto out_err_3;
 724
 725                 skt->res_attr.start     = _PCMCIAAttr(skt->nr);
 726                 skt->res_attr.end       = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
 727                 skt->res_attr.name      = "attribute";
 728                 skt->res_attr.flags     = IORESOURCE_MEM;
 729
 730                 ret = request_resource(&skt->res_skt, &skt->res_attr);
 731                 if (ret)
 732                         goto out_err_4;
 733
 734                 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 735                 if (skt->virt_io == NULL) {
 736                         ret = -ENOMEM;
 737                         goto out_err_5;
 738                 }
 739
 740                 if ( list_empty(&soc_pcmcia_sockets) )
 741                         soc_pcmcia_cpufreq_register();
 742
 743                 list_add(&skt->node, &soc_pcmcia_sockets);
 744
 745                 /*
 746                  * We initialize default socket timing here, because
 747                  * we are not guaranteed to see a SetIOMap operation at
 748                  * runtime.
 749                  */
 750                 ops->set_timing(skt);
 751
 752                 ret = ops->hw_init(skt);
 753                 if (ret)
 754                         goto out_err_6;
 755
 756                 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 757                 skt->socket.irq_mask = 0;
 758                 skt->socket.map_size = PAGE_SIZE;
 759                 skt->socket.pci_irq = skt->irq;
 760                 skt->socket.io_offset = (unsigned long)skt->virt_io;
 761
 762                 skt->status = soc_common_pcmcia_skt_state(skt);
 763
 764                 ret = pcmcia_register_socket(&skt->socket);
 765                 if (ret)
 766                         goto out_err_7;
 767
 768                 WARN_ON(skt->socket.sock != i);
 769
 770                 add_timer(&skt->poll_timer);
 771
 772                 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
 773         }
 774
 775         dev_set_drvdata(dev, sinfo);
 776         ret = 0;
 777         goto out;
 778
 779         do {
 780                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 781
 782                 del_timer_sync(&skt->poll_timer);
 783                 pcmcia_unregister_socket(&skt->socket);
 784
 785  out_err_7:
 786                 flush_scheduled_work();
 787
 788                 ops->hw_shutdown(skt);
 789  out_err_6:
 790                 list_del(&skt->node);
 791                 iounmap(skt->virt_io);
 792  out_err_5:
 793                 release_resource(&skt->res_attr);
 794  out_err_4:
 795                 release_resource(&skt->res_mem);
 796  out_err_3:
 797                 release_resource(&skt->res_io);
 798  out_err_2:
 799                 release_resource(&skt->res_skt);
 800  out_err_1:
 801                 i--;
 802         } while (i > 0);
 803
 804         kfree(sinfo);
 805
 806  out:
 807         up(&soc_pcmcia_sockets_lock);
 808         return ret;
 809 }
 810
 811 int soc_common_drv_pcmcia_remove(struct device *dev)
 812 {
 813         struct skt_dev_info *sinfo = dev_get_drvdata(dev);
 814         int i;
 815
 816         dev_set_drvdata(dev, NULL);
 817
 818         down(&soc_pcmcia_sockets_lock);
 819         for (i = 0; i < sinfo->nskt; i++) {
 820                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 821
 822                 del_timer_sync(&skt->poll_timer);
 823
 824                 pcmcia_unregister_socket(&skt->socket);
 825
 826                 flush_scheduled_work();
 827
 828                 skt->ops->hw_shutdown(skt);
 829
 830                 soc_common_pcmcia_config_skt(skt, &dead_socket);
 831
 832                 list_del(&skt->node);
 833                 iounmap(skt->virt_io);
 834                 skt->virt_io = NULL;
 835                 release_resource(&skt->res_attr);
 836                 release_resource(&skt->res_mem);
 837                 release_resource(&skt->res_io);
 838                 release_resource(&skt->res_skt);
 839         }
 840         if ( list_empty(&soc_pcmcia_sockets) )
 841                 soc_pcmcia_cpufreq_unregister();
 842
 843         up(&soc_pcmcia_sockets_lock);
 844
 845         kfree(sinfo);
 846
 847         return 0;
 848 }