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/config.h>
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39 #include <linux/timer.h>
41 #include <linux/interrupt.h>
42 #include <linux/spinlock.h>
43 #include <linux/cpufreq.h>
45 #include <asm/hardware.h>
48 #include <asm/system.h>
50 #include "soc_common.h"
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);
71 #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
74 calc_speed(unsigned short *spds, int num, unsigned short dflt)
76 unsigned short speed = 0;
79 for (i = 0; i < num; i++)
88 void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
90 timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
91 timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
92 timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
94 EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
96 static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
98 struct pcmcia_state state;
101 memset(&state, 0, sizeof(struct pcmcia_state));
103 skt->ops->socket_state(skt, &state);
105 stat = state.detect ? SS_DETECT : 0;
106 stat |= state.ready ? SS_READY : 0;
107 stat |= state.wrprot ? SS_WRPROT : 0;
108 stat |= state.vs_3v ? SS_3VCARD : 0;
109 stat |= state.vs_Xv ? SS_XVCARD : 0;
111 /* The power status of individual sockets is not available
112 * explicitly from the hardware, so we just remember the state
113 * and regurgitate it upon request:
115 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
117 if (skt->cs_state.flags & SS_IOCARD)
118 stat |= state.bvd1 ? SS_STSCHG : 0;
122 else if (state.bvd2 == 0)
129 * soc_common_pcmcia_config_skt
130 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
132 * Convert PCMCIA socket state to our socket configure structure.
135 soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
139 ret = skt->ops->configure_socket(skt, state);
142 * This really needs a better solution. The IRQ
143 * may or may not be claimed by the driver.
145 if (skt->irq_state != 1 && state->io_irq) {
147 set_irq_type(skt->irq, IRQT_FALLING);
148 } else if (skt->irq_state == 1 && state->io_irq == 0) {
150 set_irq_type(skt->irq, IRQT_NOEDGE);
153 skt->cs_state = *state;
157 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
158 "socket %d\n", skt->nr);
163 /* soc_common_pcmcia_sock_init()
164 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
166 * (Re-)Initialise the socket, turning on status interrupts
167 * and PCMCIA bus. This must wait for power to stabilise
168 * so that the card status signals report correctly.
172 static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
174 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
176 debug(skt, 2, "initializing socket\n");
178 skt->ops->socket_init(skt);
184 * soc_common_pcmcia_suspend()
185 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
187 * Remove power on the socket, disable IRQs from the card.
188 * Turn off status interrupts, and disable the PCMCIA bus.
192 static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
194 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
197 debug(skt, 2, "suspending socket\n");
199 ret = soc_common_pcmcia_config_skt(skt, &dead_socket);
201 skt->ops->socket_suspend(skt);
206 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
208 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
212 debug(skt, 4, "entering PCMCIA monitoring thread\n");
218 status = soc_common_pcmcia_skt_state(skt);
220 spin_lock_irqsave(&status_lock, flags);
221 events = (status ^ skt->status) & skt->cs_state.csc_mask;
222 skt->status = status;
223 spin_unlock_irqrestore(&status_lock, flags);
225 debug(skt, 4, "events: %s%s%s%s%s%s\n",
226 events == 0 ? "<NONE>" : "",
227 events & SS_DETECT ? "DETECT " : "",
228 events & SS_READY ? "READY " : "",
229 events & SS_BATDEAD ? "BATDEAD " : "",
230 events & SS_BATWARN ? "BATWARN " : "",
231 events & SS_STSCHG ? "STSCHG " : "");
234 pcmcia_parse_events(&skt->socket, events);
238 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
239 static void soc_common_pcmcia_poll_event(unsigned long dummy)
241 struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
242 debug(skt, 4, "polling for events\n");
244 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
246 soc_common_check_status(skt);
251 * Service routine for socket driver interrupts (requested by the
252 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
253 * The actual interrupt-servicing work is performed by
254 * soc_common_pcmcia_thread(), largely because the Card Services event-
255 * handling code performs scheduling operations which cannot be
256 * executed from within an interrupt context.
258 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
260 struct soc_pcmcia_socket *skt = dev;
262 debug(skt, 3, "servicing IRQ %d\n", irq);
264 soc_common_check_status(skt);
271 * Implements the get_status() operation for the in-kernel PCMCIA
272 * service (formerly SS_GetStatus in Card Services). Essentially just
273 * fills in bits in `status' according to internal driver state or
274 * the value of the voltage detect chipselect register.
276 * As a debugging note, during card startup, the PCMCIA core issues
277 * three set_socket() commands in a row the first with RESET deasserted,
278 * the second with RESET asserted, and the last with RESET deasserted
279 * again. Following the third set_socket(), a get_status() command will
280 * be issued. The kernel is looking for the SS_READY flag (see
281 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
286 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
288 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
290 skt->status = soc_common_pcmcia_skt_state(skt);
291 *status = skt->status;
298 * Implements the get_socket() operation for the in-kernel PCMCIA
299 * service (formerly SS_GetSocket in Card Services). Not a very
305 soc_common_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
307 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
311 *state = skt->cs_state;
317 * Implements the set_socket() operation for the in-kernel PCMCIA
318 * service (formerly SS_SetSocket in Card Services). We more or
319 * less punt all of this work and let the kernel handle the details
320 * of power configuration, reset, &c. We also record the value of
321 * `state' in order to regurgitate it to the PCMCIA core later.
326 soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
328 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
330 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
331 (state->csc_mask==0)?"<NONE> ":"",
332 (state->csc_mask&SS_DETECT)?"DETECT ":"",
333 (state->csc_mask&SS_READY)?"READY ":"",
334 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
335 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
336 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
337 (state->flags==0)?"<NONE> ":"",
338 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
339 (state->flags&SS_IOCARD)?"IOCARD ":"",
340 (state->flags&SS_RESET)?"RESET ":"",
341 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
342 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
343 state->Vcc, state->Vpp, state->io_irq);
345 return soc_common_pcmcia_config_skt(skt, state);
350 * Implements the set_io_map() operation for the in-kernel PCMCIA
351 * service (formerly SS_SetIOMap in Card Services). We configure
352 * the map speed as requested, but override the address ranges
353 * supplied by Card Services.
355 * Returns: 0 on success, -1 on error
358 soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
360 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
361 unsigned short speed = map->speed;
363 debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
364 map->map, map->speed, map->start, map->stop);
365 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
366 (map->flags==0)?"<NONE>":"",
367 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
368 (map->flags&MAP_16BIT)?"16BIT ":"",
369 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
370 (map->flags&MAP_0WS)?"0WS ":"",
371 (map->flags&MAP_WRPROT)?"WRPROT ":"",
372 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
373 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
375 if (map->map >= MAX_IO_WIN) {
376 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
381 if (map->flags & MAP_ACTIVE) {
383 speed = SOC_PCMCIA_IO_ACCESS;
388 skt->spd_io[map->map] = speed;
389 skt->ops->set_timing(skt);
392 map->stop = PAGE_SIZE-1;
394 map->stop -= map->start;
395 map->stop += (unsigned long)skt->virt_io;
396 map->start = (unsigned long)skt->virt_io;
403 * Implements the set_mem_map() operation for the in-kernel PCMCIA
404 * service (formerly SS_SetMemMap in Card Services). We configure
405 * the map speed as requested, but override the address ranges
406 * supplied by Card Services.
408 * Returns: 0 on success, -1 on error
411 soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
413 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
414 struct resource *res;
415 unsigned short speed = map->speed;
417 debug(skt, 2, "map %u speed %u card_start %08x\n",
418 map->map, map->speed, map->card_start);
419 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
420 (map->flags==0)?"<NONE>":"",
421 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
422 (map->flags&MAP_16BIT)?"16BIT ":"",
423 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
424 (map->flags&MAP_0WS)?"0WS ":"",
425 (map->flags&MAP_WRPROT)?"WRPROT ":"",
426 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
427 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
429 if (map->map >= MAX_WIN)
432 if (map->flags & MAP_ACTIVE) {
439 if (map->flags & MAP_ATTRIB) {
440 res = &skt->res_attr;
441 skt->spd_attr[map->map] = speed;
442 skt->spd_mem[map->map] = 0;
445 skt->spd_attr[map->map] = 0;
446 skt->spd_mem[map->map] = speed;
449 skt->ops->set_timing(skt);
451 map->sys_stop -= map->sys_start;
452 map->sys_stop += res->start + map->card_start;
453 map->sys_start = res->start + map->card_start;
463 static struct bittbl status_bits[] = {
464 { SS_WRPROT, "SS_WRPROT" },
465 { SS_BATDEAD, "SS_BATDEAD" },
466 { SS_BATWARN, "SS_BATWARN" },
467 { SS_READY, "SS_READY" },
468 { SS_DETECT, "SS_DETECT" },
469 { SS_POWERON, "SS_POWERON" },
470 { SS_STSCHG, "SS_STSCHG" },
471 { SS_3VCARD, "SS_3VCARD" },
472 { SS_XVCARD, "SS_XVCARD" },
475 static struct bittbl conf_bits[] = {
476 { SS_PWR_AUTO, "SS_PWR_AUTO" },
477 { SS_IOCARD, "SS_IOCARD" },
478 { SS_RESET, "SS_RESET" },
479 { SS_DMA_MODE, "SS_DMA_MODE" },
480 { SS_SPKR_ENA, "SS_SPKR_ENA" },
481 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
485 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
490 b += sprintf(b, "%-9s:", prefix);
491 for (i = 0; i < sz; i++)
492 if (val & bits[i].mask)
493 b += sprintf(b, " %s", bits[i].name);
499 * Implements the /sys/class/pcmcia_socket/??/status file.
501 * Returns: the number of characters added to the buffer
503 static ssize_t show_status(struct class_device *class_dev, char *buf)
505 struct soc_pcmcia_socket *skt =
506 container_of(class_dev, struct soc_pcmcia_socket, socket.dev);
509 p+=sprintf(p, "slot : %d\n", skt->nr);
511 dump_bits(&p, "status", skt->status,
512 status_bits, ARRAY_SIZE(status_bits));
513 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
514 status_bits, ARRAY_SIZE(status_bits));
515 dump_bits(&p, "cs_flags", skt->cs_state.flags,
516 conf_bits, ARRAY_SIZE(conf_bits));
518 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
519 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
520 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
521 if (skt->ops->show_timing)
522 p+=skt->ops->show_timing(skt, p);
526 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
529 static struct pccard_operations soc_common_pcmcia_operations = {
530 .init = soc_common_pcmcia_sock_init,
531 .suspend = soc_common_pcmcia_suspend,
532 .get_status = soc_common_pcmcia_get_status,
533 .get_socket = soc_common_pcmcia_get_socket,
534 .set_socket = soc_common_pcmcia_set_socket,
535 .set_io_map = soc_common_pcmcia_set_io_map,
536 .set_mem_map = soc_common_pcmcia_set_mem_map,
540 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
541 struct pcmcia_irqs *irqs, int nr)
545 for (i = 0; i < nr; i++) {
546 if (irqs[i].sock != skt->nr)
548 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
549 SA_INTERRUPT, irqs[i].str, skt);
552 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
556 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
560 if (irqs[i].sock == skt->nr)
561 free_irq(irqs[i].irq, skt);
565 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
567 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
568 struct pcmcia_irqs *irqs, int nr)
572 for (i = 0; i < nr; i++)
573 if (irqs[i].sock == skt->nr)
574 free_irq(irqs[i].irq, skt);
576 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
578 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
579 struct pcmcia_irqs *irqs, int nr)
583 for (i = 0; i < nr; i++)
584 if (irqs[i].sock == skt->nr)
585 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
587 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
589 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
590 struct pcmcia_irqs *irqs, int nr)
594 for (i = 0; i < nr; i++)
595 if (irqs[i].sock == skt->nr) {
596 set_irq_type(irqs[i].irq, IRQT_RISING);
597 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
600 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
603 LIST_HEAD(soc_pcmcia_sockets);
604 DECLARE_MUTEX(soc_pcmcia_sockets_lock);
606 static const char *skt_names[] = {
611 struct skt_dev_info {
613 struct soc_pcmcia_socket skt[0];
616 #define SKT_DEV_INFO_SIZE(n) \
617 (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
619 #ifdef CONFIG_CPU_FREQ
621 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
623 struct soc_pcmcia_socket *skt;
624 struct cpufreq_freqs *freqs = data;
627 down(&soc_pcmcia_sockets_lock);
628 list_for_each_entry(skt, &soc_pcmcia_sockets, node)
629 if ( skt->ops->frequency_change )
630 ret += skt->ops->frequency_change(skt, val, freqs);
631 up(&soc_pcmcia_sockets_lock);
636 static struct notifier_block soc_pcmcia_notifier_block = {
637 .notifier_call = soc_pcmcia_notifier
640 static int soc_pcmcia_cpufreq_register(void)
644 ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
645 CPUFREQ_TRANSITION_NOTIFIER);
647 printk(KERN_ERR "Unable to register CPU frequency change "
648 "notifier for PCMCIA (%d)\n", ret);
652 static void soc_pcmcia_cpufreq_unregister(void)
654 cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
658 #define soc_pcmcia_cpufreq_register()
659 #define soc_pcmcia_cpufreq_unregister()
662 int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
664 struct skt_dev_info *sinfo;
667 down(&soc_pcmcia_sockets_lock);
669 sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
675 memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
679 * Initialise the per-socket structure.
681 for (i = 0; i < nr; i++) {
682 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
684 skt->socket.ops = &soc_common_pcmcia_operations;
685 skt->socket.owner = ops->owner;
686 skt->socket.dev.dev = dev;
688 init_timer(&skt->poll_timer);
689 skt->poll_timer.function = soc_common_pcmcia_poll_event;
690 skt->poll_timer.data = (unsigned long)skt;
691 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
698 skt->res_skt.start = _PCMCIA(skt->nr);
699 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
700 skt->res_skt.name = skt_names[skt->nr];
701 skt->res_skt.flags = IORESOURCE_MEM;
703 ret = request_resource(&iomem_resource, &skt->res_skt);
707 skt->res_io.start = _PCMCIAIO(skt->nr);
708 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
709 skt->res_io.name = "io";
710 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
712 ret = request_resource(&skt->res_skt, &skt->res_io);
716 skt->res_mem.start = _PCMCIAMem(skt->nr);
717 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
718 skt->res_mem.name = "memory";
719 skt->res_mem.flags = IORESOURCE_MEM;
721 ret = request_resource(&skt->res_skt, &skt->res_mem);
725 skt->res_attr.start = _PCMCIAAttr(skt->nr);
726 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
727 skt->res_attr.name = "attribute";
728 skt->res_attr.flags = IORESOURCE_MEM;
730 ret = request_resource(&skt->res_skt, &skt->res_attr);
734 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
735 if (skt->virt_io == NULL) {
740 if ( list_empty(&soc_pcmcia_sockets) )
741 soc_pcmcia_cpufreq_register();
743 list_add(&skt->node, &soc_pcmcia_sockets);
746 * We initialize default socket timing here, because
747 * we are not guaranteed to see a SetIOMap operation at
750 ops->set_timing(skt);
752 ret = ops->hw_init(skt);
756 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
757 skt->socket.irq_mask = 0;
758 skt->socket.map_size = PAGE_SIZE;
759 skt->socket.pci_irq = skt->irq;
760 skt->socket.io_offset = (unsigned long)skt->virt_io;
762 skt->status = soc_common_pcmcia_skt_state(skt);
764 ret = pcmcia_register_socket(&skt->socket);
768 WARN_ON(skt->socket.sock != i);
770 add_timer(&skt->poll_timer);
772 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
775 dev_set_drvdata(dev, sinfo);
780 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
782 del_timer_sync(&skt->poll_timer);
783 pcmcia_unregister_socket(&skt->socket);
786 flush_scheduled_work();
788 ops->hw_shutdown(skt);
790 list_del(&skt->node);
791 iounmap(skt->virt_io);
793 release_resource(&skt->res_attr);
795 release_resource(&skt->res_mem);
797 release_resource(&skt->res_io);
799 release_resource(&skt->res_skt);
807 up(&soc_pcmcia_sockets_lock);
811 int soc_common_drv_pcmcia_remove(struct device *dev)
813 struct skt_dev_info *sinfo = dev_get_drvdata(dev);
816 dev_set_drvdata(dev, NULL);
818 down(&soc_pcmcia_sockets_lock);
819 for (i = 0; i < sinfo->nskt; i++) {
820 struct soc_pcmcia_socket *skt = &sinfo->skt[i];
822 del_timer_sync(&skt->poll_timer);
824 pcmcia_unregister_socket(&skt->socket);
826 flush_scheduled_work();
828 skt->ops->hw_shutdown(skt);
830 soc_common_pcmcia_config_skt(skt, &dead_socket);
832 list_del(&skt->node);
833 iounmap(skt->virt_io);
835 release_resource(&skt->res_attr);
836 release_resource(&skt->res_mem);
837 release_resource(&skt->res_io);
838 release_resource(&skt->res_skt);
840 if ( list_empty(&soc_pcmcia_sockets) )
841 soc_pcmcia_cpufreq_unregister();
843 up(&soc_pcmcia_sockets_lock);