drivers/pcmcia/sa11xx_core.c

   1 /*======================================================================
   2
   3     Device driver for the PCMCIA control functionality of StrongARM
   4     SA-1100 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  * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
  34  * on the low-level kernel interface.
  35  */
  36
  37 #include <linux/module.h>
  38 #include <linux/moduleparam.h>
  39 #include <linux/init.h>
  40 #include <linux/config.h>
  41 #include <linux/cpufreq.h>
  42 #include <linux/ioport.h>
  43 #include <linux/kernel.h>
  44 #include <linux/timer.h>
  45 #include <linux/mm.h>
  46 #include <linux/notifier.h>
  47 #include <linux/interrupt.h>
  48 #include <linux/spinlock.h>
  49
  50 #include <asm/hardware.h>
  51 #include <asm/io.h>
  52 #include <asm/irq.h>
  53 #include <asm/system.h>
  54
  55 #include "sa11xx_core.h"
  56 #include "sa1100.h"
  57
  58 #ifdef DEBUG
  59 static int pc_debug;
  60
  61 module_param(pc_debug, int, 0644);
  62
  63 #define debug(skt, lvl, fmt, arg...) do {                       \
  64         if (pc_debug > (lvl))                                   \
  65                 printk(KERN_DEBUG "skt%u: %s: " fmt,            \
  66                        (skt)->nr, __func__ , ## arg);           \
  67 } while (0)
  68
  69 #else
  70 #define debug(skt, lvl, fmt, arg...) do { } while (0)
  71 #endif
  72
  73 #define to_sa1100_socket(x)     container_of(x, struct sa1100_pcmcia_socket, socket)
  74
  75 /*
  76  * sa1100_pcmcia_default_mecr_timing
  77  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  78  *
  79  * Calculate MECR clock wait states for given CPU clock
  80  * speed and command wait state. This function can be over-
  81  * written by a board specific version.
  82  *
  83  * The default is to simply calculate the BS values as specified in
  84  * the INTEL SA1100 development manual
  85  * "Expansion Memory (PCMCIA) Configuration Register (MECR)"
  86  * that's section 10.2.5 in _my_ version of the manual ;)
  87  */
  88 static unsigned int
  89 sa1100_pcmcia_default_mecr_timing(struct sa1100_pcmcia_socket *skt,
  90                                   unsigned int cpu_speed,
  91                                   unsigned int cmd_time)
  92 {
  93         return sa1100_pcmcia_mecr_bs(cmd_time, cpu_speed);
  94 }
  95
  96 static unsigned short
  97 calc_speed(unsigned short *spds, int num, unsigned short dflt)
  98 {
  99         unsigned short speed = 0;
 100         int i;
 101
 102         for (i = 0; i < num; i++)
 103                 if (speed < spds[i])
 104                         speed = spds[i];
 105         if (speed == 0)
 106                 speed = dflt;
 107
 108         return speed;
 109 }
 110
 111 /* sa1100_pcmcia_set_mecr()
 112  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 113  *
 114  * set MECR value for socket <sock> based on this sockets
 115  * io, mem and attribute space access speed.
 116  * Call board specific BS value calculation to allow boards
 117  * to tweak the BS values.
 118  */
 119 static int
 120 sa1100_pcmcia_set_mecr(struct sa1100_pcmcia_socket *skt, unsigned int cpu_clock)
 121 {
 122         u32 mecr, old_mecr;
 123         unsigned long flags;
 124         unsigned short speed;
 125         unsigned int bs_io, bs_mem, bs_attr;
 126
 127         speed = calc_speed(skt->spd_io, MAX_IO_WIN, SA1100_PCMCIA_IO_ACCESS);
 128         bs_io = skt->ops->socket_get_timing(skt, cpu_clock, speed);
 129
 130         speed = calc_speed(skt->spd_mem, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS);
 131         bs_mem = skt->ops->socket_get_timing(skt, cpu_clock, speed);
 132
 133         speed = calc_speed(skt->spd_attr, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS);
 134         bs_attr = skt->ops->socket_get_timing(skt, cpu_clock, speed);
 135
 136         local_irq_save(flags);
 137
 138         old_mecr = mecr = MECR;
 139         MECR_FAST_SET(mecr, skt->nr, 0);
 140         MECR_BSIO_SET(mecr, skt->nr, bs_io);
 141         MECR_BSA_SET(mecr, skt->nr, bs_attr);
 142         MECR_BSM_SET(mecr, skt->nr, bs_mem);
 143         if (old_mecr != mecr)
 144                 MECR = mecr;
 145
 146         local_irq_restore(flags);
 147
 148         debug(skt, 2, "FAST %X  BSM %X  BSA %X  BSIO %X\n",
 149               MECR_FAST_GET(mecr, skt->nr),
 150               MECR_BSM_GET(mecr, skt->nr), MECR_BSA_GET(mecr, skt->nr),
 151               MECR_BSIO_GET(mecr, skt->nr));
 152
 153         return 0;
 154 }
 155
 156 static unsigned int sa1100_pcmcia_skt_state(struct sa1100_pcmcia_socket *skt)
 157 {
 158         struct pcmcia_state state;
 159         unsigned int stat;
 160
 161         memset(&state, 0, sizeof(struct pcmcia_state));
 162
 163         skt->ops->socket_state(skt, &state);
 164
 165         stat = state.detect  ? SS_DETECT : 0;
 166         stat |= state.ready  ? SS_READY  : 0;
 167         stat |= state.wrprot ? SS_WRPROT : 0;
 168         stat |= state.vs_3v  ? SS_3VCARD : 0;
 169         stat |= state.vs_Xv  ? SS_XVCARD : 0;
 170
 171         /* The power status of individual sockets is not available
 172          * explicitly from the hardware, so we just remember the state
 173          * and regurgitate it upon request:
 174          */
 175         stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
 176
 177         if (skt->cs_state.flags & SS_IOCARD)
 178                 stat |= state.bvd1 ? SS_STSCHG : 0;
 179         else {
 180                 if (state.bvd1 == 0)
 181                         stat |= SS_BATDEAD;
 182                 else if (state.bvd2 == 0)
 183                         stat |= SS_BATWARN;
 184         }
 185         return stat;
 186 }
 187
 188 /*
 189  * sa1100_pcmcia_config_skt
 190  * ^^^^^^^^^^^^^^^^^^^^^^^^
 191  *
 192  * Convert PCMCIA socket state to our socket configure structure.
 193  */
 194 static int
 195 sa1100_pcmcia_config_skt(struct sa1100_pcmcia_socket *skt, socket_state_t *state)
 196 {
 197         int ret;
 198
 199         ret = skt->ops->configure_socket(skt, state);
 200         if (ret == 0) {
 201                 /*
 202                  * This really needs a better solution.  The IRQ
 203                  * may or may not be claimed by the driver.
 204                  */
 205                 if (skt->irq_state != 1 && state->io_irq) {
 206                         skt->irq_state = 1;
 207                         set_irq_type(skt->irq, IRQT_FALLING);
 208                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
 209                         skt->irq_state = 0;
 210                         set_irq_type(skt->irq, IRQT_NOEDGE);
 211                 }
 212
 213                 skt->cs_state = *state;
 214         }
 215
 216         if (ret < 0)
 217                 printk(KERN_ERR "sa1100_pcmcia: unable to configure "
 218                        "socket %d\n", skt->nr);
 219
 220         return ret;
 221 }
 222
 223 /* sa1100_pcmcia_sock_init()
 224  * ^^^^^^^^^^^^^^^^^^^^^^^^^
 225  *
 226  * (Re-)Initialise the socket, turning on status interrupts
 227  * and PCMCIA bus.  This must wait for power to stabilise
 228  * so that the card status signals report correctly.
 229  *
 230  * Returns: 0
 231  */
 232 static int sa1100_pcmcia_sock_init(struct pcmcia_socket *sock)
 233 {
 234         struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 235
 236         debug(skt, 2, "initializing socket\n");
 237
 238         skt->ops->socket_init(skt);
 239         return 0;
 240 }
 241
 242
 243 /*
 244  * sa1100_pcmcia_suspend()
 245  * ^^^^^^^^^^^^^^^^^^^^^^^
 246  *
 247  * Remove power on the socket, disable IRQs from the card.
 248  * Turn off status interrupts, and disable the PCMCIA bus.
 249  *
 250  * Returns: 0
 251  */
 252 static int sa1100_pcmcia_suspend(struct pcmcia_socket *sock)
 253 {
 254         struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 255         int ret;
 256
 257         debug(skt, 2, "suspending socket\n");
 258
 259         ret = sa1100_pcmcia_config_skt(skt, &dead_socket);
 260         if (ret == 0)
 261                 skt->ops->socket_suspend(skt);
 262
 263         return ret;
 264 }
 265
 266 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
 267
 268 /* sa1100_check_status()
 269  * ^^^^^^^^^^^^^^^^^^^^^
 270  */
 271 static void sa1100_check_status(struct sa1100_pcmcia_socket *skt)
 272 {
 273         unsigned int events;
 274
 275         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 276
 277         do {
 278                 unsigned int status;
 279                 unsigned long flags;
 280
 281                 status = sa1100_pcmcia_skt_state(skt);
 282
 283                 spin_lock_irqsave(&status_lock, flags);
 284                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 285                 skt->status = status;
 286                 spin_unlock_irqrestore(&status_lock, flags);
 287
 288                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 289                         events == 0         ? "<NONE>"   : "",
 290                         events & SS_DETECT  ? "DETECT "  : "",
 291                         events & SS_READY   ? "READY "   : "",
 292                         events & SS_BATDEAD ? "BATDEAD " : "",
 293                         events & SS_BATWARN ? "BATWARN " : "",
 294                         events & SS_STSCHG  ? "STSCHG "  : "");
 295
 296                 if (events)
 297                         pcmcia_parse_events(&skt->socket, events);
 298         } while (events);
 299 }
 300
 301 /* sa1100_pcmcia_poll_event()
 302  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
 303  * Let's poll for events in addition to IRQs since IRQ only is unreliable...
 304  */
 305 static void sa1100_pcmcia_poll_event(unsigned long dummy)
 306 {
 307         struct sa1100_pcmcia_socket *skt = (struct sa1100_pcmcia_socket *)dummy;
 308         debug(skt, 4, "polling for events\n");
 309
 310         mod_timer(&skt->poll_timer, jiffies + SA1100_PCMCIA_POLL_PERIOD);
 311
 312         sa1100_check_status(skt);
 313 }
 314
 315
 316 /* sa1100_pcmcia_interrupt()
 317  * ^^^^^^^^^^^^^^^^^^^^^^^^^
 318  * Service routine for socket driver interrupts (requested by the
 319  * low-level PCMCIA init() operation via sa1100_pcmcia_thread()).
 320  * The actual interrupt-servicing work is performed by
 321  * sa1100_pcmcia_thread(), largely because the Card Services event-
 322  * handling code performs scheduling operations which cannot be
 323  * executed from within an interrupt context.
 324  */
 325 static irqreturn_t sa1100_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
 326 {
 327         struct sa1100_pcmcia_socket *skt = dev;
 328
 329         debug(skt, 3, "servicing IRQ %d\n", irq);
 330
 331         sa1100_check_status(skt);
 332
 333         return IRQ_HANDLED;
 334 }
 335
 336
 337 /* sa1100_pcmcia_get_status()
 338  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
 339  * Implements the get_status() operation for the in-kernel PCMCIA
 340  * service (formerly SS_GetStatus in Card Services). Essentially just
 341  * fills in bits in `status' according to internal driver state or
 342  * the value of the voltage detect chipselect register.
 343  *
 344  * As a debugging note, during card startup, the PCMCIA core issues
 345  * three set_socket() commands in a row the first with RESET deasserted,
 346  * the second with RESET asserted, and the last with RESET deasserted
 347  * again. Following the third set_socket(), a get_status() command will
 348  * be issued. The kernel is looking for the SS_READY flag (see
 349  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 350  *
 351  * Returns: 0
 352  */
 353 static int
 354 sa1100_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 355 {
 356         struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 357
 358         skt->status = sa1100_pcmcia_skt_state(skt);
 359         *status = skt->status;
 360
 361         return 0;
 362 }
 363
 364
 365 /* sa1100_pcmcia_get_socket()
 366  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
 367  * Implements the get_socket() operation for the in-kernel PCMCIA
 368  * service (formerly SS_GetSocket in Card Services). Not a very
 369  * exciting routine.
 370  *
 371  * Returns: 0
 372  */
 373 static int
 374 sa1100_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 375 {
 376   struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 377
 378   debug(skt, 2, "\n");
 379
 380   *state = skt->cs_state;
 381
 382   return 0;
 383 }
 384
 385 /* sa1100_pcmcia_set_socket()
 386  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
 387  * Implements the set_socket() operation for the in-kernel PCMCIA
 388  * service (formerly SS_SetSocket in Card Services). We more or
 389  * less punt all of this work and let the kernel handle the details
 390  * of power configuration, reset, &c. We also record the value of
 391  * `state' in order to regurgitate it to the PCMCIA core later.
 392  *
 393  * Returns: 0
 394  */
 395 static int
 396 sa1100_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 397 {
 398   struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 399
 400   debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
 401         (state->csc_mask==0)?"<NONE> ":"",
 402         (state->csc_mask&SS_DETECT)?"DETECT ":"",
 403         (state->csc_mask&SS_READY)?"READY ":"",
 404         (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
 405         (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
 406         (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
 407         (state->flags==0)?"<NONE> ":"",
 408         (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
 409         (state->flags&SS_IOCARD)?"IOCARD ":"",
 410         (state->flags&SS_RESET)?"RESET ":"",
 411         (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
 412         (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
 413         state->Vcc, state->Vpp, state->io_irq);
 414
 415   return sa1100_pcmcia_config_skt(skt, state);
 416 }  /* sa1100_pcmcia_set_socket() */
 417
 418
 419 /* sa1100_pcmcia_set_io_map()
 420  * ^^^^^^^^^^^^^^^^^^^^^^^^^^
 421  * Implements the set_io_map() operation for the in-kernel PCMCIA
 422  * service (formerly SS_SetIOMap in Card Services). We configure
 423  * the map speed as requested, but override the address ranges
 424  * supplied by Card Services.
 425  *
 426  * Returns: 0 on success, -1 on error
 427  */
 428 static int
 429 sa1100_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
 430 {
 431         struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 432         unsigned short speed = map->speed;
 433
 434         debug(skt, 2, "map %u  speed %u start 0x%08x stop 0x%08x\n",
 435                 map->map, map->speed, map->start, map->stop);
 436         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 437                 (map->flags==0)?"<NONE>":"",
 438                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 439                 (map->flags&MAP_16BIT)?"16BIT ":"",
 440                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 441                 (map->flags&MAP_0WS)?"0WS ":"",
 442                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 443                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
 444                 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
 445
 446         if (map->map >= MAX_IO_WIN) {
 447                 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
 448                        map->map);
 449                 return -1;
 450         }
 451
 452         if (map->flags & MAP_ACTIVE) {
 453                 if (speed == 0)
 454                         speed = SA1100_PCMCIA_IO_ACCESS;
 455         } else {
 456                 speed = 0;
 457         }
 458
 459         skt->spd_io[map->map] = speed;
 460         sa1100_pcmcia_set_mecr(skt, cpufreq_get(0));
 461
 462         if (map->stop == 1)
 463                 map->stop = PAGE_SIZE-1;
 464
 465         map->stop -= map->start;
 466         map->stop += (unsigned long)skt->virt_io;
 467         map->start = (unsigned long)skt->virt_io;
 468
 469         return 0;
 470 }  /* sa1100_pcmcia_set_io_map() */
 471
 472
 473 /* sa1100_pcmcia_set_mem_map()
 474  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 475  * Implements the set_mem_map() operation for the in-kernel PCMCIA
 476  * service (formerly SS_SetMemMap in Card Services). We configure
 477  * the map speed as requested, but override the address ranges
 478  * supplied by Card Services.
 479  *
 480  * Returns: 0 on success, -1 on error
 481  */
 482 static int
 483 sa1100_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
 484 {
 485         struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
 486         struct resource *res;
 487         unsigned short speed = map->speed;
 488
 489         debug(skt, 2, "map %u speed %u card_start %08x\n",
 490                 map->map, map->speed, map->card_start);
 491         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 492                 (map->flags==0)?"<NONE>":"",
 493                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 494                 (map->flags&MAP_16BIT)?"16BIT ":"",
 495                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 496                 (map->flags&MAP_0WS)?"0WS ":"",
 497                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 498                 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
 499                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
 500
 501         if (map->map >= MAX_WIN)
 502                 return -EINVAL;
 503
 504         if (map->flags & MAP_ACTIVE) {
 505                 if (speed == 0)
 506                         speed = 300;
 507         } else {
 508                 speed = 0;
 509         }
 510
 511         if (map->flags & MAP_ATTRIB) {
 512                 res = &skt->res_attr;
 513                 skt->spd_attr[map->map] = speed;
 514                 skt->spd_mem[map->map] = 0;
 515         } else {
 516                 res = &skt->res_mem;
 517                 skt->spd_attr[map->map] = 0;
 518                 skt->spd_mem[map->map] = speed;
 519         }
 520
 521         sa1100_pcmcia_set_mecr(skt, cpufreq_get(0));
 522
 523         map->sys_stop -= map->sys_start;
 524         map->sys_stop += res->start + map->card_start;
 525         map->sys_start = res->start + map->card_start;
 526
 527         return 0;
 528 }
 529
 530 struct bittbl {
 531         unsigned int mask;
 532         const char *name;
 533 };
 534
 535 static struct bittbl status_bits[] = {
 536         { SS_WRPROT,            "SS_WRPROT"     },
 537         { SS_BATDEAD,           "SS_BATDEAD"    },
 538         { SS_BATWARN,           "SS_BATWARN"    },
 539         { SS_READY,             "SS_READY"      },
 540         { SS_DETECT,            "SS_DETECT"     },
 541         { SS_POWERON,           "SS_POWERON"    },
 542         { SS_STSCHG,            "SS_STSCHG"     },
 543         { SS_3VCARD,            "SS_3VCARD"     },
 544         { SS_XVCARD,            "SS_XVCARD"     },
 545 };
 546
 547 static struct bittbl conf_bits[] = {
 548         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
 549         { SS_IOCARD,            "SS_IOCARD"     },
 550         { SS_RESET,             "SS_RESET"      },
 551         { SS_DMA_MODE,          "SS_DMA_MODE"   },
 552         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
 553         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
 554 };
 555
 556 static void
 557 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
 558 {
 559         char *b = *p;
 560         int i;
 561
 562         b += sprintf(b, "%-9s:", prefix);
 563         for (i = 0; i < sz; i++)
 564                 if (val & bits[i].mask)
 565                         b += sprintf(b, " %s", bits[i].name);
 566         *b++ = '\n';
 567         *p = b;
 568 }
 569
 570 /* show_status()
 571  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 572  * Implements the /sys/class/pcmcia_socket/??/status file.
 573  *
 574  * Returns: the number of characters added to the buffer
 575  */
 576 static ssize_t show_status(struct class_device *class_dev, char *buf)
 577 {
 578         struct sa1100_pcmcia_socket *skt = container_of(class_dev,
 579                                 struct sa1100_pcmcia_socket, socket.dev);
 580         unsigned int clock = cpufreq_get(0);
 581         unsigned long mecr = MECR;
 582         char *p = buf;
 583
 584         p+=sprintf(p, "slot     : %d\n", skt->nr);
 585
 586         dump_bits(&p, "status", skt->status,
 587                   status_bits, ARRAY_SIZE(status_bits));
 588         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
 589                   status_bits, ARRAY_SIZE(status_bits));
 590         dump_bits(&p, "cs_flags", skt->cs_state.flags,
 591                   conf_bits, ARRAY_SIZE(conf_bits));
 592
 593         p+=sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
 594         p+=sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
 595         p+=sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
 596
 597         p+=sprintf(p, "I/O      : %u (%u)\n",
 598                 calc_speed(skt->spd_io, MAX_IO_WIN, SA1100_PCMCIA_IO_ACCESS),
 599                 sa1100_pcmcia_cmd_time(clock, MECR_BSIO_GET(mecr, skt->nr)));
 600
 601         p+=sprintf(p, "attribute: %u (%u)\n",
 602                 calc_speed(skt->spd_attr, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS),
 603                 sa1100_pcmcia_cmd_time(clock, MECR_BSA_GET(mecr, skt->nr)));
 604
 605         p+=sprintf(p, "common   : %u (%u)\n",
 606                 calc_speed(skt->spd_mem, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS),
 607                 sa1100_pcmcia_cmd_time(clock, MECR_BSM_GET(mecr, skt->nr)));
 608
 609         return p-buf;
 610 }
 611 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
 612
 613
 614 static struct pccard_operations sa11xx_pcmcia_operations = {
 615         .init                   = sa1100_pcmcia_sock_init,
 616         .suspend                = sa1100_pcmcia_suspend,
 617         .get_status             = sa1100_pcmcia_get_status,
 618         .get_socket             = sa1100_pcmcia_get_socket,
 619         .set_socket             = sa1100_pcmcia_set_socket,
 620         .set_io_map             = sa1100_pcmcia_set_io_map,
 621         .set_mem_map            = sa1100_pcmcia_set_mem_map,
 622 };
 623
 624 int sa11xx_request_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
 625 {
 626         int i, res = 0;
 627
 628         for (i = 0; i < nr; i++) {
 629                 if (irqs[i].sock != skt->nr)
 630                         continue;
 631                 res = request_irq(irqs[i].irq, sa1100_pcmcia_interrupt,
 632                                   SA_INTERRUPT, irqs[i].str, skt);
 633                 if (res)
 634                         break;
 635                 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 636         }
 637
 638         if (res) {
 639                 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
 640                         irqs[i].irq, res);
 641
 642                 while (i--)
 643                         if (irqs[i].sock == skt->nr)
 644                                 free_irq(irqs[i].irq, skt);
 645         }
 646         return res;
 647 }
 648 EXPORT_SYMBOL(sa11xx_request_irqs);
 649
 650 void sa11xx_free_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
 651 {
 652         int i;
 653
 654         for (i = 0; i < nr; i++)
 655                 if (irqs[i].sock == skt->nr)
 656                         free_irq(irqs[i].irq, skt);
 657 }
 658 EXPORT_SYMBOL(sa11xx_free_irqs);
 659
 660 void sa11xx_disable_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
 661 {
 662         int i;
 663
 664         for (i = 0; i < nr; i++)
 665                 if (irqs[i].sock == skt->nr)
 666                         set_irq_type(irqs[i].irq, IRQT_NOEDGE);
 667 }
 668 EXPORT_SYMBOL(sa11xx_disable_irqs);
 669
 670 void sa11xx_enable_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
 671 {
 672         int i;
 673
 674         for (i = 0; i < nr; i++)
 675                 if (irqs[i].sock == skt->nr) {
 676                         set_irq_type(irqs[i].irq, IRQT_RISING);
 677                         set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
 678                 }
 679 }
 680 EXPORT_SYMBOL(sa11xx_enable_irqs);
 681
 682 static LIST_HEAD(sa1100_sockets);
 683 static DECLARE_MUTEX(sa1100_sockets_lock);
 684
 685 static const char *skt_names[] = {
 686         "PCMCIA socket 0",
 687         "PCMCIA socket 1",
 688 };
 689
 690 struct skt_dev_info {
 691         int nskt;
 692         struct sa1100_pcmcia_socket skt[0];
 693 };
 694
 695 #define SKT_DEV_INFO_SIZE(n) \
 696         (sizeof(struct skt_dev_info) + (n)*sizeof(struct sa1100_pcmcia_socket))
 697
 698 int sa11xx_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
 699 {
 700         struct skt_dev_info *sinfo;
 701         unsigned int cpu_clock;
 702         int ret, i;
 703
 704         /*
 705          * set default MECR calculation if the board specific
 706          * code did not specify one...
 707          */
 708         if (!ops->socket_get_timing)
 709                 ops->socket_get_timing = sa1100_pcmcia_default_mecr_timing;
 710
 711         down(&sa1100_sockets_lock);
 712
 713         sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
 714         if (!sinfo) {
 715                 ret = -ENOMEM;
 716                 goto out;
 717         }
 718
 719         memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
 720         sinfo->nskt = nr;
 721
 722         cpu_clock = cpufreq_get(0);
 723
 724         /*
 725          * Initialise the per-socket structure.
 726          */
 727         for (i = 0; i < nr; i++) {
 728                 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
 729
 730                 skt->socket.ops = &sa11xx_pcmcia_operations;
 731                 skt->socket.owner = ops->owner;
 732                 skt->socket.dev.dev = dev;
 733
 734                 init_timer(&skt->poll_timer);
 735                 skt->poll_timer.function = sa1100_pcmcia_poll_event;
 736                 skt->poll_timer.data = (unsigned long)skt;
 737                 skt->poll_timer.expires = jiffies + SA1100_PCMCIA_POLL_PERIOD;
 738
 739                 skt->nr         = first + i;
 740                 skt->irq        = NO_IRQ;
 741                 skt->dev        = dev;
 742                 skt->ops        = ops;
 743
 744                 skt->res_skt.start      = _PCMCIA(skt->nr);
 745                 skt->res_skt.end        = _PCMCIA(skt->nr) + PCMCIASp - 1;
 746                 skt->res_skt.name       = skt_names[skt->nr];
 747                 skt->res_skt.flags      = IORESOURCE_MEM;
 748
 749                 ret = request_resource(&iomem_resource, &skt->res_skt);
 750                 if (ret)
 751                         goto out_err_1;
 752
 753                 skt->res_io.start       = _PCMCIAIO(skt->nr);
 754                 skt->res_io.end         = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
 755                 skt->res_io.name        = "io";
 756                 skt->res_io.flags       = IORESOURCE_MEM | IORESOURCE_BUSY;
 757
 758                 ret = request_resource(&skt->res_skt, &skt->res_io);
 759                 if (ret)
 760                         goto out_err_2;
 761
 762                 skt->res_mem.start      = _PCMCIAMem(skt->nr);
 763                 skt->res_mem.end        = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
 764                 skt->res_mem.name       = "memory";
 765                 skt->res_mem.flags      = IORESOURCE_MEM;
 766
 767                 ret = request_resource(&skt->res_skt, &skt->res_mem);
 768                 if (ret)
 769                         goto out_err_3;
 770
 771                 skt->res_attr.start     = _PCMCIAAttr(skt->nr);
 772                 skt->res_attr.end       = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
 773                 skt->res_attr.name      = "attribute";
 774                 skt->res_attr.flags     = IORESOURCE_MEM;
 775
 776                 ret = request_resource(&skt->res_skt, &skt->res_attr);
 777                 if (ret)
 778                         goto out_err_4;
 779
 780                 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 781                 if (skt->virt_io == NULL) {
 782                         ret = -ENOMEM;
 783                         goto out_err_5;
 784                 }
 785
 786                 list_add(&skt->node, &sa1100_sockets);
 787
 788                 /*
 789                  * We initialize the MECR to default values here, because
 790                  * we are not guaranteed to see a SetIOMap operation at
 791                  * runtime.
 792                  */
 793                 sa1100_pcmcia_set_mecr(skt, cpu_clock);
 794
 795                 ret = ops->hw_init(skt);
 796                 if (ret)
 797                         goto out_err_6;
 798
 799                 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 800                 skt->socket.irq_mask = 0;
 801                 skt->socket.map_size = PAGE_SIZE;
 802                 skt->socket.pci_irq = skt->irq;
 803                 skt->socket.io_offset = (unsigned long)skt->virt_io;
 804
 805                 skt->status = sa1100_pcmcia_skt_state(skt);
 806
 807                 ret = pcmcia_register_socket(&skt->socket);
 808                 if (ret)
 809                         goto out_err_7;
 810
 811                 WARN_ON(skt->socket.sock != i);
 812
 813                 add_timer(&skt->poll_timer);
 814
 815                 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
 816         }
 817
 818         dev_set_drvdata(dev, sinfo);
 819         ret = 0;
 820         goto out;
 821
 822         do {
 823                 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
 824
 825                 del_timer_sync(&skt->poll_timer);
 826                 pcmcia_unregister_socket(&skt->socket);
 827
 828  out_err_7:
 829                 flush_scheduled_work();
 830
 831                 ops->hw_shutdown(skt);
 832  out_err_6:
 833                 list_del(&skt->node);
 834                 iounmap(skt->virt_io);
 835  out_err_5:
 836                 release_resource(&skt->res_attr);
 837  out_err_4:
 838                 release_resource(&skt->res_mem);
 839  out_err_3:
 840                 release_resource(&skt->res_io);
 841  out_err_2:
 842                 release_resource(&skt->res_skt);
 843  out_err_1:
 844                 i--;
 845         } while (i > 0);
 846
 847         kfree(sinfo);
 848
 849  out:
 850         up(&sa1100_sockets_lock);
 851         return ret;
 852 }
 853 EXPORT_SYMBOL(sa11xx_drv_pcmcia_probe);
 854
 855 int sa11xx_drv_pcmcia_remove(struct device *dev)
 856 {
 857         struct skt_dev_info *sinfo = dev_get_drvdata(dev);
 858         int i;
 859
 860         dev_set_drvdata(dev, NULL);
 861
 862         down(&sa1100_sockets_lock);
 863         for (i = 0; i < sinfo->nskt; i++) {
 864                 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
 865
 866                 del_timer_sync(&skt->poll_timer);
 867
 868                 pcmcia_unregister_socket(&skt->socket);
 869
 870                 flush_scheduled_work();
 871
 872                 skt->ops->hw_shutdown(skt);
 873
 874                 sa1100_pcmcia_config_skt(skt, &dead_socket);
 875
 876                 list_del(&skt->node);
 877                 iounmap(skt->virt_io);
 878                 skt->virt_io = NULL;
 879                 release_resource(&skt->res_attr);
 880                 release_resource(&skt->res_mem);
 881                 release_resource(&skt->res_io);
 882                 release_resource(&skt->res_skt);
 883         }
 884         up(&sa1100_sockets_lock);
 885
 886         kfree(sinfo);
 887
 888         return 0;
 889 }
 890 EXPORT_SYMBOL(sa11xx_drv_pcmcia_remove);
 891
 892 #ifdef CONFIG_CPU_FREQ
 893
 894 /* sa1100_pcmcia_update_mecr()
 895  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 896  * When sa1100_pcmcia_notifier() decides that a MECR adjustment (due
 897  * to a core clock frequency change) is needed, this routine establishes
 898  * new BS_xx values consistent with the clock speed `clock'.
 899  */
 900 static void sa1100_pcmcia_update_mecr(unsigned int clock)
 901 {
 902         struct sa1100_pcmcia_socket *skt;
 903
 904         down(&sa1100_sockets_lock);
 905         list_for_each_entry(skt, &sa1100_sockets, node)
 906                 sa1100_pcmcia_set_mecr(skt, clock);
 907         up(&sa1100_sockets_lock);
 908 }
 909
 910 /* sa1100_pcmcia_notifier()
 911  * ^^^^^^^^^^^^^^^^^^^^^^^^
 912  * When changing the processor core clock frequency, it is necessary
 913  * to adjust the MECR timings accordingly. We've recorded the timings
 914  * requested by Card Services, so this is just a matter of finding
 915  * out what our current speed is, and then recomputing the new MECR
 916  * values.
 917  *
 918  * Returns: 0 on success, -1 on error
 919  */
 920 static int
 921 sa1100_pcmcia_notifier(struct notifier_block *nb, unsigned long val,
 922                        void *data)
 923 {
 924         struct cpufreq_freqs *freqs = data;
 925
 926         switch (val) {
 927         case CPUFREQ_PRECHANGE:
 928                 if (freqs->new > freqs->old)
 929                         sa1100_pcmcia_update_mecr(freqs->new);
 930                 break;
 931
 932         case CPUFREQ_POSTCHANGE:
 933                 if (freqs->new < freqs->old)
 934                         sa1100_pcmcia_update_mecr(freqs->new);
 935                 break;
 936         }
 937
 938         return 0;
 939 }
 940
 941 static struct notifier_block sa1100_pcmcia_notifier_block = {
 942         .notifier_call  = sa1100_pcmcia_notifier
 943 };
 944
 945 static int __init sa11xx_pcmcia_init(void)
 946 {
 947         int ret;
 948
 949         printk(KERN_INFO "SA11xx PCMCIA\n");
 950
 951         ret = cpufreq_register_notifier(&sa1100_pcmcia_notifier_block,
 952                                         CPUFREQ_TRANSITION_NOTIFIER);
 953         if (ret < 0)
 954                 printk(KERN_ERR "Unable to register CPU frequency change "
 955                         "notifier (%d)\n", ret);
 956
 957         return ret;
 958 }
 959 module_init(sa11xx_pcmcia_init);
 960
 961 static void __exit sa11xx_pcmcia_exit(void)
 962 {
 963         cpufreq_unregister_notifier(&sa1100_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
 964 }
 965
 966 module_exit(sa11xx_pcmcia_exit);
 967 #endif
 968
 969 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
 970 MODULE_DESCRIPTION("Linux PCMCIA Card Services: SA-11xx core socket driver");
 971 MODULE_LICENSE("Dual MPL/GPL");