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 /* FIXME: platform dependent resource declaration has to move out of this file */
  53 #ifdef CONFIG_ARCH_PXA
  54 #include <asm/arch/pxa-regs.h>
  55 #endif
  56
  57 #ifdef DEBUG
  58
  59 static int pc_debug;
  60 module_param(pc_debug, int, 0644);
  61
  62 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
  63                       int lvl, const char *fmt, ...)
  64 {
  65         va_list args;
  66         if (pc_debug > lvl) {
  67                 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
  68                 va_start(args, fmt);
  69                 vprintk(fmt, args);
  70                 va_end(args);
  71         }
  72 }
  73
  74 #endif
  75
  76 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
  77
  78 static unsigned short
  79 calc_speed(unsigned short *spds, int num, unsigned short dflt)
  80 {
  81         unsigned short speed = 0;
  82         int i;
  83
  84         for (i = 0; i < num; i++)
  85                 if (speed < spds[i])
  86                         speed = spds[i];
  87         if (speed == 0)
  88                 speed = dflt;
  89
  90         return speed;
  91 }
  92
  93 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
  94 {
  95         timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
  96         timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  97         timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  98 }
  99 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
 100
 101 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
 102 {
 103         struct pcmcia_state state;
 104         unsigned int stat;
 105
 106         memset(&state, 0, sizeof(struct pcmcia_state));
 107
 108         skt->ops->socket_state(skt, &state);
 109
 110         stat = state.detect  ? SS_DETECT : 0;
 111         stat |= state.ready  ? SS_READY  : 0;
 112         stat |= state.wrprot ? SS_WRPROT : 0;
 113         stat |= state.vs_3v  ? SS_3VCARD : 0;
 114         stat |= state.vs_Xv  ? SS_XVCARD : 0;
 115
 116         /* The power status of individual sockets is not available
 117          * explicitly from the hardware, so we just remember the state
 118          * and regurgitate it upon request:
 119          */
 120         stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
 121
 122         if (skt->cs_state.flags & SS_IOCARD)
 123                 stat |= state.bvd1 ? SS_STSCHG : 0;
 124         else {
 125                 if (state.bvd1 == 0)
 126                         stat |= SS_BATDEAD;
 127                 else if (state.bvd2 == 0)
 128                         stat |= SS_BATWARN;
 129         }
 130         return stat;
 131 }
 132
 133 /*
 134  * soc_common_pcmcia_config_skt
 135  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 136  *
 137  * Convert PCMCIA socket state to our socket configure structure.
 138  */
 139 static int
 140 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
 141 {
 142         int ret;
 143
 144         ret = skt->ops->configure_socket(skt, state);
 145         if (ret == 0) {
 146                 /*
 147                  * This really needs a better solution.  The IRQ
 148                  * may or may not be claimed by the driver.
 149                  */
 150                 if (skt->irq_state != 1 && state->io_irq) {
 151                         skt->irq_state = 1;
 152                         set_irq_type(skt->irq, IRQT_FALLING);
 153                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
 154                         skt->irq_state = 0;
 155                         set_irq_type(skt->irq, IRQT_NOEDGE);
 156                 }
 157
 158                 skt->cs_state = *state;
 159         }
 160
 161         if (ret < 0)
 162                 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
 163                        "socket %d\n", skt->nr);
 164
 165         return ret;
 166 }
 167
 168 /* soc_common_pcmcia_sock_init()
 169  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 170  *
 171  * (Re-)Initialise the socket, turning on status interrupts
 172  * and PCMCIA bus.  This must wait for power to stabilise
 173  * so that the card status signals report correctly.
 174  *
 175  * Returns: 0
 176  */
 177 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
 178 {
 179         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 180
 181         debug(skt, 2, "initializing socket\n");
 182
 183         skt->ops->socket_init(skt);
 184         return 0;
 185 }
 186
 187
 188 /*
 189  * soc_common_pcmcia_suspend()
 190  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 191  *
 192  * Remove power on the socket, disable IRQs from the card.
 193  * Turn off status interrupts, and disable the PCMCIA bus.
 194  *
 195  * Returns: 0
 196  */
 197 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
 198 {
 199         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 200
 201         debug(skt, 2, "suspending socket\n");
 202
 203         skt->ops->socket_suspend(skt);
 204
 205         return 0;
 206 }
 207
 208 static DEFINE_SPINLOCK(status_lock);
 209
 210 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 211 {
 212         unsigned int events;
 213
 214         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 215
 216         do {
 217                 unsigned int status;
 218                 unsigned long flags;
 219
 220                 status = soc_common_pcmcia_skt_state(skt);
 221
 222                 spin_lock_irqsave(&status_lock, flags);
 223                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 224                 skt->status = status;
 225                 spin_unlock_irqrestore(&status_lock, flags);
 226
 227                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 228                         events == 0         ? "<NONE>"   : "",
 229                         events & SS_DETECT  ? "DETECT "  : "",
 230                         events & SS_READY   ? "READY "   : "",
 231                         events & SS_BATDEAD ? "BATDEAD " : "",
 232                         events & SS_BATWARN ? "BATWARN " : "",
 233                         events & SS_STSCHG  ? "STSCHG "  : "");
 234
 235                 if (events)
 236                         pcmcia_parse_events(&skt->socket, events);
 237         } while (events);
 238 }
 239
 240 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 241 static void soc_common_pcmcia_poll_event(unsigned long dummy)
 242 {
 243         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
 244         debug(skt, 4, "polling for events\n");
 245
 246         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 247
 248         soc_common_check_status(skt);
 249 }
 250
 251
 252 /*
 253  * Service routine for socket driver interrupts (requested by the
 254  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 255  * The actual interrupt-servicing work is performed by
 256  * soc_common_pcmcia_thread(), largely because the Card Services event-
 257  * handling code performs scheduling operations which cannot be
 258  * executed from within an interrupt context.
 259  */
 260 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
 261 {
 262         struct soc_pcmcia_socket *skt = dev;
 263
 264         debug(skt, 3, "servicing IRQ %d\n", irq);
 265
 266         soc_common_check_status(skt);
 267
 268         return IRQ_HANDLED;
 269 }
 270
 271
 272 /*
 273  *  Implements the get_status() operation for the in-kernel PCMCIA
 274  * service (formerly SS_GetStatus in Card Services). Essentially just
 275  * fills in bits in `status' according to internal driver state or
 276  * the value of the voltage detect chipselect register.
 277  *
 278  * As a debugging note, during card startup, the PCMCIA core issues
 279  * three set_socket() commands in a row the first with RESET deasserted,
 280  * the second with RESET asserted, and the last with RESET deasserted
 281  * again. Following the third set_socket(), a get_status() command will
 282  * be issued. The kernel is looking for the SS_READY flag (see
 283  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 284  *
 285  * Returns: 0
 286  */
 287 static int
 288 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 289 {
 290         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 291
 292         skt->status = soc_common_pcmcia_skt_state(skt);
 293         *status = skt->status;
 294
 295         return 0;
 296 }
 297
 298
 299 /*
 300  * Implements the get_socket() operation for the in-kernel PCMCIA
 301  * service (formerly SS_GetSocket in Card Services). Not a very
 302  * exciting routine.
 303  *
 304  * Returns: 0
 305  */
 306 static int
 307 soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 308 {
 309         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 310
 311         debug(skt, 2, "\n");
 312
 313         *state = skt->cs_state;
 314
 315         return 0;
 316 }
 317
 318 /*
 319  * Implements the set_socket() operation for the in-kernel PCMCIA
 320  * service (formerly SS_SetSocket in Card Services). We more or
 321  * less punt all of this work and let the kernel handle the details
 322  * of power configuration, reset, &c. We also record the value of
 323  * `state' in order to regurgitate it to the PCMCIA core later.
 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 += skt->socket.io_offset;
 396         map->start = skt->socket.io_offset;
 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, -ERRNO 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->static_start = res->start + map->card_start;
 452
 453         return 0;
 454 }
 455
 456 struct bittbl {
 457         unsigned int mask;
 458         const char *name;
 459 };
 460
 461 static struct bittbl status_bits[] = {
 462         { SS_WRPROT,            "SS_WRPROT"     },
 463         { SS_BATDEAD,           "SS_BATDEAD"    },
 464         { SS_BATWARN,           "SS_BATWARN"    },
 465         { SS_READY,             "SS_READY"      },
 466         { SS_DETECT,            "SS_DETECT"     },
 467         { SS_POWERON,           "SS_POWERON"    },
 468         { SS_STSCHG,            "SS_STSCHG"     },
 469         { SS_3VCARD,            "SS_3VCARD"     },
 470         { SS_XVCARD,            "SS_XVCARD"     },
 471 };
 472
 473 static struct bittbl conf_bits[] = {
 474         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 475         { SS_IOCARD,            "SS_IOCARD"     },
 476         { SS_RESET,             "SS_RESET"      },
 477         { SS_DMA_MODE,          "SS_DMA_MODE"   },
 478         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 479         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 480 };
 481
 482 static void
 483 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
 484 {
 485         char *b = *p;
 486         int i;
 487
 488         b += sprintf(b, "%-9s:", prefix);
 489         for (i = 0; i < sz; i++)
 490                 if (val & bits[i].mask)
 491                         b += sprintf(b, " %s", bits[i].name);
 492         *b++ = '\n';
 493         *p = b;
 494 }
 495
 496 /*
 497  * Implements the /sys/class/pcmcia_socket/??/status file.
 498  *
 499  * Returns: the number of characters added to the buffer
 500  */
 501 static ssize_t show_status(struct class_device *class_dev, char *buf)
 502 {
 503         struct soc_pcmcia_socket *skt =
 504                 container_of(class_dev, struct soc_pcmcia_socket, socket.dev);
 505         char *p = buf;
 506
 507         p+=sprintf(p, "slot     : %d\n", skt->nr);
 508
 509         dump_bits(&p, "status", skt->status,
 510                   status_bits, ARRAY_SIZE(status_bits));
 511         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 512                   status_bits, ARRAY_SIZE(status_bits));
 513         dump_bits(&p, "cs_flags", skt->cs_state.flags,
 514                   conf_bits, ARRAY_SIZE(conf_bits));
 515
 516         p+=sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 517         p+=sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 518         p+=sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
 519         if (skt->ops->show_timing)
 520                 p+=skt->ops->show_timing(skt, p);
 521
 522         return p-buf;
 523 }
 524 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 525
 526
 527 static struct pccard_operations soc_common_pcmcia_operations = {
 528         .init                   = soc_common_pcmcia_sock_init,
 529         .suspend                = soc_common_pcmcia_suspend,
 530         .get_status             = soc_common_pcmcia_get_status,
 531         .get_socket             = soc_common_pcmcia_get_socket,
 532         .set_socket             = soc_common_pcmcia_set_socket,
 533         .set_io_map             = soc_common_pcmcia_set_io_map,
 534         .set_mem_map            = soc_common_pcmcia_set_mem_map,
 535 };
 536
 537
 538 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
 539                             struct pcmcia_irqs *irqs, int nr)
 540 {
 541         int i, res = 0;
 542
 543         for (i = 0; i < nr; i++) {
 544                 if (irqs[i].sock != skt->nr)
 545                         continue;
 546                 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
 547                                   SA_INTERRUPT, irqs[i].str, skt);
 548                 if (res)
 549                         break;
 550                 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 551         }
 552
 553         if (res) {
 554                 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
 555                         irqs[i].irq, res);
 556
 557                 while (i--)
 558                         if (irqs[i].sock == skt->nr)
 559                                 free_irq(irqs[i].irq, skt);
 560         }
 561         return res;
 562 }
 563 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
 564
 565 void soc_pcmcia_free_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                         free_irq(irqs[i].irq, skt);
 573 }
 574 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
 575
 576 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
 577                              struct pcmcia_irqs *irqs, int nr)
 578 {
 579         int i;
 580
 581         for (i = 0; i < nr; i++)
 582                 if (irqs[i].sock == skt->nr)
 583                         set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 584 }
 585 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
 586
 587 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
 588                             struct pcmcia_irqs *irqs, int nr)
 589 {
 590         int i;
 591
 592         for (i = 0; i < nr; i++)
 593                 if (irqs[i].sock == skt->nr) {
 594                         set_irq_type(irqs[i].irq, IRQT_RISING);
 595                         set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
 596                 }
 597 }
 598 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
 599
 600
 601 LIST_HEAD(soc_pcmcia_sockets);
 602 DECLARE_MUTEX(soc_pcmcia_sockets_lock);
 603
 604 static const char *skt_names[] = {
 605         "PCMCIA socket 0",
 606         "PCMCIA socket 1",
 607 };
 608
 609 struct skt_dev_info {
 610         int nskt;
 611         struct soc_pcmcia_socket skt[0];
 612 };
 613
 614 #define SKT_DEV_INFO_SIZE(n) \
 615         (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
 616
 617 #ifdef CONFIG_CPU_FREQ
 618 static int
 619 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
 620 {
 621         struct soc_pcmcia_socket *skt;
 622         struct cpufreq_freqs *freqs = data;
 623         int ret = 0;
 624
 625         down(&soc_pcmcia_sockets_lock);
 626         list_for_each_entry(skt, &soc_pcmcia_sockets, node)
 627                 if ( skt->ops->frequency_change )
 628                         ret += skt->ops->frequency_change(skt, val, freqs);
 629         up(&soc_pcmcia_sockets_lock);
 630
 631         return ret;
 632 }
 633
 634 static struct notifier_block soc_pcmcia_notifier_block = {
 635         .notifier_call  = soc_pcmcia_notifier
 636 };
 637
 638 static int soc_pcmcia_cpufreq_register(void)
 639 {
 640         int ret;
 641
 642         ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
 643                                         CPUFREQ_TRANSITION_NOTIFIER);
 644         if (ret < 0)
 645                 printk(KERN_ERR "Unable to register CPU frequency change "
 646                                 "notifier for PCMCIA (%d)\n", ret);
 647         return ret;
 648 }
 649
 650 static void soc_pcmcia_cpufreq_unregister(void)
 651 {
 652         cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
 653 }
 654
 655 #else
 656 static int soc_pcmcia_cpufreq_register(void) { return 0; }
 657 static void soc_pcmcia_cpufreq_unregister(void) {}
 658 #endif
 659
 660 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
 661 {
 662         struct skt_dev_info *sinfo;
 663         struct soc_pcmcia_socket *skt;
 664         int ret, i;
 665
 666         down(&soc_pcmcia_sockets_lock);
 667
 668         sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
 669         if (!sinfo) {
 670                 ret = -ENOMEM;
 671                 goto out;
 672         }
 673
 674         memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
 675         sinfo->nskt = nr;
 676
 677         /*
 678          * Initialise the per-socket structure.
 679          */
 680         for (i = 0; i < nr; i++) {
 681                 skt = &sinfo->skt[i];
 682
 683                 skt->socket.ops = &soc_common_pcmcia_operations;
 684                 skt->socket.owner = ops->owner;
 685                 skt->socket.dev.dev = dev;
 686
 687                 init_timer(&skt->poll_timer);
 688                 skt->poll_timer.function = soc_common_pcmcia_poll_event;
 689                 skt->poll_timer.data = (unsigned long)skt;
 690                 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 691
 692                 skt->nr         = first + i;
 693                 skt->irq        = NO_IRQ;
 694                 skt->dev        = dev;
 695                 skt->ops        = ops;
 696
 697                 skt->res_skt.start      = _PCMCIA(skt->nr);
 698                 skt->res_skt.end        = _PCMCIA(skt->nr) + PCMCIASp - 1;
 699                 skt->res_skt.name       = skt_names[skt->nr];
 700                 skt->res_skt.flags      = IORESOURCE_MEM;
 701
 702                 ret = request_resource(&iomem_resource, &skt->res_skt);
 703                 if (ret)
 704                         goto out_err_1;
 705
 706                 skt->res_io.start       = _PCMCIAIO(skt->nr);
 707                 skt->res_io.end         = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
 708                 skt->res_io.name        = "io";
 709                 skt->res_io.flags       = IORESOURCE_MEM | IORESOURCE_BUSY;
 710
 711                 ret = request_resource(&skt->res_skt, &skt->res_io);
 712                 if (ret)
 713                         goto out_err_2;
 714
 715                 skt->res_mem.start      = _PCMCIAMem(skt->nr);
 716                 skt->res_mem.end        = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
 717                 skt->res_mem.name       = "memory";
 718                 skt->res_mem.flags      = IORESOURCE_MEM;
 719
 720                 ret = request_resource(&skt->res_skt, &skt->res_mem);
 721                 if (ret)
 722                         goto out_err_3;
 723
 724                 skt->res_attr.start     = _PCMCIAAttr(skt->nr);
 725                 skt->res_attr.end       = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
 726                 skt->res_attr.name      = "attribute";
 727                 skt->res_attr.flags     = IORESOURCE_MEM;
 728
 729                 ret = request_resource(&skt->res_skt, &skt->res_attr);
 730                 if (ret)
 731                         goto out_err_4;
 732
 733                 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 734                 if (skt->virt_io == NULL) {
 735                         ret = -ENOMEM;
 736                         goto out_err_5;
 737                 }
 738
 739                 if (list_empty(&soc_pcmcia_sockets))
 740                         soc_pcmcia_cpufreq_register();
 741
 742                 list_add(&skt->node, &soc_pcmcia_sockets);
 743
 744                 /*
 745                  * We initialize default socket timing here, because
 746                  * we are not guaranteed to see a SetIOMap operation at
 747                  * runtime.
 748                  */
 749                 ops->set_timing(skt);
 750
 751                 ret = ops->hw_init(skt);
 752                 if (ret)
 753                         goto out_err_6;
 754
 755                 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 756                 skt->socket.resource_ops = &pccard_static_ops;
 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                 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 }