drivers/pcmcia/soc_common.c

0001 /*======================================================================
0002
0003     Common support code for the PCMCIA control functionality of
0004     integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
0005
0006     The contents of this file are subject to the Mozilla Public
0007     License Version 1.1 (the "License"); you may not use this file
0008     except in compliance with the License. You may obtain a copy of
0009     the License at http://www.mozilla.org/MPL/
0010
0011     Software distributed under the License is distributed on an "AS
0012     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
0013     implied. See the License for the specific language governing
0014     rights and limitations under the License.
0015
0016     The initial developer of the original code is John G. Dorsey
0017     <john+@cs.cmu.edu>.  Portions created by John G. Dorsey are
0018     Copyright (C) 1999 John G. Dorsey.  All Rights Reserved.
0019
0020     Alternatively, the contents of this file may be used under the
0021     terms of the GNU Public License version 2 (the "GPL"), in which
0022     case the provisions of the GPL are applicable instead of the
0023     above.  If you wish to allow the use of your version of this file
0024     only under the terms of the GPL and not to allow others to use
0025     your version of this file under the MPL, indicate your decision
0026     by deleting the provisions above and replace them with the notice
0027     and other provisions required by the GPL.  If you do not delete
0028     the provisions above, a recipient may use your version of this
0029     file under either the MPL or the GPL.
0030
0031 ======================================================================*/
0032
0033
0034 #include <linux/cpufreq.h>
0035 #include <linux/gpio.h>
0036 #include <linux/gpio/consumer.h>
0037 #include <linux/init.h>
0038 #include <linux/interrupt.h>
0039 #include <linux/io.h>
0040 #include <linux/irq.h>
0041 #include <linux/kernel.h>
0042 #include <linux/mm.h>
0043 #include <linux/module.h>
0044 #include <linux/moduleparam.h>
0045 #include <linux/mutex.h>
0046 #include <linux/regulator/consumer.h>
0047 #include <linux/spinlock.h>
0048 #include <linux/timer.h>
0049 #include <linux/pci.h>
0050
0051 #include "soc_common.h"
0052
0053 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev);
0054
0055 #ifdef CONFIG_PCMCIA_DEBUG
0056
0057 static int pc_debug;
0058 module_param(pc_debug, int, 0644);
0059
0060 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
0061               int lvl, const char *fmt, ...)
0062 {
0063     struct va_format vaf;
0064     va_list args;
0065     if (pc_debug > lvl) {
0066         va_start(args, fmt);
0067
0068         vaf.fmt = fmt;
0069         vaf.va = &args;
0070
0071         printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf);
0072
0073         va_end(args);
0074     }
0075 }
0076 EXPORT_SYMBOL(soc_pcmcia_debug);
0077
0078 #endif
0079
0080 #define to_soc_pcmcia_socket(x) \
0081     container_of(x, struct soc_pcmcia_socket, socket)
0082
0083 int soc_pcmcia_regulator_set(struct soc_pcmcia_socket *skt,
0084     struct soc_pcmcia_regulator *r, int v)
0085 {
0086     bool on;
0087     int ret;
0088
0089     if (!r->reg)
0090         return 0;
0091
0092     on = v != 0;
0093     if (r->on == on)
0094         return 0;
0095
0096     if (on) {
0097         ret = regulator_set_voltage(r->reg, v * 100000, v * 100000);
0098         if (ret) {
0099             int vout = regulator_get_voltage(r->reg) / 100000;
0100
0101             dev_warn(&skt->socket.dev,
0102                  "CS requested %s=%u.%uV, applying %u.%uV\n",
0103                  r == &skt->vcc ? "Vcc" : "Vpp",
0104                  v / 10, v % 10, vout / 10, vout % 10);
0105         }
0106
0107         ret = regulator_enable(r->reg);
0108     } else {
0109         ret = regulator_disable(r->reg);
0110     }
0111     if (ret == 0)
0112         r->on = on;
0113
0114     return ret;
0115 }
0116 EXPORT_SYMBOL_GPL(soc_pcmcia_regulator_set);
0117
0118 static unsigned short
0119 calc_speed(unsigned short *spds, int num, unsigned short dflt)
0120 {
0121     unsigned short speed = 0;
0122     int i;
0123
0124     for (i = 0; i < num; i++)
0125         if (speed < spds[i])
0126             speed = spds[i];
0127     if (speed == 0)
0128         speed = dflt;
0129
0130     return speed;
0131 }
0132
0133 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
0134     struct soc_pcmcia_timing *timing)
0135 {
0136     timing->io =
0137         calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
0138     timing->mem =
0139         calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
0140     timing->attr =
0141         calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
0142 }
0143 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
0144
0145 static void __soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt,
0146     unsigned int nr)
0147 {
0148     unsigned int i;
0149
0150     for (i = 0; i < nr; i++)
0151         if (skt->stat[i].irq)
0152             free_irq(skt->stat[i].irq, skt);
0153
0154     if (skt->ops->hw_shutdown)
0155         skt->ops->hw_shutdown(skt);
0156
0157     clk_disable_unprepare(skt->clk);
0158 }
0159
0160 static void soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
0161 {
0162     __soc_pcmcia_hw_shutdown(skt, ARRAY_SIZE(skt->stat));
0163 }
0164
0165 int soc_pcmcia_request_gpiods(struct soc_pcmcia_socket *skt)
0166 {
0167     struct device *dev = skt->socket.dev.parent;
0168     struct gpio_desc *desc;
0169     int i;
0170
0171     for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
0172         if (!skt->stat[i].name)
0173             continue;
0174
0175         desc = devm_gpiod_get(dev, skt->stat[i].name, GPIOD_IN);
0176         if (IS_ERR(desc)) {
0177             dev_err(dev, "Failed to get GPIO for %s: %ld\n",
0178                 skt->stat[i].name, PTR_ERR(desc));
0179             return PTR_ERR(desc);
0180         }
0181
0182         skt->stat[i].desc = desc;
0183     }
0184
0185     return 0;
0186 }
0187 EXPORT_SYMBOL_GPL(soc_pcmcia_request_gpiods);
0188
0189 static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
0190 {
0191     int ret = 0, i;
0192
0193     ret = clk_prepare_enable(skt->clk);
0194     if (ret)
0195         return ret;
0196
0197     if (skt->ops->hw_init) {
0198         ret = skt->ops->hw_init(skt);
0199         if (ret) {
0200             clk_disable_unprepare(skt->clk);
0201             return ret;
0202         }
0203     }
0204
0205     for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
0206         if (gpio_is_valid(skt->stat[i].gpio)) {
0207             unsigned long flags = GPIOF_IN;
0208
0209             /* CD is active low by default */
0210             if (i == SOC_STAT_CD)
0211                 flags |= GPIOF_ACTIVE_LOW;
0212
0213             ret = devm_gpio_request_one(skt->socket.dev.parent,
0214                             skt->stat[i].gpio, flags,
0215                             skt->stat[i].name);
0216             if (ret) {
0217                 __soc_pcmcia_hw_shutdown(skt, i);
0218                 return ret;
0219             }
0220
0221             skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio);
0222         }
0223
0224         if (i < SOC_STAT_VS1 && skt->stat[i].desc) {
0225             int irq = gpiod_to_irq(skt->stat[i].desc);
0226
0227             if (irq > 0) {
0228                 if (i == SOC_STAT_RDY)
0229                     skt->socket.pci_irq = irq;
0230                 else
0231                     skt->stat[i].irq = irq;
0232             }
0233         }
0234
0235         if (skt->stat[i].irq) {
0236             ret = request_irq(skt->stat[i].irq,
0237                       soc_common_pcmcia_interrupt,
0238                       IRQF_TRIGGER_NONE,
0239                       skt->stat[i].name, skt);
0240             if (ret) {
0241                 __soc_pcmcia_hw_shutdown(skt, i);
0242                 return ret;
0243             }
0244         }
0245     }
0246
0247     return ret;
0248 }
0249
0250 static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt)
0251 {
0252     int i;
0253
0254     for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
0255         if (skt->stat[i].irq) {
0256             irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING);
0257             irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH);
0258         }
0259 }
0260
0261 static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt)
0262 {
0263     int i;
0264
0265     for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
0266         if (skt->stat[i].irq)
0267             irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE);
0268 }
0269
0270 /*
0271  * The CF 3.0 specification says that cards tie VS1 to ground and leave
0272  * VS2 open.  Many implementations do not wire up the VS signals, so we
0273  * provide hard-coded values as per the CF 3.0 spec.
0274  */
0275 void soc_common_cf_socket_state(struct soc_pcmcia_socket *skt,
0276     struct pcmcia_state *state)
0277 {
0278     state->vs_3v = 1;
0279 }
0280 EXPORT_SYMBOL_GPL(soc_common_cf_socket_state);
0281
0282 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
0283 {
0284     struct pcmcia_state state;
0285     unsigned int stat;
0286
0287     memset(&state, 0, sizeof(struct pcmcia_state));
0288
0289     /* Make battery voltage state report 'good' */
0290     state.bvd1 = 1;
0291     state.bvd2 = 1;
0292
0293     if (skt->stat[SOC_STAT_CD].desc)
0294         state.detect = !!gpiod_get_value(skt->stat[SOC_STAT_CD].desc);
0295     if (skt->stat[SOC_STAT_RDY].desc)
0296         state.ready = !!gpiod_get_value(skt->stat[SOC_STAT_RDY].desc);
0297     if (skt->stat[SOC_STAT_BVD1].desc)
0298         state.bvd1 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD1].desc);
0299     if (skt->stat[SOC_STAT_BVD2].desc)
0300         state.bvd2 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD2].desc);
0301     if (skt->stat[SOC_STAT_VS1].desc)
0302         state.vs_3v = !!gpiod_get_value(skt->stat[SOC_STAT_VS1].desc);
0303     if (skt->stat[SOC_STAT_VS2].desc)
0304         state.vs_Xv = !!gpiod_get_value(skt->stat[SOC_STAT_VS2].desc);
0305
0306     skt->ops->socket_state(skt, &state);
0307
0308     stat = state.detect  ? SS_DETECT : 0;
0309     stat |= state.ready  ? SS_READY  : 0;
0310     stat |= state.wrprot ? SS_WRPROT : 0;
0311     stat |= state.vs_3v  ? SS_3VCARD : 0;
0312     stat |= state.vs_Xv  ? SS_XVCARD : 0;
0313
0314     /* The power status of individual sockets is not available
0315      * explicitly from the hardware, so we just remember the state
0316      * and regurgitate it upon request:
0317      */
0318     stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
0319
0320     if (skt->cs_state.flags & SS_IOCARD)
0321         stat |= state.bvd1 ? 0 : SS_STSCHG;
0322     else {
0323         if (state.bvd1 == 0)
0324             stat |= SS_BATDEAD;
0325         else if (state.bvd2 == 0)
0326             stat |= SS_BATWARN;
0327     }
0328     return stat;
0329 }
0330
0331 /*
0332  * soc_common_pcmcia_config_skt
0333  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
0334  *
0335  * Convert PCMCIA socket state to our socket configure structure.
0336  */
0337 static int soc_common_pcmcia_config_skt(
0338     struct soc_pcmcia_socket *skt, socket_state_t *state)
0339 {
0340     int ret;
0341
0342     ret = skt->ops->configure_socket(skt, state);
0343     if (ret < 0) {
0344         pr_err("soc_common_pcmcia: unable to configure socket %d\n",
0345                skt->nr);
0346         /* restore the previous state */
0347         WARN_ON(skt->ops->configure_socket(skt, &skt->cs_state));
0348         return ret;
0349     }
0350
0351     if (ret == 0) {
0352         struct gpio_desc *descs[2];
0353         DECLARE_BITMAP(values, 2);
0354         int n = 0;
0355
0356         if (skt->gpio_reset) {
0357             descs[n] = skt->gpio_reset;
0358             __assign_bit(n++, values, state->flags & SS_RESET);
0359         }
0360         if (skt->gpio_bus_enable) {
0361             descs[n] = skt->gpio_bus_enable;
0362             __assign_bit(n++, values, state->flags & SS_OUTPUT_ENA);
0363         }
0364
0365         if (n)
0366             gpiod_set_array_value_cansleep(n, descs, NULL, values);
0367
0368         /*
0369          * This really needs a better solution.  The IRQ
0370          * may or may not be claimed by the driver.
0371          */
0372         if (skt->irq_state != 1 && state->io_irq) {
0373             skt->irq_state = 1;
0374             irq_set_irq_type(skt->socket.pci_irq,
0375                      IRQ_TYPE_EDGE_FALLING);
0376         } else if (skt->irq_state == 1 && state->io_irq == 0) {
0377             skt->irq_state = 0;
0378             irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
0379         }
0380
0381         skt->cs_state = *state;
0382     }
0383
0384     return ret;
0385 }
0386
0387 /* soc_common_pcmcia_sock_init()
0388  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
0389  *
0390  * (Re-)Initialise the socket, turning on status interrupts
0391  * and PCMCIA bus.  This must wait for power to stabilise
0392  * so that the card status signals report correctly.
0393  *
0394  * Returns: 0
0395  */
0396 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
0397 {
0398     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0399
0400     debug(skt, 2, "initializing socket\n");
0401     if (skt->ops->socket_init)
0402         skt->ops->socket_init(skt);
0403     soc_pcmcia_hw_enable(skt);
0404     return 0;
0405 }
0406
0407
0408 /*
0409  * soc_common_pcmcia_suspend()
0410  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
0411  *
0412  * Remove power on the socket, disable IRQs from the card.
0413  * Turn off status interrupts, and disable the PCMCIA bus.
0414  *
0415  * Returns: 0
0416  */
0417 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
0418 {
0419     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0420
0421     debug(skt, 2, "suspending socket\n");
0422
0423     soc_pcmcia_hw_disable(skt);
0424     if (skt->ops->socket_suspend)
0425         skt->ops->socket_suspend(skt);
0426
0427     return 0;
0428 }
0429
0430 static DEFINE_SPINLOCK(status_lock);
0431
0432 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
0433 {
0434     unsigned int events;
0435
0436     debug(skt, 4, "entering PCMCIA monitoring thread\n");
0437
0438     do {
0439         unsigned int status;
0440         unsigned long flags;
0441
0442         status = soc_common_pcmcia_skt_state(skt);
0443
0444         spin_lock_irqsave(&status_lock, flags);
0445         events = (status ^ skt->status) & skt->cs_state.csc_mask;
0446         skt->status = status;
0447         spin_unlock_irqrestore(&status_lock, flags);
0448
0449         debug(skt, 4, "events: %s%s%s%s%s%s\n",
0450             events == 0         ? "<NONE>"   : "",
0451             events & SS_DETECT  ? "DETECT "  : "",
0452             events & SS_READY   ? "READY "   : "",
0453             events & SS_BATDEAD ? "BATDEAD " : "",
0454             events & SS_BATWARN ? "BATWARN " : "",
0455             events & SS_STSCHG  ? "STSCHG "  : "");
0456
0457         if (events)
0458             pcmcia_parse_events(&skt->socket, events);
0459     } while (events);
0460 }
0461
0462 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
0463 static void soc_common_pcmcia_poll_event(struct timer_list *t)
0464 {
0465     struct soc_pcmcia_socket *skt = from_timer(skt, t, poll_timer);
0466     debug(skt, 4, "polling for events\n");
0467
0468     mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
0469
0470     soc_common_check_status(skt);
0471 }
0472
0473
0474 /*
0475  * Service routine for socket driver interrupts (requested by the
0476  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
0477  * The actual interrupt-servicing work is performed by
0478  * soc_common_pcmcia_thread(), largely because the Card Services event-
0479  * handling code performs scheduling operations which cannot be
0480  * executed from within an interrupt context.
0481  */
0482 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
0483 {
0484     struct soc_pcmcia_socket *skt = dev;
0485
0486     debug(skt, 3, "servicing IRQ %d\n", irq);
0487
0488     soc_common_check_status(skt);
0489
0490     return IRQ_HANDLED;
0491 }
0492
0493
0494 /*
0495  *  Implements the get_status() operation for the in-kernel PCMCIA
0496  * service (formerly SS_GetStatus in Card Services). Essentially just
0497  * fills in bits in `status' according to internal driver state or
0498  * the value of the voltage detect chipselect register.
0499  *
0500  * As a debugging note, during card startup, the PCMCIA core issues
0501  * three set_socket() commands in a row the first with RESET deasserted,
0502  * the second with RESET asserted, and the last with RESET deasserted
0503  * again. Following the third set_socket(), a get_status() command will
0504  * be issued. The kernel is looking for the SS_READY flag (see
0505  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
0506  *
0507  * Returns: 0
0508  */
0509 static int
0510 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
0511 {
0512     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0513
0514     skt->status = soc_common_pcmcia_skt_state(skt);
0515     *status = skt->status;
0516
0517     return 0;
0518 }
0519
0520
0521 /*
0522  * Implements the set_socket() operation for the in-kernel PCMCIA
0523  * service (formerly SS_SetSocket in Card Services). We more or
0524  * less punt all of this work and let the kernel handle the details
0525  * of power configuration, reset, &c. We also record the value of
0526  * `state' in order to regurgitate it to the PCMCIA core later.
0527  */
0528 static int soc_common_pcmcia_set_socket(
0529     struct pcmcia_socket *sock, socket_state_t *state)
0530 {
0531     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0532
0533     debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
0534             (state->csc_mask == 0)      ? "<NONE> " :   "",
0535             (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
0536             (state->csc_mask & SS_READY)    ? "READY " :    "",
0537             (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
0538             (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
0539             (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
0540             (state->flags == 0)     ? "<NONE> " :   "",
0541             (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
0542             (state->flags & SS_IOCARD)  ? "IOCARD " :   "",
0543             (state->flags & SS_RESET)   ? "RESET " :    "",
0544             (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
0545             (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
0546             state->Vcc, state->Vpp, state->io_irq);
0547
0548     return soc_common_pcmcia_config_skt(skt, state);
0549 }
0550
0551
0552 /*
0553  * Implements the set_io_map() operation for the in-kernel PCMCIA
0554  * service (formerly SS_SetIOMap in Card Services). We configure
0555  * the map speed as requested, but override the address ranges
0556  * supplied by Card Services.
0557  *
0558  * Returns: 0 on success, -1 on error
0559  */
0560 static int soc_common_pcmcia_set_io_map(
0561     struct pcmcia_socket *sock, struct pccard_io_map *map)
0562 {
0563     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0564     unsigned short speed = map->speed;
0565
0566     debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
0567         map->map, map->speed, (unsigned long long)map->start,
0568         (unsigned long long)map->stop);
0569     debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
0570         (map->flags == 0)       ? "<NONE>"  : "",
0571         (map->flags & MAP_ACTIVE)   ? "ACTIVE " : "",
0572         (map->flags & MAP_16BIT)    ? "16BIT "  : "",
0573         (map->flags & MAP_AUTOSZ)   ? "AUTOSZ " : "",
0574         (map->flags & MAP_0WS)      ? "0WS "    : "",
0575         (map->flags & MAP_WRPROT)   ? "WRPROT " : "",
0576         (map->flags & MAP_USE_WAIT) ? "USE_WAIT "   : "",
0577         (map->flags & MAP_PREFETCH) ? "PREFETCH "   : "");
0578
0579     if (map->map >= MAX_IO_WIN) {
0580         printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
0581                map->map);
0582         return -1;
0583     }
0584
0585     if (map->flags & MAP_ACTIVE) {
0586         if (speed == 0)
0587             speed = SOC_PCMCIA_IO_ACCESS;
0588     } else {
0589         speed = 0;
0590     }
0591
0592     skt->spd_io[map->map] = speed;
0593     skt->ops->set_timing(skt);
0594
0595     if (map->stop == 1)
0596         map->stop = PAGE_SIZE-1;
0597
0598     map->stop -= map->start;
0599     map->stop += skt->socket.io_offset;
0600     map->start = skt->socket.io_offset;
0601
0602     return 0;
0603 }
0604
0605
0606 /*
0607  * Implements the set_mem_map() operation for the in-kernel PCMCIA
0608  * service (formerly SS_SetMemMap in Card Services). We configure
0609  * the map speed as requested, but override the address ranges
0610  * supplied by Card Services.
0611  *
0612  * Returns: 0 on success, -ERRNO on error
0613  */
0614 static int soc_common_pcmcia_set_mem_map(
0615     struct pcmcia_socket *sock, struct pccard_mem_map *map)
0616 {
0617     struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
0618     struct resource *res;
0619     unsigned short speed = map->speed;
0620
0621     debug(skt, 2, "map %u speed %u card_start %08x\n",
0622         map->map, map->speed, map->card_start);
0623     debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
0624         (map->flags == 0)       ? "<NONE>"  : "",
0625         (map->flags & MAP_ACTIVE)   ? "ACTIVE " : "",
0626         (map->flags & MAP_16BIT)    ? "16BIT "  : "",
0627         (map->flags & MAP_AUTOSZ)   ? "AUTOSZ " : "",
0628         (map->flags & MAP_0WS)      ? "0WS "    : "",
0629         (map->flags & MAP_WRPROT)   ? "WRPROT " : "",
0630         (map->flags & MAP_ATTRIB)   ? "ATTRIB " : "",
0631         (map->flags & MAP_USE_WAIT) ? "USE_WAIT "   : "");
0632
0633     if (map->map >= MAX_WIN)
0634         return -EINVAL;
0635
0636     if (map->flags & MAP_ACTIVE) {
0637         if (speed == 0)
0638             speed = 300;
0639     } else {
0640         speed = 0;
0641     }
0642
0643     if (map->flags & MAP_ATTRIB) {
0644         res = &skt->res_attr;
0645         skt->spd_attr[map->map] = speed;
0646         skt->spd_mem[map->map] = 0;
0647     } else {
0648         res = &skt->res_mem;
0649         skt->spd_attr[map->map] = 0;
0650         skt->spd_mem[map->map] = speed;
0651     }
0652
0653     skt->ops->set_timing(skt);
0654
0655     map->static_start = res->start + map->card_start;
0656
0657     return 0;
0658 }
0659
0660 struct bittbl {
0661     unsigned int mask;
0662     const char *name;
0663 };
0664
0665 static struct bittbl status_bits[] = {
0666     { SS_WRPROT,        "SS_WRPROT" },
0667     { SS_BATDEAD,       "SS_BATDEAD"    },
0668     { SS_BATWARN,       "SS_BATWARN"    },
0669     { SS_READY,     "SS_READY"  },
0670     { SS_DETECT,        "SS_DETECT" },
0671     { SS_POWERON,       "SS_POWERON"    },
0672     { SS_STSCHG,        "SS_STSCHG" },
0673     { SS_3VCARD,        "SS_3VCARD" },
0674     { SS_XVCARD,        "SS_XVCARD" },
0675 };
0676
0677 static struct bittbl conf_bits[] = {
0678     { SS_PWR_AUTO,      "SS_PWR_AUTO"   },
0679     { SS_IOCARD,        "SS_IOCARD" },
0680     { SS_RESET,     "SS_RESET"  },
0681     { SS_DMA_MODE,      "SS_DMA_MODE"   },
0682     { SS_SPKR_ENA,      "SS_SPKR_ENA"   },
0683     { SS_OUTPUT_ENA,    "SS_OUTPUT_ENA" },
0684 };
0685
0686 static void dump_bits(char **p, const char *prefix,
0687     unsigned int val, struct bittbl *bits, int sz)
0688 {
0689     char *b = *p;
0690     int i;
0691
0692     b += sprintf(b, "%-9s:", prefix);
0693     for (i = 0; i < sz; i++)
0694         if (val & bits[i].mask)
0695             b += sprintf(b, " %s", bits[i].name);
0696     *b++ = '\n';
0697     *p = b;
0698 }
0699
0700 /*
0701  * Implements the /sys/class/pcmcia_socket/??/status file.
0702  *
0703  * Returns: the number of characters added to the buffer
0704  */
0705 static ssize_t show_status(
0706     struct device *dev, struct device_attribute *attr, char *buf)
0707 {
0708     struct soc_pcmcia_socket *skt =
0709         container_of(dev, struct soc_pcmcia_socket, socket.dev);
0710     char *p = buf;
0711
0712     p += sprintf(p, "slot     : %d\n", skt->nr);
0713
0714     dump_bits(&p, "status", skt->status,
0715           status_bits, ARRAY_SIZE(status_bits));
0716     dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
0717           status_bits, ARRAY_SIZE(status_bits));
0718     dump_bits(&p, "cs_flags", skt->cs_state.flags,
0719           conf_bits, ARRAY_SIZE(conf_bits));
0720
0721     p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
0722     p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
0723     p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
0724         skt->socket.pci_irq);
0725     if (skt->ops->show_timing)
0726         p += skt->ops->show_timing(skt, p);
0727
0728     return p-buf;
0729 }
0730 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
0731
0732
0733 static struct pccard_operations soc_common_pcmcia_operations = {
0734     .init           = soc_common_pcmcia_sock_init,
0735     .suspend        = soc_common_pcmcia_suspend,
0736     .get_status     = soc_common_pcmcia_get_status,
0737     .set_socket     = soc_common_pcmcia_set_socket,
0738     .set_io_map     = soc_common_pcmcia_set_io_map,
0739     .set_mem_map        = soc_common_pcmcia_set_mem_map,
0740 };
0741
0742
0743 #ifdef CONFIG_CPU_FREQ
0744 static int soc_common_pcmcia_cpufreq_nb(struct notifier_block *nb,
0745     unsigned long val, void *data)
0746 {
0747     struct soc_pcmcia_socket *skt = container_of(nb, struct soc_pcmcia_socket, cpufreq_nb);
0748     struct cpufreq_freqs *freqs = data;
0749
0750     return skt->ops->frequency_change(skt, val, freqs);
0751 }
0752 #endif
0753
0754 void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt,
0755     const struct pcmcia_low_level *ops, struct device *dev)
0756 {
0757     int i;
0758
0759     skt->ops = ops;
0760     skt->socket.owner = ops->owner;
0761     skt->socket.dev.parent = dev;
0762     skt->socket.pci_irq = NO_IRQ;
0763
0764     for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
0765         skt->stat[i].gpio = -EINVAL;
0766 }
0767 EXPORT_SYMBOL(soc_pcmcia_init_one);
0768
0769 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
0770 {
0771     del_timer_sync(&skt->poll_timer);
0772
0773     pcmcia_unregister_socket(&skt->socket);
0774
0775 #ifdef CONFIG_CPU_FREQ
0776     if (skt->ops->frequency_change)
0777         cpufreq_unregister_notifier(&skt->cpufreq_nb,
0778                         CPUFREQ_TRANSITION_NOTIFIER);
0779 #endif
0780
0781     soc_pcmcia_hw_shutdown(skt);
0782
0783     /* should not be required; violates some lowlevel drivers */
0784     soc_common_pcmcia_config_skt(skt, &dead_socket);
0785
0786     iounmap(PCI_IOBASE + skt->res_io_io.start);
0787     release_resource(&skt->res_attr);
0788     release_resource(&skt->res_mem);
0789     release_resource(&skt->res_io);
0790     release_resource(&skt->res_skt);
0791 }
0792 EXPORT_SYMBOL(soc_pcmcia_remove_one);
0793
0794 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
0795 {
0796     int ret;
0797
0798     skt->cs_state = dead_socket;
0799
0800     timer_setup(&skt->poll_timer, soc_common_pcmcia_poll_event, 0);
0801     skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
0802
0803     ret = request_resource(&iomem_resource, &skt->res_skt);
0804     if (ret)
0805         goto out_err_1;
0806
0807     ret = request_resource(&skt->res_skt, &skt->res_io);
0808     if (ret)
0809         goto out_err_2;
0810
0811     ret = request_resource(&skt->res_skt, &skt->res_mem);
0812     if (ret)
0813         goto out_err_3;
0814
0815     ret = request_resource(&skt->res_skt, &skt->res_attr);
0816     if (ret)
0817         goto out_err_4;
0818
0819     skt->res_io_io = (struct resource)
0820          DEFINE_RES_IO_NAMED(skt->nr * 0x1000 + 0x10000, 0x1000,
0821                      "PCMCIA I/O");
0822     ret = pci_remap_iospace(&skt->res_io_io, skt->res_io.start);
0823     if (ret)
0824         goto out_err_5;
0825
0826     /*
0827      * We initialize default socket timing here, because
0828      * we are not guaranteed to see a SetIOMap operation at
0829      * runtime.
0830      */
0831     skt->ops->set_timing(skt);
0832
0833     ret = soc_pcmcia_hw_init(skt);
0834     if (ret)
0835         goto out_err_6;
0836
0837     skt->socket.ops = &soc_common_pcmcia_operations;
0838     skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
0839     skt->socket.resource_ops = &pccard_static_ops;
0840     skt->socket.irq_mask = 0;
0841     skt->socket.map_size = PAGE_SIZE;
0842     skt->socket.io_offset = (unsigned long)skt->res_io_io.start;
0843
0844     skt->status = soc_common_pcmcia_skt_state(skt);
0845
0846 #ifdef CONFIG_CPU_FREQ
0847     if (skt->ops->frequency_change) {
0848         skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb;
0849
0850         ret = cpufreq_register_notifier(&skt->cpufreq_nb,
0851                         CPUFREQ_TRANSITION_NOTIFIER);
0852         if (ret < 0)
0853             dev_err(skt->socket.dev.parent,
0854                 "unable to register CPU frequency change notifier for PCMCIA (%d)\n",
0855                 ret);
0856     }
0857 #endif
0858
0859     ret = pcmcia_register_socket(&skt->socket);
0860     if (ret)
0861         goto out_err_7;
0862
0863     ret = device_create_file(&skt->socket.dev, &dev_attr_status);
0864     if (ret)
0865         goto out_err_8;
0866
0867     return ret;
0868
0869  out_err_8:
0870     del_timer_sync(&skt->poll_timer);
0871     pcmcia_unregister_socket(&skt->socket);
0872
0873  out_err_7:
0874     soc_pcmcia_hw_shutdown(skt);
0875  out_err_6:
0876     iounmap(PCI_IOBASE + skt->res_io_io.start);
0877  out_err_5:
0878     release_resource(&skt->res_attr);
0879  out_err_4:
0880     release_resource(&skt->res_mem);
0881  out_err_3:
0882     release_resource(&skt->res_io);
0883  out_err_2:
0884     release_resource(&skt->res_skt);
0885  out_err_1:
0886
0887     return ret;
0888 }
0889 EXPORT_SYMBOL(soc_pcmcia_add_one);
0890
0891 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
0892 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
0893 MODULE_LICENSE("Dual MPL/GPL");