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