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