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/interrupt.h>
41 #include <linux/spinlock.h>
43 #include <asm/hardware.h>
46 #include <asm/system.h>
48 #include "soc_common.h"
53 module_param(pc_debug, int, 0644);
55 void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
56 int lvl, const char *fmt, ...)
60 printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
69 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
72 calc_speed(unsigned short *spds, int num, unsigned short dflt)
74 unsigned short speed = 0;
77 for (i = 0; i < num; i++)
86 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
88 timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
89 timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
90 timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
92 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
94 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
96 struct pcmcia_state state;
99 memset(&state, 0, sizeof(struct pcmcia_state));
101 skt->ops->socket_state(skt, &state);
103 stat = state.detect ? SS_DETECT : 0;
104 stat |= state.ready ? SS_READY : 0;
105 stat |= state.wrprot ? SS_WRPROT : 0;
106 stat |= state.vs_3v ? SS_3VCARD : 0;
107 stat |= state.vs_Xv ? SS_XVCARD : 0;
109 /* The power status of individual sockets is not available
110 * explicitly from the hardware, so we just remember the state
111 * and regurgitate it upon request:
113 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
115 if (skt->cs_state.flags & SS_IOCARD)
116 stat |= state.bvd1 ? SS_STSCHG : 0;
120 else if (state.bvd2 == 0)
127 * soc_common_pcmcia_config_skt
128 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
130 * Convert PCMCIA socket state to our socket configure structure.
133 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
137 ret = skt->ops->configure_socket(skt, state);
140 * This really needs a better solution. The IRQ
141 * may or may not be claimed by the driver.
143 if (skt->irq_state != 1 && state->io_irq) {
145 set_irq_type(skt->irq, IRQT_FALLING);
146 } else if (skt->irq_state == 1 && state->io_irq == 0) {
148 set_irq_type(skt->irq, IRQT_NOEDGE);
151 skt->cs_state = *state;
155 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
156 "socket %d\n", skt->nr);
161 /* soc_common_pcmcia_sock_init()
162 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
164 * (Re-)Initialise the socket, turning on status interrupts
165 * and PCMCIA bus. This must wait for power to stabilise
166 * so that the card status signals report correctly.
170 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
172 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
174 debug(skt, 2, "initializing socket\n");
176 skt->ops->socket_init(skt);
182 * soc_common_pcmcia_suspend()
183 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
185 * Remove power on the socket, disable IRQs from the card.
186 * Turn off status interrupts, and disable the PCMCIA bus.
190 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
192 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
195 debug(skt, 2, "suspending socket\n");
197 ret = soc_common_pcmcia_config_skt(skt, &dead_socket);
199 skt->ops->socket_suspend(skt);
204 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
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, struct pt_regs *regs)
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 get_socket() operation for the in-kernel PCMCIA
297 * service (formerly SS_GetSocket in Card Services). Not a very
303 soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
305 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
309 *state = skt->cs_state;
315 * Implements the set_socket() operation for the in-kernel PCMCIA
316 * service (formerly SS_SetSocket in Card Services). We more or
317 * less punt all of this work and let the kernel handle the details
318 * of power configuration, reset, &c. We also record the value of
319 * `state' in order to regurgitate it to the PCMCIA core later.
324 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
326 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
328 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
329 (state->csc_mask==0)?"<NONE> ":"",
330 (state->csc_mask&SS_DETECT)?"DETECT ":"",
331 (state->csc_mask&SS_READY)?"READY ":"",
332 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
333 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
334 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
335 (state->flags==0)?"<NONE> ":"",
336 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
337 (state->flags&SS_IOCARD)?"IOCARD ":"",
338 (state->flags&SS_RESET)?"RESET ":"",
339 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
340 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
341 state->Vcc, state->Vpp, state->io_irq);
343 return soc_common_pcmcia_config_skt(skt, state);
348 * Implements the set_io_map() operation for the in-kernel PCMCIA
349 * service (formerly SS_SetIOMap in Card Services). We configure
350 * the map speed as requested, but override the address ranges
351 * supplied by Card Services.
353 * Returns: 0 on success, -1 on error
356 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
358 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
359 unsigned short speed = map->speed;
361 debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
362 map->map, map->speed, map->start, map->stop);
363 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
364 (map->flags==0)?"<NONE>":"",
365 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
366 (map->flags&MAP_16BIT)?"16BIT ":"",
367 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
368 (map->flags&MAP_0WS)?"0WS ":"",
369 (map->flags&MAP_WRPROT)?"WRPROT ":"",
370 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
371 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
373 if (map->map >= MAX_IO_WIN) {
374 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
379 if (map->flags & MAP_ACTIVE) {
381 speed = SOC_PCMCIA_IO_ACCESS;
386 skt->spd_io[map->map] = speed;
387 skt->ops->set_timing(skt);
390 map->stop = PAGE_SIZE-1;
392 map->stop -= map->start;
393 map->stop += (unsigned long)skt->virt_io;
394 map->start = (unsigned long)skt->virt_io;
401 * Implements the set_mem_map() operation for the in-kernel PCMCIA
402 * service (formerly SS_SetMemMap in Card Services). We configure
403 * the map speed as requested, but override the address ranges
404 * supplied by Card Services.
406 * Returns: 0 on success, -1 on error
409 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
411 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
412 struct resource *res;
413 unsigned short speed = map->speed;
415 debug(skt, 2, "map %u speed %u card_start %08x\n",
416 map->map, map->speed, map->card_start);
417 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
418 (map->flags==0)?"<NONE>":"",
419 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
420 (map->flags&MAP_16BIT)?"16BIT ":"",
421 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
422 (map->flags&MAP_0WS)?"0WS ":"",
423 (map->flags&MAP_WRPROT)?"WRPROT ":"",
424 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
425 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
427 if (map->map >= MAX_WIN)
430 if (map->flags & MAP_ACTIVE) {
437 if (map->flags & MAP_ATTRIB) {
438 res = &skt->res_attr;
439 skt->spd_attr[map->map] = speed;
440 skt->spd_mem[map->map] = 0;
443 skt->spd_attr[map->map] = 0;
444 skt->spd_mem[map->map] = speed;
447 skt->ops->set_timing(skt);
449 map->sys_stop -= map->sys_start;
450 map->sys_stop += res->start + map->card_start;
451 map->sys_start = res->start + map->card_start;
461 static struct bittbl status_bits[] = {
462 { SS_WRPROT, "SS_WRPROT" },
463 { SS_BATDEAD, "SS_BATDEAD" },
464 { SS_BATWARN, "SS_BATWARN" },
465 { SS_READY, "SS_READY" },
466 { SS_DETECT, "SS_DETECT" },
467 { SS_POWERON, "SS_POWERON" },
468 { SS_STSCHG, "SS_STSCHG" },
469 { SS_3VCARD, "SS_3VCARD" },
470 { SS_XVCARD, "SS_XVCARD" },
473 static struct bittbl conf_bits[] = {
474 { SS_PWR_AUTO, "SS_PWR_AUTO" },
475 { SS_IOCARD, "SS_IOCARD" },
476 { SS_RESET, "SS_RESET" },
477 { SS_DMA_MODE, "SS_DMA_MODE" },
478 { SS_SPKR_ENA, "SS_SPKR_ENA" },
479 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
483 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
488 b += sprintf(b, "%-9s:", prefix);
489 for (i = 0; i < sz; i++)
490 if (val & bits[i].mask)
491 b += sprintf(b, " %s", bits[i].name);
497 * Implements the /sys/class/pcmcia_socket/??/status file.
499 * Returns: the number of characters added to the buffer
501 static ssize_t show_status(struct class_device *class_dev, char *buf)
503 struct soc_pcmcia_socket *skt =
504 container_of(class_dev, struct soc_pcmcia_socket, socket.dev);
507 p+=sprintf(p, "slot : %d\n", skt->nr);
509 dump_bits(&p, "status", skt->status,
510 status_bits, ARRAY_SIZE(status_bits));
511 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
512 status_bits, ARRAY_SIZE(status_bits));
513 dump_bits(&p, "cs_flags", skt->cs_state.flags,
514 conf_bits, ARRAY_SIZE(conf_bits));
516 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
517 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
518 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
519 if (skt->ops->show_timing)
520 p+=skt->ops->show_timing(skt, p);
524 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
527 static struct pccard_operations soc_common_pcmcia_operations = {
528 .init = soc_common_pcmcia_sock_init,
529 .suspend = soc_common_pcmcia_suspend,
530 .get_status = soc_common_pcmcia_get_status,
531 .get_socket = soc_common_pcmcia_get_socket,
532 .set_socket = soc_common_pcmcia_set_socket,
533 .set_io_map = soc_common_pcmcia_set_io_map,
534 .set_mem_map = soc_common_pcmcia_set_mem_map,
538 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
539 struct pcmcia_irqs *irqs, int nr)
543 for (i = 0; i < nr; i++) {
544 if (irqs[i].sock != skt->nr)
546 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
547 SA_INTERRUPT, irqs[i].str, skt);
550 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
554 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
558 if (irqs[i].sock == skt->nr)
559 free_irq(irqs[i].irq, skt);
563 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
565 void soc_pcmcia_free_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 free_irq(irqs[i].irq, skt);
574 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
576 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
577 struct pcmcia_irqs *irqs, int nr)
581 for (i = 0; i < nr; i++)
582 if (irqs[i].sock == skt->nr)
583 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
585 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
587 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
588 struct pcmcia_irqs *irqs, int nr)
592 for (i = 0; i < nr; i++)
593 if (irqs[i].sock == skt->nr) {
594 set_irq_type(irqs[i].irq, IRQT_RISING);
595 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
598 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
601 LIST_HEAD(soc_pcmcia_sockets);
602 DECLARE_MUTEX(soc_pcmcia_sockets_lock);
604 static const char *skt_names[] = {
609 struct skt_dev_info {
611 struct soc_pcmcia_socket skt[0];
614 #define SKT_DEV_INFO_SIZE(n) \
615 (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
617 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
619 struct skt_dev_info *sinfo;
622 down(&soc_pcmcia_sockets_lock);
624 sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
630 memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
634 * Initialise the per-socket structure.
636 for (i = 0; i < nr; i++) {
637 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
639 skt->socket.ops = &soc_common_pcmcia_operations;
640 skt->socket.owner = ops->owner;
641 skt->socket.dev.dev = dev;
643 init_timer(&skt->poll_timer);
644 skt->poll_timer.function = soc_common_pcmcia_poll_event;
645 skt->poll_timer.data = (unsigned long)skt;
646 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
653 skt->res_skt.start = _PCMCIA(skt->nr);
654 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
655 skt->res_skt.name = skt_names[skt->nr];
656 skt->res_skt.flags = IORESOURCE_MEM;
658 ret = request_resource(&iomem_resource, &skt->res_skt);
662 skt->res_io.start = _PCMCIAIO(skt->nr);
663 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
664 skt->res_io.name = "io";
665 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
667 ret = request_resource(&skt->res_skt, &skt->res_io);
671 skt->res_mem.start = _PCMCIAMem(skt->nr);
672 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
673 skt->res_mem.name = "memory";
674 skt->res_mem.flags = IORESOURCE_MEM;
676 ret = request_resource(&skt->res_skt, &skt->res_mem);
680 skt->res_attr.start = _PCMCIAAttr(skt->nr);
681 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
682 skt->res_attr.name = "attribute";
683 skt->res_attr.flags = IORESOURCE_MEM;
685 ret = request_resource(&skt->res_skt, &skt->res_attr);
689 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
690 if (skt->virt_io == NULL) {
695 list_add(&skt->node, &soc_pcmcia_sockets);
698 * We initialize default socket timing here, because
699 * we are not guaranteed to see a SetIOMap operation at
702 ops->set_timing(skt);
704 ret = ops->hw_init(skt);
708 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
709 skt->socket.irq_mask = 0;
710 skt->socket.map_size = PAGE_SIZE;
711 skt->socket.pci_irq = skt->irq;
712 skt->socket.io_offset = (unsigned long)skt->virt_io;
714 skt->status = soc_common_pcmcia_skt_state(skt);
716 ret = pcmcia_register_socket(&skt->socket);
720 WARN_ON(skt->socket.sock != i);
722 add_timer(&skt->poll_timer);
724 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
727 dev_set_drvdata(dev, sinfo);
732 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
734 del_timer_sync(&skt->poll_timer);
735 pcmcia_unregister_socket(&skt->socket);
738 flush_scheduled_work();
740 ops->hw_shutdown(skt);
742 list_del(&skt->node);
743 iounmap(skt->virt_io);
745 release_resource(&skt->res_attr);
747 release_resource(&skt->res_mem);
749 release_resource(&skt->res_io);
751 release_resource(&skt->res_skt);
759 up(&soc_pcmcia_sockets_lock);
763 int soc_common_drv_pcmcia_remove(struct device *dev)
765 struct skt_dev_info *sinfo = dev_get_drvdata(dev);
768 dev_set_drvdata(dev, NULL);
770 down(&soc_pcmcia_sockets_lock);
771 for (i = 0; i < sinfo->nskt; i++) {
772 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
774 del_timer_sync(&skt->poll_timer);
776 pcmcia_unregister_socket(&skt->socket);
778 flush_scheduled_work();
780 skt->ops->hw_shutdown(skt);
782 soc_common_pcmcia_config_skt(skt, &dead_socket);
784 list_del(&skt->node);
785 iounmap(skt->virt_io);
787 release_resource(&skt->res_attr);
788 release_resource(&skt->res_mem);
789 release_resource(&skt->res_io);
790 release_resource(&skt->res_skt);
792 up(&soc_pcmcia_sockets_lock);