drivers/pcmcia/soc_common.c

   1 /*======================================================================
   2
   3     Common support code for the PCMCIA control functionality of
   4     integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
   5
   6     The contents of this file are subject to the Mozilla Public
   7     License Version 1.1 (the "License"); you may not use this file
   8     except in compliance with the License. You may obtain a copy of
   9     the License at http://www.mozilla.org/MPL/
  10
  11     Software distributed under the License is distributed on an "AS
  12     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  13     implied. See the License for the specific language governing
  14     rights and limitations under the License.
  15
  16     The initial developer of the original code is John G. Dorsey
  17     <john+@cs.cmu.edu>.  Portions created by John G. Dorsey are
  18     Copyright (C) 1999 John G. Dorsey.  All Rights Reserved.
  19
  20     Alternatively, the contents of this file may be used under the
  21     terms of the GNU Public License version 2 (the "GPL"), in which
  22     case the provisions of the GPL are applicable instead of the
  23     above.  If you wish to allow the use of your version of this file
  24     only under the terms of the GPL and not to allow others to use
  25     your version of this file under the MPL, indicate your decision
  26     by deleting the provisions above and replace them with the notice
  27     and other provisions required by the GPL.  If you do not delete
  28     the provisions above, a recipient may use your version of this
  29     file under either the MPL or the GPL.
  30
  31 ======================================================================*/
  32
  33
  34 #include <linux/module.h>
  35 #include <linux/moduleparam.h>
  36 #include <linux/init.h>
  37 #include <linux/kernel.h>
  38 #include <linux/timer.h>
  39 #include <linux/mm.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/spinlock.h>
  42
  43 #include <asm/hardware.h>
  44 #include <asm/io.h>
  45 #include <asm/irq.h>
  46 #include <asm/system.h>
  47
  48 #include "soc_common.h"
  49
  50 #ifdef DEBUG
  51
  52 static int pc_debug;
  53 module_param(pc_debug, int, 0644);
  54
  55 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
  56                       int lvl, const char *fmt, ...)
  57 {
  58         va_list args;
  59         if (pc_debug > lvl) {
  60                 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
  61                 va_start(args, fmt);
  62                 printk(fmt, args);
  63                 va_end(args);
  64         }
  65 }
  66
  67 #endif
  68
  69 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
  70
  71 static unsigned short
  72 calc_speed(unsigned short *spds, int num, unsigned short dflt)
  73 {
  74         unsigned short speed = 0;
  75         int i;
  76
  77         for (i = 0; i < num; i++)
  78                 if (speed < spds[i])
  79                         speed = spds[i];
  80         if (speed == 0)
  81                 speed = dflt;
  82
  83         return speed;
  84 }
  85
  86 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
  87 {
  88         timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
  89         timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  90         timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  91 }
  92 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
  93
  94 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
  95 {
  96         struct pcmcia_state state;
  97         unsigned int stat;
  98
  99         memset(&state, 0, sizeof(struct pcmcia_state));
 100
 101         skt->ops->socket_state(skt, &state);
 102
 103         stat = state.detect  ? SS_DETECT : 0;
 104         stat |= state.ready  ? SS_READY  : 0;
 105         stat |= state.wrprot ? SS_WRPROT : 0;
 106         stat |= state.vs_3v  ? SS_3VCARD : 0;
 107         stat |= state.vs_Xv  ? SS_XVCARD : 0;
 108
 109         /* The power status of individual sockets is not available
 110          * explicitly from the hardware, so we just remember the state
 111          * and regurgitate it upon request:
 112          */
 113         stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
 114
 115         if (skt->cs_state.flags & SS_IOCARD)
 116                 stat |= state.bvd1 ? SS_STSCHG : 0;
 117         else {
 118                 if (state.bvd1 == 0)
 119                         stat |= SS_BATDEAD;
 120                 else if (state.bvd2 == 0)
 121                         stat |= SS_BATWARN;
 122         }
 123         return stat;
 124 }
 125
 126 /*
 127  * soc_common_pcmcia_config_skt
 128  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 129  *
 130  * Convert PCMCIA socket state to our socket configure structure.
 131  */
 132 static int
 133 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
 134 {
 135         int ret;
 136
 137         ret = skt->ops->configure_socket(skt, state);
 138         if (ret == 0) {
 139                 /*
 140                  * This really needs a better solution.  The IRQ
 141                  * may or may not be claimed by the driver.
 142                  */
 143                 if (skt->irq_state != 1 && state->io_irq) {
 144                         skt->irq_state = 1;
 145                         set_irq_type(skt->irq, IRQT_FALLING);
 146                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
 147                         skt->irq_state = 0;
 148                         set_irq_type(skt->irq, IRQT_NOEDGE);
 149                 }
 150
 151                 skt->cs_state = *state;
 152         }
 153
 154         if (ret < 0)
 155                 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
 156                        "socket %d\n", skt->nr);
 157
 158         return ret;
 159 }
 160
 161 /* soc_common_pcmcia_sock_init()
 162  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 163  *
 164  * (Re-)Initialise the socket, turning on status interrupts
 165  * and PCMCIA bus.  This must wait for power to stabilise
 166  * so that the card status signals report correctly.
 167  *
 168  * Returns: 0
 169  */
 170 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
 171 {
 172         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 173
 174         debug(skt, 2, "initializing socket\n");
 175
 176         skt->ops->socket_init(skt);
 177         return 0;
 178 }
 179
 180
 181 /*
 182  * soc_common_pcmcia_suspend()
 183  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 184  *
 185  * Remove power on the socket, disable IRQs from the card.
 186  * Turn off status interrupts, and disable the PCMCIA bus.
 187  *
 188  * Returns: 0
 189  */
 190 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
 191 {
 192         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 193         int ret;
 194
 195         debug(skt, 2, "suspending socket\n");
 196
 197         ret = soc_common_pcmcia_config_skt(skt, &dead_socket);
 198         if (ret == 0)
 199                 skt->ops->socket_suspend(skt);
 200
 201         return ret;
 202 }
 203
 204 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
 205
 206 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
 207 {
 208         unsigned int events;
 209
 210         debug(skt, 4, "entering PCMCIA monitoring thread\n");
 211
 212         do {
 213                 unsigned int status;
 214                 unsigned long flags;
 215
 216                 status = soc_common_pcmcia_skt_state(skt);
 217
 218                 spin_lock_irqsave(&status_lock, flags);
 219                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
 220                 skt->status = status;
 221                 spin_unlock_irqrestore(&status_lock, flags);
 222
 223                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
 224                         events == 0         ? "<NONE>"   : "",
 225                         events & SS_DETECT  ? "DETECT "  : "",
 226                         events & SS_READY   ? "READY "   : "",
 227                         events & SS_BATDEAD ? "BATDEAD " : "",
 228                         events & SS_BATWARN ? "BATWARN " : "",
 229                         events & SS_STSCHG  ? "STSCHG "  : "");
 230
 231                 if (events)
 232                         pcmcia_parse_events(&skt->socket, events);
 233         } while (events);
 234 }
 235
 236 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
 237 static void soc_common_pcmcia_poll_event(unsigned long dummy)
 238 {
 239         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
 240         debug(skt, 4, "polling for events\n");
 241
 242         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
 243
 244         soc_common_check_status(skt);
 245 }
 246
 247
 248 /*
 249  * Service routine for socket driver interrupts (requested by the
 250  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
 251  * The actual interrupt-servicing work is performed by
 252  * soc_common_pcmcia_thread(), largely because the Card Services event-
 253  * handling code performs scheduling operations which cannot be
 254  * executed from within an interrupt context.
 255  */
 256 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
 257 {
 258         struct soc_pcmcia_socket *skt = dev;
 259
 260         debug(skt, 3, "servicing IRQ %d\n", irq);
 261
 262         soc_common_check_status(skt);
 263
 264         return IRQ_HANDLED;
 265 }
 266
 267
 268 /*
 269  *  Implements the get_status() operation for the in-kernel PCMCIA
 270  * service (formerly SS_GetStatus in Card Services). Essentially just
 271  * fills in bits in `status' according to internal driver state or
 272  * the value of the voltage detect chipselect register.
 273  *
 274  * As a debugging note, during card startup, the PCMCIA core issues
 275  * three set_socket() commands in a row the first with RESET deasserted,
 276  * the second with RESET asserted, and the last with RESET deasserted
 277  * again. Following the third set_socket(), a get_status() command will
 278  * be issued. The kernel is looking for the SS_READY flag (see
 279  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
 280  *
 281  * Returns: 0
 282  */
 283 static int
 284 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
 285 {
 286         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 287
 288         skt->status = soc_common_pcmcia_skt_state(skt);
 289         *status = skt->status;
 290
 291         return 0;
 292 }
 293
 294
 295 /*
 296  * Implements the get_socket() operation for the in-kernel PCMCIA
 297  * service (formerly SS_GetSocket in Card Services). Not a very
 298  * exciting routine.
 299  *
 300  * Returns: 0
 301  */
 302 static int
 303 soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
 304 {
 305         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 306
 307         debug(skt, 2, "\n");
 308
 309         *state = skt->cs_state;
 310
 311         return 0;
 312 }
 313
 314 /*
 315  * Implements the set_socket() operation for the in-kernel PCMCIA
 316  * service (formerly SS_SetSocket in Card Services). We more or
 317  * less punt all of this work and let the kernel handle the details
 318  * of power configuration, reset, &c. We also record the value of
 319  * `state' in order to regurgitate it to the PCMCIA core later.
 320  *
 321  * Returns: 0
 322  */
 323 static int
 324 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 325 {
 326         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 327
 328         debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
 329                         (state->csc_mask==0)?"<NONE> ":"",
 330                         (state->csc_mask&SS_DETECT)?"DETECT ":"",
 331                         (state->csc_mask&SS_READY)?"READY ":"",
 332                         (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
 333                         (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
 334                         (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
 335                         (state->flags==0)?"<NONE> ":"",
 336                         (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
 337                         (state->flags&SS_IOCARD)?"IOCARD ":"",
 338                         (state->flags&SS_RESET)?"RESET ":"",
 339                         (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
 340                         (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
 341                         state->Vcc, state->Vpp, state->io_irq);
 342
 343         return soc_common_pcmcia_config_skt(skt, state);
 344 }
 345
 346
 347 /*
 348  * Implements the set_io_map() operation for the in-kernel PCMCIA
 349  * service (formerly SS_SetIOMap in Card Services). We configure
 350  * the map speed as requested, but override the address ranges
 351  * supplied by Card Services.
 352  *
 353  * Returns: 0 on success, -1 on error
 354  */
 355 static int
 356 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
 357 {
 358         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 359         unsigned short speed = map->speed;
 360
 361         debug(skt, 2, "map %u  speed %u start 0x%08x stop 0x%08x\n",
 362                 map->map, map->speed, map->start, map->stop);
 363         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 364                 (map->flags==0)?"<NONE>":"",
 365                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 366                 (map->flags&MAP_16BIT)?"16BIT ":"",
 367                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 368                 (map->flags&MAP_0WS)?"0WS ":"",
 369                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 370                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
 371                 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
 372
 373         if (map->map >= MAX_IO_WIN) {
 374                 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
 375                        map->map);
 376                 return -1;
 377         }
 378
 379         if (map->flags & MAP_ACTIVE) {
 380                 if (speed == 0)
 381                         speed = SOC_PCMCIA_IO_ACCESS;
 382         } else {
 383                 speed = 0;
 384         }
 385
 386         skt->spd_io[map->map] = speed;
 387         skt->ops->set_timing(skt);
 388
 389         if (map->stop == 1)
 390                 map->stop = PAGE_SIZE-1;
 391
 392         map->stop -= map->start;
 393         map->stop += (unsigned long)skt->virt_io;
 394         map->start = (unsigned long)skt->virt_io;
 395
 396         return 0;
 397 }
 398
 399
 400 /*
 401  * Implements the set_mem_map() operation for the in-kernel PCMCIA
 402  * service (formerly SS_SetMemMap in Card Services). We configure
 403  * the map speed as requested, but override the address ranges
 404  * supplied by Card Services.
 405  *
 406  * Returns: 0 on success, -1 on error
 407  */
 408 static int
 409 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
 410 {
 411         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
 412         struct resource *res;
 413         unsigned short speed = map->speed;
 414
 415         debug(skt, 2, "map %u speed %u card_start %08x\n",
 416                 map->map, map->speed, map->card_start);
 417         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
 418                 (map->flags==0)?"<NONE>":"",
 419                 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
 420                 (map->flags&MAP_16BIT)?"16BIT ":"",
 421                 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
 422                 (map->flags&MAP_0WS)?"0WS ":"",
 423                 (map->flags&MAP_WRPROT)?"WRPROT ":"",
 424                 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
 425                 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
 426
 427         if (map->map >= MAX_WIN)
 428                 return -EINVAL;
 429
 430         if (map->flags & MAP_ACTIVE) {
 431                 if (speed == 0)
 432                         speed = 300;
 433         } else {
 434                 speed = 0;
 435         }
 436
 437         if (map->flags & MAP_ATTRIB) {
 438                 res = &skt->res_attr;
 439                 skt->spd_attr[map->map] = speed;
 440                 skt->spd_mem[map->map] = 0;
 441         } else {
 442                 res = &skt->res_mem;
 443                 skt->spd_attr[map->map] = 0;
 444                 skt->spd_mem[map->map] = speed;
 445         }
 446
 447         skt->ops->set_timing(skt);
 448
 449         map->sys_stop -= map->sys_start;
 450         map->sys_stop += res->start + map->card_start;
 451         map->sys_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 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
 618 {
 619         struct skt_dev_info *sinfo;
 620         int ret, i;
 621
 622         down(&soc_pcmcia_sockets_lock);
 623
 624         sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
 625         if (!sinfo) {
 626                 ret = -ENOMEM;
 627                 goto out;
 628         }
 629
 630         memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
 631         sinfo->nskt = nr;
 632
 633         /*
 634          * Initialise the per-socket structure.
 635          */
 636         for (i = 0; i < nr; i++) {
 637                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 638
 639                 skt->socket.ops = &soc_common_pcmcia_operations;
 640                 skt->socket.owner = ops->owner;
 641                 skt->socket.dev.dev = dev;
 642
 643                 init_timer(&skt->poll_timer);
 644                 skt->poll_timer.function = soc_common_pcmcia_poll_event;
 645                 skt->poll_timer.data = (unsigned long)skt;
 646                 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
 647
 648                 skt->nr         = first + i;
 649                 skt->irq        = NO_IRQ;
 650                 skt->dev        = dev;
 651                 skt->ops        = ops;
 652
 653                 skt->res_skt.start      = _PCMCIA(skt->nr);
 654                 skt->res_skt.end        = _PCMCIA(skt->nr) + PCMCIASp - 1;
 655                 skt->res_skt.name       = skt_names[skt->nr];
 656                 skt->res_skt.flags      = IORESOURCE_MEM;
 657
 658                 ret = request_resource(&iomem_resource, &skt->res_skt);
 659                 if (ret)
 660                         goto out_err_1;
 661
 662                 skt->res_io.start       = _PCMCIAIO(skt->nr);
 663                 skt->res_io.end         = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
 664                 skt->res_io.name        = "io";
 665                 skt->res_io.flags       = IORESOURCE_MEM | IORESOURCE_BUSY;
 666
 667                 ret = request_resource(&skt->res_skt, &skt->res_io);
 668                 if (ret)
 669                         goto out_err_2;
 670
 671                 skt->res_mem.start      = _PCMCIAMem(skt->nr);
 672                 skt->res_mem.end        = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
 673                 skt->res_mem.name       = "memory";
 674                 skt->res_mem.flags      = IORESOURCE_MEM;
 675
 676                 ret = request_resource(&skt->res_skt, &skt->res_mem);
 677                 if (ret)
 678                         goto out_err_3;
 679
 680                 skt->res_attr.start     = _PCMCIAAttr(skt->nr);
 681                 skt->res_attr.end       = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
 682                 skt->res_attr.name      = "attribute";
 683                 skt->res_attr.flags     = IORESOURCE_MEM;
 684
 685                 ret = request_resource(&skt->res_skt, &skt->res_attr);
 686                 if (ret)
 687                         goto out_err_4;
 688
 689                 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
 690                 if (skt->virt_io == NULL) {
 691                         ret = -ENOMEM;
 692                         goto out_err_5;
 693                 }
 694
 695                 list_add(&skt->node, &soc_pcmcia_sockets);
 696
 697                 /*
 698                  * We initialize default socket timing here, because
 699                  * we are not guaranteed to see a SetIOMap operation at
 700                  * runtime.
 701                  */
 702                 ops->set_timing(skt);
 703
 704                 ret = ops->hw_init(skt);
 705                 if (ret)
 706                         goto out_err_6;
 707
 708                 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
 709                 skt->socket.irq_mask = 0;
 710                 skt->socket.map_size = PAGE_SIZE;
 711                 skt->socket.pci_irq = skt->irq;
 712                 skt->socket.io_offset = (unsigned long)skt->virt_io;
 713
 714                 skt->status = soc_common_pcmcia_skt_state(skt);
 715
 716                 ret = pcmcia_register_socket(&skt->socket);
 717                 if (ret)
 718                         goto out_err_7;
 719
 720                 WARN_ON(skt->socket.sock != i);
 721
 722                 add_timer(&skt->poll_timer);
 723
 724                 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
 725         }
 726
 727         dev_set_drvdata(dev, sinfo);
 728         ret = 0;
 729         goto out;
 730
 731         do {
 732                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 733
 734                 del_timer_sync(&skt->poll_timer);
 735                 pcmcia_unregister_socket(&skt->socket);
 736
 737  out_err_7:
 738                 flush_scheduled_work();
 739
 740                 ops->hw_shutdown(skt);
 741  out_err_6:
 742                 list_del(&skt->node);
 743                 iounmap(skt->virt_io);
 744  out_err_5:
 745                 release_resource(&skt->res_attr);
 746  out_err_4:
 747                 release_resource(&skt->res_mem);
 748  out_err_3:
 749                 release_resource(&skt->res_io);
 750  out_err_2:
 751                 release_resource(&skt->res_skt);
 752  out_err_1:
 753                 i--;
 754         } while (i > 0);
 755
 756         kfree(sinfo);
 757
 758  out:
 759         up(&soc_pcmcia_sockets_lock);
 760         return ret;
 761 }
 762
 763 int soc_common_drv_pcmcia_remove(struct device *dev)
 764 {
 765         struct skt_dev_info *sinfo = dev_get_drvdata(dev);
 766         int i;
 767
 768         dev_set_drvdata(dev, NULL);
 769
 770         down(&soc_pcmcia_sockets_lock);
 771         for (i = 0; i < sinfo->nskt; i++) {
 772                 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
 773
 774                 del_timer_sync(&skt->poll_timer);
 775
 776                 pcmcia_unregister_socket(&skt->socket);
 777
 778                 flush_scheduled_work();
 779
 780                 skt->ops->hw_shutdown(skt);
 781
 782                 soc_common_pcmcia_config_skt(skt, &dead_socket);
 783
 784                 list_del(&skt->node);
 785                 iounmap(skt->virt_io);
 786                 skt->virt_io = NULL;
 787                 release_resource(&skt->res_attr);
 788                 release_resource(&skt->res_mem);
 789                 release_resource(&skt->res_io);
 790                 release_resource(&skt->res_skt);
 791         }
 792         up(&soc_pcmcia_sockets_lock);
 793
 794         kfree(sinfo);
 795
 796         return 0;
 797 }