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