1 /*======================================================================
3 Common support code for the PCMCIA control functionality of
4 integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
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/
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.
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.
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.
31 ======================================================================*/
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/init.h>
37 #include <linux/kernel.h>
38 #include <linux/timer.h>
40 #include <linux/mutex.h>
41 #include <linux/interrupt.h>
42 #include <linux/irq.h>
43 #include <linux/spinlock.h>
44 #include <linux/cpufreq.h>
46 #include <mach/hardware.h>
48 #include <asm/system.h>
50 #include "soc_common.h"
52 #ifdef CONFIG_PCMCIA_DEBUG
55 module_param(pc_debug, int, 0644);
57 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
58 int lvl, const char *fmt, ...)
62 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
68 EXPORT_SYMBOL(soc_pcmcia_debug);
72 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
75 calc_speed(unsigned short *spds, int num, unsigned short dflt)
77 unsigned short speed = 0;
80 for (i = 0; i < num; i++)
89 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
91 timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
92 timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
93 timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
95 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
97 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
99 struct pcmcia_state state;
102 memset(&state, 0, sizeof(struct pcmcia_state));
104 skt->ops->socket_state(skt, &state);
106 stat = state.detect ? SS_DETECT : 0;
107 stat |= state.ready ? SS_READY : 0;
108 stat |= state.wrprot ? SS_WRPROT : 0;
109 stat |= state.vs_3v ? SS_3VCARD : 0;
110 stat |= state.vs_Xv ? SS_XVCARD : 0;
112 /* The power status of individual sockets is not available
113 * explicitly from the hardware, so we just remember the state
114 * and regurgitate it upon request:
116 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
118 if (skt->cs_state.flags & SS_IOCARD)
119 stat |= state.bvd1 ? SS_STSCHG : 0;
123 else if (state.bvd2 == 0)
130 * soc_common_pcmcia_config_skt
131 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
133 * Convert PCMCIA socket state to our socket configure structure.
136 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
140 ret = skt->ops->configure_socket(skt, state);
143 * This really needs a better solution. The IRQ
144 * may or may not be claimed by the driver.
146 if (skt->irq_state != 1 && state->io_irq) {
148 set_irq_type(skt->socket.pci_irq, IRQ_TYPE_EDGE_FALLING);
149 } else if (skt->irq_state == 1 && state->io_irq == 0) {
151 set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
154 skt->cs_state = *state;
158 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
159 "socket %d\n", skt->nr);
164 /* soc_common_pcmcia_sock_init()
165 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
167 * (Re-)Initialise the socket, turning on status interrupts
168 * and PCMCIA bus. This must wait for power to stabilise
169 * so that the card status signals report correctly.
173 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
175 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
177 debug(skt, 2, "initializing socket\n");
179 skt->ops->socket_init(skt);
185 * soc_common_pcmcia_suspend()
186 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
188 * Remove power on the socket, disable IRQs from the card.
189 * Turn off status interrupts, and disable the PCMCIA bus.
193 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
195 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
197 debug(skt, 2, "suspending socket\n");
199 skt->ops->socket_suspend(skt);
204 static DEFINE_SPINLOCK(status_lock);
206 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
210 debug(skt, 4, "entering PCMCIA monitoring thread\n");
216 status = soc_common_pcmcia_skt_state(skt);
218 spin_lock_irqsave(&status_lock, flags);
219 events = (status ^ skt->status) & skt->cs_state.csc_mask;
220 skt->status = status;
221 spin_unlock_irqrestore(&status_lock, flags);
223 debug(skt, 4, "events: %s%s%s%s%s%s\n",
224 events == 0 ? "<NONE>" : "",
225 events & SS_DETECT ? "DETECT " : "",
226 events & SS_READY ? "READY " : "",
227 events & SS_BATDEAD ? "BATDEAD " : "",
228 events & SS_BATWARN ? "BATWARN " : "",
229 events & SS_STSCHG ? "STSCHG " : "");
232 pcmcia_parse_events(&skt->socket, events);
236 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
237 static void soc_common_pcmcia_poll_event(unsigned long dummy)
239 struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
240 debug(skt, 4, "polling for events\n");
242 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
244 soc_common_check_status(skt);
249 * Service routine for socket driver interrupts (requested by the
250 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
251 * The actual interrupt-servicing work is performed by
252 * soc_common_pcmcia_thread(), largely because the Card Services event-
253 * handling code performs scheduling operations which cannot be
254 * executed from within an interrupt context.
256 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
258 struct soc_pcmcia_socket *skt = dev;
260 debug(skt, 3, "servicing IRQ %d\n", irq);
262 soc_common_check_status(skt);
269 * Implements the get_status() operation for the in-kernel PCMCIA
270 * service (formerly SS_GetStatus in Card Services). Essentially just
271 * fills in bits in `status' according to internal driver state or
272 * the value of the voltage detect chipselect register.
274 * As a debugging note, during card startup, the PCMCIA core issues
275 * three set_socket() commands in a row the first with RESET deasserted,
276 * the second with RESET asserted, and the last with RESET deasserted
277 * again. Following the third set_socket(), a get_status() command will
278 * be issued. The kernel is looking for the SS_READY flag (see
279 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
284 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
286 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
288 skt->status = soc_common_pcmcia_skt_state(skt);
289 *status = skt->status;
296 * Implements the set_socket() operation for the in-kernel PCMCIA
297 * service (formerly SS_SetSocket in Card Services). We more or
298 * less punt all of this work and let the kernel handle the details
299 * of power configuration, reset, &c. We also record the value of
300 * `state' in order to regurgitate it to the PCMCIA core later.
303 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
305 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
307 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
308 (state->csc_mask==0)?"<NONE> ":"",
309 (state->csc_mask&SS_DETECT)?"DETECT ":"",
310 (state->csc_mask&SS_READY)?"READY ":"",
311 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
312 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
313 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
314 (state->flags==0)?"<NONE> ":"",
315 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
316 (state->flags&SS_IOCARD)?"IOCARD ":"",
317 (state->flags&SS_RESET)?"RESET ":"",
318 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
319 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
320 state->Vcc, state->Vpp, state->io_irq);
322 return soc_common_pcmcia_config_skt(skt, state);
327 * Implements the set_io_map() operation for the in-kernel PCMCIA
328 * service (formerly SS_SetIOMap in Card Services). We configure
329 * the map speed as requested, but override the address ranges
330 * supplied by Card Services.
332 * Returns: 0 on success, -1 on error
335 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
337 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
338 unsigned short speed = map->speed;
340 debug(skt, 2, "map %u speed %u start 0x%08llx stop 0x%08llx\n",
341 map->map, map->speed, (unsigned long long)map->start,
342 (unsigned long long)map->stop);
343 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
344 (map->flags==0)?"<NONE>":"",
345 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
346 (map->flags&MAP_16BIT)?"16BIT ":"",
347 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
348 (map->flags&MAP_0WS)?"0WS ":"",
349 (map->flags&MAP_WRPROT)?"WRPROT ":"",
350 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
351 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
353 if (map->map >= MAX_IO_WIN) {
354 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
359 if (map->flags & MAP_ACTIVE) {
361 speed = SOC_PCMCIA_IO_ACCESS;
366 skt->spd_io[map->map] = speed;
367 skt->ops->set_timing(skt);
370 map->stop = PAGE_SIZE-1;
372 map->stop -= map->start;
373 map->stop += skt->socket.io_offset;
374 map->start = skt->socket.io_offset;
381 * Implements the set_mem_map() operation for the in-kernel PCMCIA
382 * service (formerly SS_SetMemMap in Card Services). We configure
383 * the map speed as requested, but override the address ranges
384 * supplied by Card Services.
386 * Returns: 0 on success, -ERRNO on error
389 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
391 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
392 struct resource *res;
393 unsigned short speed = map->speed;
395 debug(skt, 2, "map %u speed %u card_start %08x\n",
396 map->map, map->speed, map->card_start);
397 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
398 (map->flags==0)?"<NONE>":"",
399 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
400 (map->flags&MAP_16BIT)?"16BIT ":"",
401 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
402 (map->flags&MAP_0WS)?"0WS ":"",
403 (map->flags&MAP_WRPROT)?"WRPROT ":"",
404 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
405 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
407 if (map->map >= MAX_WIN)
410 if (map->flags & MAP_ACTIVE) {
417 if (map->flags & MAP_ATTRIB) {
418 res = &skt->res_attr;
419 skt->spd_attr[map->map] = speed;
420 skt->spd_mem[map->map] = 0;
423 skt->spd_attr[map->map] = 0;
424 skt->spd_mem[map->map] = speed;
427 skt->ops->set_timing(skt);
429 map->static_start = res->start + map->card_start;
439 static struct bittbl status_bits[] = {
440 { SS_WRPROT, "SS_WRPROT" },
441 { SS_BATDEAD, "SS_BATDEAD" },
442 { SS_BATWARN, "SS_BATWARN" },
443 { SS_READY, "SS_READY" },
444 { SS_DETECT, "SS_DETECT" },
445 { SS_POWERON, "SS_POWERON" },
446 { SS_STSCHG, "SS_STSCHG" },
447 { SS_3VCARD, "SS_3VCARD" },
448 { SS_XVCARD, "SS_XVCARD" },
451 static struct bittbl conf_bits[] = {
452 { SS_PWR_AUTO, "SS_PWR_AUTO" },
453 { SS_IOCARD, "SS_IOCARD" },
454 { SS_RESET, "SS_RESET" },
455 { SS_DMA_MODE, "SS_DMA_MODE" },
456 { SS_SPKR_ENA, "SS_SPKR_ENA" },
457 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
461 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
466 b += sprintf(b, "%-9s:", prefix);
467 for (i = 0; i < sz; i++)
468 if (val & bits[i].mask)
469 b += sprintf(b, " %s", bits[i].name);
475 * Implements the /sys/class/pcmcia_socket/??/status file.
477 * Returns: the number of characters added to the buffer
479 static ssize_t show_status(struct device *dev, struct device_attribute *attr, char *buf)
481 struct soc_pcmcia_socket *skt =
482 container_of(dev, struct soc_pcmcia_socket, socket.dev);
485 p+=sprintf(p, "slot : %d\n", skt->nr);
487 dump_bits(&p, "status", skt->status,
488 status_bits, ARRAY_SIZE(status_bits));
489 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
490 status_bits, ARRAY_SIZE(status_bits));
491 dump_bits(&p, "cs_flags", skt->cs_state.flags,
492 conf_bits, ARRAY_SIZE(conf_bits));
494 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
495 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
496 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq,
497 skt->socket.pci_irq);
498 if (skt->ops->show_timing)
499 p+=skt->ops->show_timing(skt, p);
503 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
506 static struct pccard_operations soc_common_pcmcia_operations = {
507 .init = soc_common_pcmcia_sock_init,
508 .suspend = soc_common_pcmcia_suspend,
509 .get_status = soc_common_pcmcia_get_status,
510 .set_socket = soc_common_pcmcia_set_socket,
511 .set_io_map = soc_common_pcmcia_set_io_map,
512 .set_mem_map = soc_common_pcmcia_set_mem_map,
516 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
517 struct pcmcia_irqs *irqs, int nr)
521 for (i = 0; i < nr; i++) {
522 if (irqs[i].sock != skt->nr)
524 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
525 IRQF_DISABLED, irqs[i].str, skt);
528 set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
532 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
536 if (irqs[i].sock == skt->nr)
537 free_irq(irqs[i].irq, skt);
541 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
543 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
544 struct pcmcia_irqs *irqs, int nr)
548 for (i = 0; i < nr; i++)
549 if (irqs[i].sock == skt->nr)
550 free_irq(irqs[i].irq, skt);
552 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
554 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
555 struct pcmcia_irqs *irqs, int nr)
559 for (i = 0; i < nr; i++)
560 if (irqs[i].sock == skt->nr)
561 set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
563 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
565 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
566 struct pcmcia_irqs *irqs, int nr)
570 for (i = 0; i < nr; i++)
571 if (irqs[i].sock == skt->nr) {
572 set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
573 set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
576 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
579 static LIST_HEAD(soc_pcmcia_sockets);
580 static DEFINE_MUTEX(soc_pcmcia_sockets_lock);
582 #ifdef CONFIG_CPU_FREQ
584 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
586 struct soc_pcmcia_socket *skt;
587 struct cpufreq_freqs *freqs = data;
590 mutex_lock(&soc_pcmcia_sockets_lock);
591 list_for_each_entry(skt, &soc_pcmcia_sockets, node)
592 if ( skt->ops->frequency_change )
593 ret += skt->ops->frequency_change(skt, val, freqs);
594 mutex_unlock(&soc_pcmcia_sockets_lock);
599 static struct notifier_block soc_pcmcia_notifier_block = {
600 .notifier_call = soc_pcmcia_notifier
603 static int soc_pcmcia_cpufreq_register(void)
607 ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
608 CPUFREQ_TRANSITION_NOTIFIER);
610 printk(KERN_ERR "Unable to register CPU frequency change "
611 "notifier for PCMCIA (%d)\n", ret);
614 fs_initcall(soc_pcmcia_cpufreq_register);
616 static void soc_pcmcia_cpufreq_unregister(void)
618 cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
620 module_exit(soc_pcmcia_cpufreq_unregister);
624 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
626 mutex_lock(&soc_pcmcia_sockets_lock);
627 del_timer_sync(&skt->poll_timer);
629 pcmcia_unregister_socket(&skt->socket);
631 flush_scheduled_work();
633 skt->ops->hw_shutdown(skt);
635 soc_common_pcmcia_config_skt(skt, &dead_socket);
637 list_del(&skt->node);
638 mutex_unlock(&soc_pcmcia_sockets_lock);
640 iounmap(skt->virt_io);
642 release_resource(&skt->res_attr);
643 release_resource(&skt->res_mem);
644 release_resource(&skt->res_io);
645 release_resource(&skt->res_skt);
647 EXPORT_SYMBOL(soc_pcmcia_remove_one);
649 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
653 init_timer(&skt->poll_timer);
654 skt->poll_timer.function = soc_common_pcmcia_poll_event;
655 skt->poll_timer.data = (unsigned long)skt;
656 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
658 ret = request_resource(&iomem_resource, &skt->res_skt);
662 ret = request_resource(&skt->res_skt, &skt->res_io);
666 ret = request_resource(&skt->res_skt, &skt->res_mem);
670 ret = request_resource(&skt->res_skt, &skt->res_attr);
674 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
675 if (skt->virt_io == NULL) {
680 mutex_lock(&soc_pcmcia_sockets_lock);
682 list_add(&skt->node, &soc_pcmcia_sockets);
685 * We initialize default socket timing here, because
686 * we are not guaranteed to see a SetIOMap operation at
689 skt->ops->set_timing(skt);
691 ret = skt->ops->hw_init(skt);
695 skt->socket.ops = &soc_common_pcmcia_operations;
696 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
697 skt->socket.resource_ops = &pccard_static_ops;
698 skt->socket.irq_mask = 0;
699 skt->socket.map_size = PAGE_SIZE;
700 skt->socket.io_offset = (unsigned long)skt->virt_io;
702 skt->status = soc_common_pcmcia_skt_state(skt);
704 ret = pcmcia_register_socket(&skt->socket);
708 add_timer(&skt->poll_timer);
710 mutex_unlock(&soc_pcmcia_sockets_lock);
712 ret = device_create_file(&skt->socket.dev, &dev_attr_status);
719 mutex_lock(&soc_pcmcia_sockets_lock);
720 del_timer_sync(&skt->poll_timer);
721 pcmcia_unregister_socket(&skt->socket);
724 flush_scheduled_work();
726 skt->ops->hw_shutdown(skt);
728 list_del(&skt->node);
729 mutex_unlock(&soc_pcmcia_sockets_lock);
730 iounmap(skt->virt_io);
732 release_resource(&skt->res_attr);
734 release_resource(&skt->res_mem);
736 release_resource(&skt->res_io);
738 release_resource(&skt->res_skt);
743 EXPORT_SYMBOL(soc_pcmcia_add_one);
745 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
746 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
747 MODULE_LICENSE("Dual MPL/GPL");