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