PageRenderTime 57ms CodeModel.GetById 34ms app.highlight 20ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/pcmcia/soc_common.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 757 lines | 500 code | 137 blank | 120 comment | 77 complexity | ea0c3286f02ee55d1982968c0b7f3c3e MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  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");