GNU Linux-libre 4.9.328-gnu1
[releases.git] / 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/cpufreq.h>
35 #include <linux/gpio.h>
36 #include <linux/gpio/consumer.h>
37 #include <linux/init.h>
38 #include <linux/interrupt.h>
39 #include <linux/io.h>
40 #include <linux/irq.h>
41 #include <linux/kernel.h>
42 #include <linux/mm.h>
43 #include <linux/module.h>
44 #include <linux/moduleparam.h>
45 #include <linux/mutex.h>
46 #include <linux/regulator/consumer.h>
47 #include <linux/spinlock.h>
48 #include <linux/timer.h>
49
50 #include <mach/hardware.h>
51
52 #include "soc_common.h"
53
54 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev);
55
56 #ifdef CONFIG_PCMCIA_DEBUG
57
58 static int pc_debug;
59 module_param(pc_debug, int, 0644);
60
61 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
62                       int lvl, const char *fmt, ...)
63 {
64         struct va_format vaf;
65         va_list args;
66         if (pc_debug > lvl) {
67                 va_start(args, fmt);
68
69                 vaf.fmt = fmt;
70                 vaf.va = &args;
71
72                 printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf);
73
74                 va_end(args);
75         }
76 }
77 EXPORT_SYMBOL(soc_pcmcia_debug);
78
79 #endif
80
81 #define to_soc_pcmcia_socket(x) \
82         container_of(x, struct soc_pcmcia_socket, socket)
83
84 int soc_pcmcia_regulator_set(struct soc_pcmcia_socket *skt,
85         struct soc_pcmcia_regulator *r, int v)
86 {
87         bool on;
88         int ret;
89
90         if (!r->reg)
91                 return 0;
92
93         on = v != 0;
94         if (r->on == on)
95                 return 0;
96
97         if (on) {
98                 ret = regulator_set_voltage(r->reg, v * 100000, v * 100000);
99                 if (ret) {
100                         int vout = regulator_get_voltage(r->reg) / 100000;
101
102                         dev_warn(&skt->socket.dev,
103                                  "CS requested %s=%u.%uV, applying %u.%uV\n",
104                                  r == &skt->vcc ? "Vcc" : "Vpp",
105                                  v / 10, v % 10, vout / 10, vout % 10);
106                 }
107
108                 ret = regulator_enable(r->reg);
109         } else {
110                 ret = regulator_disable(r->reg);
111         }
112         if (ret == 0)
113                 r->on = on;
114
115         return ret;
116 }
117 EXPORT_SYMBOL_GPL(soc_pcmcia_regulator_set);
118
119 static unsigned short
120 calc_speed(unsigned short *spds, int num, unsigned short dflt)
121 {
122         unsigned short speed = 0;
123         int i;
124
125         for (i = 0; i < num; i++)
126                 if (speed < spds[i])
127                         speed = spds[i];
128         if (speed == 0)
129                 speed = dflt;
130
131         return speed;
132 }
133
134 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
135         struct soc_pcmcia_timing *timing)
136 {
137         timing->io =
138                 calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
139         timing->mem =
140                 calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
141         timing->attr =
142                 calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
143 }
144 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
145
146 static void __soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt,
147         unsigned int nr)
148 {
149         unsigned int i;
150
151         for (i = 0; i < nr; i++)
152                 if (skt->stat[i].irq)
153                         free_irq(skt->stat[i].irq, skt);
154
155         if (skt->ops->hw_shutdown)
156                 skt->ops->hw_shutdown(skt);
157
158         clk_disable_unprepare(skt->clk);
159 }
160
161 static void soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
162 {
163         __soc_pcmcia_hw_shutdown(skt, ARRAY_SIZE(skt->stat));
164 }
165
166 int soc_pcmcia_request_gpiods(struct soc_pcmcia_socket *skt)
167 {
168         struct device *dev = skt->socket.dev.parent;
169         struct gpio_desc *desc;
170         int i;
171
172         for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
173                 if (!skt->stat[i].name)
174                         continue;
175
176                 desc = devm_gpiod_get(dev, skt->stat[i].name, GPIOD_IN);
177                 if (IS_ERR(desc)) {
178                         dev_err(dev, "Failed to get GPIO for %s: %ld\n",
179                                 skt->stat[i].name, PTR_ERR(desc));
180                         return PTR_ERR(desc);
181                 }
182
183                 skt->stat[i].desc = desc;
184         }
185
186         return 0;
187 }
188 EXPORT_SYMBOL_GPL(soc_pcmcia_request_gpiods);
189
190 static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
191 {
192         int ret = 0, i;
193
194         clk_prepare_enable(skt->clk);
195
196         if (skt->ops->hw_init) {
197                 ret = skt->ops->hw_init(skt);
198                 if (ret)
199                         return ret;
200         }
201
202         for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
203                 if (gpio_is_valid(skt->stat[i].gpio)) {
204                         unsigned long flags = GPIOF_IN;
205
206                         /* CD is active low by default */
207                         if (i == SOC_STAT_CD)
208                                 flags |= GPIOF_ACTIVE_LOW;
209
210                         ret = devm_gpio_request_one(skt->socket.dev.parent,
211                                                     skt->stat[i].gpio, flags,
212                                                     skt->stat[i].name);
213                         if (ret) {
214                                 __soc_pcmcia_hw_shutdown(skt, i);
215                                 return ret;
216                         }
217
218                         skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio);
219                 }
220
221                 if (i < SOC_STAT_VS1 && skt->stat[i].desc) {
222                         int irq = gpiod_to_irq(skt->stat[i].desc);
223
224                         if (irq > 0) {
225                                 if (i == SOC_STAT_RDY)
226                                         skt->socket.pci_irq = irq;
227                                 else
228                                         skt->stat[i].irq = irq;
229                         }
230                 }
231
232                 if (skt->stat[i].irq) {
233                         ret = request_irq(skt->stat[i].irq,
234                                           soc_common_pcmcia_interrupt,
235                                           IRQF_TRIGGER_NONE,
236                                           skt->stat[i].name, skt);
237                         if (ret) {
238                                 __soc_pcmcia_hw_shutdown(skt, i);
239                                 return ret;
240                         }
241                 }
242         }
243
244         return ret;
245 }
246
247 static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt)
248 {
249         int i;
250
251         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
252                 if (skt->stat[i].irq) {
253                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING);
254                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH);
255                 }
256 }
257
258 static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt)
259 {
260         int i;
261
262         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
263                 if (skt->stat[i].irq)
264                         irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE);
265 }
266
267 /*
268  * The CF 3.0 specification says that cards tie VS1 to ground and leave
269  * VS2 open.  Many implementations do not wire up the VS signals, so we
270  * provide hard-coded values as per the CF 3.0 spec.
271  */
272 void soc_common_cf_socket_state(struct soc_pcmcia_socket *skt,
273         struct pcmcia_state *state)
274 {
275         state->vs_3v = 1;
276 }
277 EXPORT_SYMBOL_GPL(soc_common_cf_socket_state);
278
279 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
280 {
281         struct pcmcia_state state;
282         unsigned int stat;
283
284         memset(&state, 0, sizeof(struct pcmcia_state));
285
286         /* Make battery voltage state report 'good' */
287         state.bvd1 = 1;
288         state.bvd2 = 1;
289
290         if (skt->stat[SOC_STAT_CD].desc)
291                 state.detect = !!gpiod_get_value(skt->stat[SOC_STAT_CD].desc);
292         if (skt->stat[SOC_STAT_RDY].desc)
293                 state.ready = !!gpiod_get_value(skt->stat[SOC_STAT_RDY].desc);
294         if (skt->stat[SOC_STAT_BVD1].desc)
295                 state.bvd1 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD1].desc);
296         if (skt->stat[SOC_STAT_BVD2].desc)
297                 state.bvd2 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD2].desc);
298         if (skt->stat[SOC_STAT_VS1].desc)
299                 state.vs_3v = !!gpiod_get_value(skt->stat[SOC_STAT_VS1].desc);
300         if (skt->stat[SOC_STAT_VS2].desc)
301                 state.vs_Xv = !!gpiod_get_value(skt->stat[SOC_STAT_VS2].desc);
302
303         skt->ops->socket_state(skt, &state);
304
305         stat = state.detect  ? SS_DETECT : 0;
306         stat |= state.ready  ? SS_READY  : 0;
307         stat |= state.wrprot ? SS_WRPROT : 0;
308         stat |= state.vs_3v  ? SS_3VCARD : 0;
309         stat |= state.vs_Xv  ? SS_XVCARD : 0;
310
311         /* The power status of individual sockets is not available
312          * explicitly from the hardware, so we just remember the state
313          * and regurgitate it upon request:
314          */
315         stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
316
317         if (skt->cs_state.flags & SS_IOCARD)
318                 stat |= state.bvd1 ? 0 : SS_STSCHG;
319         else {
320                 if (state.bvd1 == 0)
321                         stat |= SS_BATDEAD;
322                 else if (state.bvd2 == 0)
323                         stat |= SS_BATWARN;
324         }
325         return stat;
326 }
327
328 /*
329  * soc_common_pcmcia_config_skt
330  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
331  *
332  * Convert PCMCIA socket state to our socket configure structure.
333  */
334 static int soc_common_pcmcia_config_skt(
335         struct soc_pcmcia_socket *skt, socket_state_t *state)
336 {
337         int ret;
338
339         ret = skt->ops->configure_socket(skt, state);
340         if (ret < 0) {
341                 pr_err("soc_common_pcmcia: unable to configure socket %d\n",
342                        skt->nr);
343                 /* restore the previous state */
344                 WARN_ON(skt->ops->configure_socket(skt, &skt->cs_state));
345                 return ret;
346         }
347
348         if (ret == 0) {
349                 struct gpio_desc *descs[2];
350                 int values[2], n = 0;
351
352                 if (skt->gpio_reset) {
353                         descs[n] = skt->gpio_reset;
354                         values[n++] = !!(state->flags & SS_RESET);
355                 }
356                 if (skt->gpio_bus_enable) {
357                         descs[n] = skt->gpio_bus_enable;
358                         values[n++] = !!(state->flags & SS_OUTPUT_ENA);
359                 }
360
361                 if (n)
362                         gpiod_set_array_value_cansleep(n, descs, values);
363
364                 /*
365                  * This really needs a better solution.  The IRQ
366                  * may or may not be claimed by the driver.
367                  */
368                 if (skt->irq_state != 1 && state->io_irq) {
369                         skt->irq_state = 1;
370                         irq_set_irq_type(skt->socket.pci_irq,
371                                          IRQ_TYPE_EDGE_FALLING);
372                 } else if (skt->irq_state == 1 && state->io_irq == 0) {
373                         skt->irq_state = 0;
374                         irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
375                 }
376
377                 skt->cs_state = *state;
378         }
379
380         return ret;
381 }
382
383 /* soc_common_pcmcia_sock_init()
384  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
385  *
386  * (Re-)Initialise the socket, turning on status interrupts
387  * and PCMCIA bus.  This must wait for power to stabilise
388  * so that the card status signals report correctly.
389  *
390  * Returns: 0
391  */
392 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
393 {
394         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
395
396         debug(skt, 2, "initializing socket\n");
397         if (skt->ops->socket_init)
398                 skt->ops->socket_init(skt);
399         soc_pcmcia_hw_enable(skt);
400         return 0;
401 }
402
403
404 /*
405  * soc_common_pcmcia_suspend()
406  * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
407  *
408  * Remove power on the socket, disable IRQs from the card.
409  * Turn off status interrupts, and disable the PCMCIA bus.
410  *
411  * Returns: 0
412  */
413 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
414 {
415         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
416
417         debug(skt, 2, "suspending socket\n");
418
419         soc_pcmcia_hw_disable(skt);
420         if (skt->ops->socket_suspend)
421                 skt->ops->socket_suspend(skt);
422
423         return 0;
424 }
425
426 static DEFINE_SPINLOCK(status_lock);
427
428 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
429 {
430         unsigned int events;
431
432         debug(skt, 4, "entering PCMCIA monitoring thread\n");
433
434         do {
435                 unsigned int status;
436                 unsigned long flags;
437
438                 status = soc_common_pcmcia_skt_state(skt);
439
440                 spin_lock_irqsave(&status_lock, flags);
441                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
442                 skt->status = status;
443                 spin_unlock_irqrestore(&status_lock, flags);
444
445                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
446                         events == 0         ? "<NONE>"   : "",
447                         events & SS_DETECT  ? "DETECT "  : "",
448                         events & SS_READY   ? "READY "   : "",
449                         events & SS_BATDEAD ? "BATDEAD " : "",
450                         events & SS_BATWARN ? "BATWARN " : "",
451                         events & SS_STSCHG  ? "STSCHG "  : "");
452
453                 if (events)
454                         pcmcia_parse_events(&skt->socket, events);
455         } while (events);
456 }
457
458 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
459 static void soc_common_pcmcia_poll_event(unsigned long dummy)
460 {
461         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
462         debug(skt, 4, "polling for events\n");
463
464         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
465
466         soc_common_check_status(skt);
467 }
468
469
470 /*
471  * Service routine for socket driver interrupts (requested by the
472  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
473  * The actual interrupt-servicing work is performed by
474  * soc_common_pcmcia_thread(), largely because the Card Services event-
475  * handling code performs scheduling operations which cannot be
476  * executed from within an interrupt context.
477  */
478 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
479 {
480         struct soc_pcmcia_socket *skt = dev;
481
482         debug(skt, 3, "servicing IRQ %d\n", irq);
483
484         soc_common_check_status(skt);
485
486         return IRQ_HANDLED;
487 }
488
489
490 /*
491  *  Implements the get_status() operation for the in-kernel PCMCIA
492  * service (formerly SS_GetStatus in Card Services). Essentially just
493  * fills in bits in `status' according to internal driver state or
494  * the value of the voltage detect chipselect register.
495  *
496  * As a debugging note, during card startup, the PCMCIA core issues
497  * three set_socket() commands in a row the first with RESET deasserted,
498  * the second with RESET asserted, and the last with RESET deasserted
499  * again. Following the third set_socket(), a get_status() command will
500  * be issued. The kernel is looking for the SS_READY flag (see
501  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
502  *
503  * Returns: 0
504  */
505 static int
506 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
507 {
508         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
509
510         skt->status = soc_common_pcmcia_skt_state(skt);
511         *status = skt->status;
512
513         return 0;
514 }
515
516
517 /*
518  * Implements the set_socket() operation for the in-kernel PCMCIA
519  * service (formerly SS_SetSocket in Card Services). We more or
520  * less punt all of this work and let the kernel handle the details
521  * of power configuration, reset, &c. We also record the value of
522  * `state' in order to regurgitate it to the PCMCIA core later.
523  */
524 static int soc_common_pcmcia_set_socket(
525         struct pcmcia_socket *sock, socket_state_t *state)
526 {
527         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
528
529         debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
530                         (state->csc_mask == 0)          ? "<NONE> " :   "",
531                         (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
532                         (state->csc_mask & SS_READY)    ? "READY " :    "",
533                         (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
534                         (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
535                         (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
536                         (state->flags == 0)             ? "<NONE> " :   "",
537                         (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
538                         (state->flags & SS_IOCARD)      ? "IOCARD " :   "",
539                         (state->flags & SS_RESET)       ? "RESET " :    "",
540                         (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
541                         (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
542                         state->Vcc, state->Vpp, state->io_irq);
543
544         return soc_common_pcmcia_config_skt(skt, state);
545 }
546
547
548 /*
549  * Implements the set_io_map() operation for the in-kernel PCMCIA
550  * service (formerly SS_SetIOMap in Card Services). We configure
551  * the map speed as requested, but override the address ranges
552  * supplied by Card Services.
553  *
554  * Returns: 0 on success, -1 on error
555  */
556 static int soc_common_pcmcia_set_io_map(
557         struct pcmcia_socket *sock, struct pccard_io_map *map)
558 {
559         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
560         unsigned short speed = map->speed;
561
562         debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
563                 map->map, map->speed, (unsigned long long)map->start,
564                 (unsigned long long)map->stop);
565         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
566                 (map->flags == 0)               ? "<NONE>"      : "",
567                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
568                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
569                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
570                 (map->flags & MAP_0WS)          ? "0WS "        : "",
571                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
572                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "",
573                 (map->flags & MAP_PREFETCH)     ? "PREFETCH "   : "");
574
575         if (map->map >= MAX_IO_WIN) {
576                 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
577                        map->map);
578                 return -1;
579         }
580
581         if (map->flags & MAP_ACTIVE) {
582                 if (speed == 0)
583                         speed = SOC_PCMCIA_IO_ACCESS;
584         } else {
585                 speed = 0;
586         }
587
588         skt->spd_io[map->map] = speed;
589         skt->ops->set_timing(skt);
590
591         if (map->stop == 1)
592                 map->stop = PAGE_SIZE-1;
593
594         map->stop -= map->start;
595         map->stop += skt->socket.io_offset;
596         map->start = skt->socket.io_offset;
597
598         return 0;
599 }
600
601
602 /*
603  * Implements the set_mem_map() operation for the in-kernel PCMCIA
604  * service (formerly SS_SetMemMap in Card Services). We configure
605  * the map speed as requested, but override the address ranges
606  * supplied by Card Services.
607  *
608  * Returns: 0 on success, -ERRNO on error
609  */
610 static int soc_common_pcmcia_set_mem_map(
611         struct pcmcia_socket *sock, struct pccard_mem_map *map)
612 {
613         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
614         struct resource *res;
615         unsigned short speed = map->speed;
616
617         debug(skt, 2, "map %u speed %u card_start %08x\n",
618                 map->map, map->speed, map->card_start);
619         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
620                 (map->flags == 0)               ? "<NONE>"      : "",
621                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
622                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
623                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
624                 (map->flags & MAP_0WS)          ? "0WS "        : "",
625                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
626                 (map->flags & MAP_ATTRIB)       ? "ATTRIB "     : "",
627                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "");
628
629         if (map->map >= MAX_WIN)
630                 return -EINVAL;
631
632         if (map->flags & MAP_ACTIVE) {
633                 if (speed == 0)
634                         speed = 300;
635         } else {
636                 speed = 0;
637         }
638
639         if (map->flags & MAP_ATTRIB) {
640                 res = &skt->res_attr;
641                 skt->spd_attr[map->map] = speed;
642                 skt->spd_mem[map->map] = 0;
643         } else {
644                 res = &skt->res_mem;
645                 skt->spd_attr[map->map] = 0;
646                 skt->spd_mem[map->map] = speed;
647         }
648
649         skt->ops->set_timing(skt);
650
651         map->static_start = res->start + map->card_start;
652
653         return 0;
654 }
655
656 struct bittbl {
657         unsigned int mask;
658         const char *name;
659 };
660
661 static struct bittbl status_bits[] = {
662         { SS_WRPROT,            "SS_WRPROT"     },
663         { SS_BATDEAD,           "SS_BATDEAD"    },
664         { SS_BATWARN,           "SS_BATWARN"    },
665         { SS_READY,             "SS_READY"      },
666         { SS_DETECT,            "SS_DETECT"     },
667         { SS_POWERON,           "SS_POWERON"    },
668         { SS_STSCHG,            "SS_STSCHG"     },
669         { SS_3VCARD,            "SS_3VCARD"     },
670         { SS_XVCARD,            "SS_XVCARD"     },
671 };
672
673 static struct bittbl conf_bits[] = {
674         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
675         { SS_IOCARD,            "SS_IOCARD"     },
676         { SS_RESET,             "SS_RESET"      },
677         { SS_DMA_MODE,          "SS_DMA_MODE"   },
678         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
679         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
680 };
681
682 static void dump_bits(char **p, const char *prefix,
683         unsigned int val, struct bittbl *bits, int sz)
684 {
685         char *b = *p;
686         int i;
687
688         b += sprintf(b, "%-9s:", prefix);
689         for (i = 0; i < sz; i++)
690                 if (val & bits[i].mask)
691                         b += sprintf(b, " %s", bits[i].name);
692         *b++ = '\n';
693         *p = b;
694 }
695
696 /*
697  * Implements the /sys/class/pcmcia_socket/??/status file.
698  *
699  * Returns: the number of characters added to the buffer
700  */
701 static ssize_t show_status(
702         struct device *dev, struct device_attribute *attr, char *buf)
703 {
704         struct soc_pcmcia_socket *skt =
705                 container_of(dev, struct soc_pcmcia_socket, socket.dev);
706         char *p = buf;
707
708         p += sprintf(p, "slot     : %d\n", skt->nr);
709
710         dump_bits(&p, "status", skt->status,
711                   status_bits, ARRAY_SIZE(status_bits));
712         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
713                   status_bits, ARRAY_SIZE(status_bits));
714         dump_bits(&p, "cs_flags", skt->cs_state.flags,
715                   conf_bits, ARRAY_SIZE(conf_bits));
716
717         p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
718         p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
719         p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
720                 skt->socket.pci_irq);
721         if (skt->ops->show_timing)
722                 p += skt->ops->show_timing(skt, p);
723
724         return p-buf;
725 }
726 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
727
728
729 static struct pccard_operations soc_common_pcmcia_operations = {
730         .init                   = soc_common_pcmcia_sock_init,
731         .suspend                = soc_common_pcmcia_suspend,
732         .get_status             = soc_common_pcmcia_get_status,
733         .set_socket             = soc_common_pcmcia_set_socket,
734         .set_io_map             = soc_common_pcmcia_set_io_map,
735         .set_mem_map            = soc_common_pcmcia_set_mem_map,
736 };
737
738
739 #ifdef CONFIG_CPU_FREQ
740 static int soc_common_pcmcia_cpufreq_nb(struct notifier_block *nb,
741         unsigned long val, void *data)
742 {
743         struct soc_pcmcia_socket *skt = container_of(nb, struct soc_pcmcia_socket, cpufreq_nb);
744         struct cpufreq_freqs *freqs = data;
745
746         return skt->ops->frequency_change(skt, val, freqs);
747 }
748 #endif
749
750 void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt,
751         const struct pcmcia_low_level *ops, struct device *dev)
752 {
753         int i;
754
755         skt->ops = ops;
756         skt->socket.owner = ops->owner;
757         skt->socket.dev.parent = dev;
758         skt->socket.pci_irq = NO_IRQ;
759
760         for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
761                 skt->stat[i].gpio = -EINVAL;
762 }
763 EXPORT_SYMBOL(soc_pcmcia_init_one);
764
765 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
766 {
767         del_timer_sync(&skt->poll_timer);
768
769         pcmcia_unregister_socket(&skt->socket);
770
771 #ifdef CONFIG_CPU_FREQ
772         if (skt->ops->frequency_change)
773                 cpufreq_unregister_notifier(&skt->cpufreq_nb,
774                                             CPUFREQ_TRANSITION_NOTIFIER);
775 #endif
776
777         soc_pcmcia_hw_shutdown(skt);
778
779         /* should not be required; violates some lowlevel drivers */
780         soc_common_pcmcia_config_skt(skt, &dead_socket);
781
782         iounmap(skt->virt_io);
783         skt->virt_io = NULL;
784         release_resource(&skt->res_attr);
785         release_resource(&skt->res_mem);
786         release_resource(&skt->res_io);
787         release_resource(&skt->res_skt);
788 }
789 EXPORT_SYMBOL(soc_pcmcia_remove_one);
790
791 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
792 {
793         int ret;
794
795         skt->cs_state = dead_socket;
796
797         setup_timer(&skt->poll_timer, soc_common_pcmcia_poll_event,
798                     (unsigned long)skt);
799         skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
800
801         ret = request_resource(&iomem_resource, &skt->res_skt);
802         if (ret)
803                 goto out_err_1;
804
805         ret = request_resource(&skt->res_skt, &skt->res_io);
806         if (ret)
807                 goto out_err_2;
808
809         ret = request_resource(&skt->res_skt, &skt->res_mem);
810         if (ret)
811                 goto out_err_3;
812
813         ret = request_resource(&skt->res_skt, &skt->res_attr);
814         if (ret)
815                 goto out_err_4;
816
817         skt->virt_io = ioremap(skt->res_io.start, 0x10000);
818         if (skt->virt_io == NULL) {
819                 ret = -ENOMEM;
820                 goto out_err_5;
821         }
822
823         /*
824          * We initialize default socket timing here, because
825          * we are not guaranteed to see a SetIOMap operation at
826          * runtime.
827          */
828         skt->ops->set_timing(skt);
829
830         ret = soc_pcmcia_hw_init(skt);
831         if (ret)
832                 goto out_err_6;
833
834         skt->socket.ops = &soc_common_pcmcia_operations;
835         skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
836         skt->socket.resource_ops = &pccard_static_ops;
837         skt->socket.irq_mask = 0;
838         skt->socket.map_size = PAGE_SIZE;
839         skt->socket.io_offset = (unsigned long)skt->virt_io;
840
841         skt->status = soc_common_pcmcia_skt_state(skt);
842
843 #ifdef CONFIG_CPU_FREQ
844         if (skt->ops->frequency_change) {
845                 skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb;
846
847                 ret = cpufreq_register_notifier(&skt->cpufreq_nb,
848                                                 CPUFREQ_TRANSITION_NOTIFIER);
849                 if (ret < 0)
850                         dev_err(skt->socket.dev.parent,
851                                 "unable to register CPU frequency change notifier for PCMCIA (%d)\n",
852                                 ret);
853         }
854 #endif
855
856         ret = pcmcia_register_socket(&skt->socket);
857         if (ret)
858                 goto out_err_7;
859
860         ret = device_create_file(&skt->socket.dev, &dev_attr_status);
861         if (ret)
862                 goto out_err_8;
863
864         return ret;
865
866  out_err_8:
867         del_timer_sync(&skt->poll_timer);
868         pcmcia_unregister_socket(&skt->socket);
869
870  out_err_7:
871         soc_pcmcia_hw_shutdown(skt);
872  out_err_6:
873         iounmap(skt->virt_io);
874  out_err_5:
875         release_resource(&skt->res_attr);
876  out_err_4:
877         release_resource(&skt->res_mem);
878  out_err_3:
879         release_resource(&skt->res_io);
880  out_err_2:
881         release_resource(&skt->res_skt);
882  out_err_1:
883
884         return ret;
885 }
886 EXPORT_SYMBOL(soc_pcmcia_add_one);
887
888 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
889 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
890 MODULE_LICENSE("Dual MPL/GPL");