soc_common.c

  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/gpio.h>
 36#include <linux/gpio/consumer.h>
 37#include <linux/init.h>
 38#include <linux/interrupt.h>
 39#include <linux/io.h>
 40#include <linux/irq.h>
 41#include <linux/kernel.h>
 42#include <linux/mm.h>
 43#include <linux/module.h>
 44#include <linux/moduleparam.h>
 45#include <linux/mutex.h>
 46#include <linux/regulator/consumer.h>
 47#include <linux/spinlock.h>
 48#include <linux/timer.h>
 49#include <linux/pci.h>
 50
 51#include "soc_common.h"
 52
 53static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev);
 54
 55#ifdef CONFIG_PCMCIA_DEBUG
 56
 57static int pc_debug;
 58module_param(pc_debug, int, 0644);
 59
 60void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
 61		      int lvl, const char *fmt, ...)
 62{
 63	struct va_format vaf;
 64	va_list args;
 65	if (pc_debug > lvl) {
 66		va_start(args, fmt);
 67
 68		vaf.fmt = fmt;
 69		vaf.va = &args;
 70
 71		printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf);
 72
 73		va_end(args);
 74	}
 75}
 76EXPORT_SYMBOL(soc_pcmcia_debug);
 77
 78#endif
 79
 80#define to_soc_pcmcia_socket(x)	\
 81	container_of(x, struct soc_pcmcia_socket, socket)
 82
 83int soc_pcmcia_regulator_set(struct soc_pcmcia_socket *skt,
 84	struct soc_pcmcia_regulator *r, int v)
 85{
 86	bool on;
 87	int ret;
 88
 89	if (!r->reg)
 90		return 0;
 91
 92	on = v != 0;
 93	if (r->on == on)
 94		return 0;
 95
 96	if (on) {
 97		ret = regulator_set_voltage(r->reg, v * 100000, v * 100000);
 98		if (ret) {
 99			int vout = regulator_get_voltage(r->reg) / 100000;
100
101			dev_warn(&skt->socket.dev,
102				 "CS requested %s=%u.%uV, applying %u.%uV\n",
103				 r == &skt->vcc ? "Vcc" : "Vpp",
104				 v / 10, v % 10, vout / 10, vout % 10);
105		}
106
107		ret = regulator_enable(r->reg);
108	} else {
109		ret = regulator_disable(r->reg);
110	}
111	if (ret == 0)
112		r->on = on;
113
114	return ret;
115}
116EXPORT_SYMBOL_GPL(soc_pcmcia_regulator_set);
117
118static unsigned short
119calc_speed(unsigned short *spds, int num, unsigned short dflt)
120{
121	unsigned short speed = 0;
122	int i;
123
124	for (i = 0; i < num; i++)
125		if (speed < spds[i])
126			speed = spds[i];
127	if (speed == 0)
128		speed = dflt;
129
130	return speed;
131}
132
133void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
134	struct soc_pcmcia_timing *timing)
135{
136	timing->io =
137		calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
138	timing->mem =
139		calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
140	timing->attr =
141		calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
142}
143EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
144
145static void __soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt,
146	unsigned int nr)
147{
148	unsigned int i;
149
150	for (i = 0; i < nr; i++)
151		if (skt->stat[i].irq)
152			free_irq(skt->stat[i].irq, skt);
153
154	if (skt->ops->hw_shutdown)
155		skt->ops->hw_shutdown(skt);
156
157	clk_disable_unprepare(skt->clk);
158}
159
160static void soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
161{
162	__soc_pcmcia_hw_shutdown(skt, ARRAY_SIZE(skt->stat));
163}
164
165int soc_pcmcia_request_gpiods(struct soc_pcmcia_socket *skt)
166{
167	struct device *dev = skt->socket.dev.parent;
168	struct gpio_desc *desc;
169	int i;
170
171	for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
172		if (!skt->stat[i].name)
173			continue;
174
175		desc = devm_gpiod_get(dev, skt->stat[i].name, GPIOD_IN);
176		if (IS_ERR(desc)) {
177			dev_err(dev, "Failed to get GPIO for %s: %ld\n",
178				skt->stat[i].name, PTR_ERR(desc));
179			return PTR_ERR(desc);
180		}
181
182		skt->stat[i].desc = desc;
183	}
184
185	return 0;
186}
187EXPORT_SYMBOL_GPL(soc_pcmcia_request_gpiods);
188
189static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
190{
191	int ret = 0, i;
192
193	ret = clk_prepare_enable(skt->clk);
194	if (ret)
195		return ret;
196
197	if (skt->ops->hw_init) {
198		ret = skt->ops->hw_init(skt);
199		if (ret) {
200			clk_disable_unprepare(skt->clk);
201			return ret;
202		}
203	}
204
205	for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
206		if (gpio_is_valid(skt->stat[i].gpio)) {
207			ret = devm_gpio_request_one(skt->socket.dev.parent,
208						    skt->stat[i].gpio, GPIOF_IN,
209						    skt->stat[i].name);
210			if (ret) {
211				__soc_pcmcia_hw_shutdown(skt, i);
212				return ret;
213			}
214
215			skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio);
216
217			/* CD is active low by default */
218			if ((i == SOC_STAT_CD) ^ gpiod_is_active_low(skt->stat[i].desc))
219				gpiod_toggle_active_low(skt->stat[i].desc);
220		}
221
222		if (i < SOC_STAT_VS1 && skt->stat[i].desc) {
223			int irq = gpiod_to_irq(skt->stat[i].desc);
224
225			if (irq > 0) {
226				if (i == SOC_STAT_RDY)
227					skt->socket.pci_irq = irq;
228				else
229					skt->stat[i].irq = irq;
230			}
231		}
232
233		if (skt->stat[i].irq) {
234			ret = request_irq(skt->stat[i].irq,
235					  soc_common_pcmcia_interrupt,
236					  IRQF_TRIGGER_NONE,
237					  skt->stat[i].name, skt);
238			if (ret) {
239				__soc_pcmcia_hw_shutdown(skt, i);
240				return ret;
241			}
242		}
243	}
244
245	return ret;
246}
247
248static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt)
249{
250	int i;
251
252	for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
253		if (skt->stat[i].irq) {
254			irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING);
255			irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH);
256		}
257}
258
259static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt)
260{
261	int i;
262
263	for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
264		if (skt->stat[i].irq)
265			irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE);
266}
267
268/*
269 * The CF 3.0 specification says that cards tie VS1 to ground and leave
270 * VS2 open.  Many implementations do not wire up the VS signals, so we
271 * provide hard-coded values as per the CF 3.0 spec.
272 */
273void soc_common_cf_socket_state(struct soc_pcmcia_socket *skt,
274	struct pcmcia_state *state)
275{
276	state->vs_3v = 1;
277}
278EXPORT_SYMBOL_GPL(soc_common_cf_socket_state);
279
280static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
281{
282	struct pcmcia_state state;
283	unsigned int stat;
284
285	memset(&state, 0, sizeof(struct pcmcia_state));
286
287	/* Make battery voltage state report 'good' */
288	state.bvd1 = 1;
289	state.bvd2 = 1;
290
291	if (skt->stat[SOC_STAT_CD].desc)
292		state.detect = !!gpiod_get_value(skt->stat[SOC_STAT_CD].desc);
293	if (skt->stat[SOC_STAT_RDY].desc)
294		state.ready = !!gpiod_get_value(skt->stat[SOC_STAT_RDY].desc);
295	if (skt->stat[SOC_STAT_BVD1].desc)
296		state.bvd1 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD1].desc);
297	if (skt->stat[SOC_STAT_BVD2].desc)
298		state.bvd2 = !!gpiod_get_value(skt->stat[SOC_STAT_BVD2].desc);
299	if (skt->stat[SOC_STAT_VS1].desc)
300		state.vs_3v = !!gpiod_get_value(skt->stat[SOC_STAT_VS1].desc);
301	if (skt->stat[SOC_STAT_VS2].desc)
302		state.vs_Xv = !!gpiod_get_value(skt->stat[SOC_STAT_VS2].desc);
303
304	skt->ops->socket_state(skt, &state);
305
306	stat = state.detect  ? SS_DETECT : 0;
307	stat |= state.ready  ? SS_READY  : 0;
308	stat |= state.wrprot ? SS_WRPROT : 0;
309	stat |= state.vs_3v  ? SS_3VCARD : 0;
310	stat |= state.vs_Xv  ? SS_XVCARD : 0;
311
312	/* The power status of individual sockets is not available
313	 * explicitly from the hardware, so we just remember the state
314	 * and regurgitate it upon request:
315	 */
316	stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
317
318	if (skt->cs_state.flags & SS_IOCARD)
319		stat |= state.bvd1 ? 0 : SS_STSCHG;
320	else {
321		if (state.bvd1 == 0)
322			stat |= SS_BATDEAD;
323		else if (state.bvd2 == 0)
324			stat |= SS_BATWARN;
325	}
326	return stat;
327}
328
329/*
330 * soc_common_pcmcia_config_skt
331 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
332 *
333 * Convert PCMCIA socket state to our socket configure structure.
334 */
335static int soc_common_pcmcia_config_skt(
336	struct soc_pcmcia_socket *skt, socket_state_t *state)
337{
338	int ret;
339
340	ret = skt->ops->configure_socket(skt, state);
341	if (ret < 0) {
342		pr_err("soc_common_pcmcia: unable to configure socket %d\n",
343		       skt->nr);
344		/* restore the previous state */
345		WARN_ON(skt->ops->configure_socket(skt, &skt->cs_state));
346		return ret;
347	}
348
349	if (ret == 0) {
350		struct gpio_desc *descs[2];
351		DECLARE_BITMAP(values, 2);
352		int n = 0;
353
354		if (skt->gpio_reset) {
355			descs[n] = skt->gpio_reset;
356			__assign_bit(n++, values, state->flags & SS_RESET);
357		}
358		if (skt->gpio_bus_enable) {
359			descs[n] = skt->gpio_bus_enable;
360			__assign_bit(n++, values, state->flags & SS_OUTPUT_ENA);
361		}
362
363		if (n)
364			gpiod_set_array_value_cansleep(n, descs, NULL, values);
365
366		/*
367		 * This really needs a better solution.  The IRQ
368		 * may or may not be claimed by the driver.
369		 */
370		if (skt->irq_state != 1 && state->io_irq) {
371			skt->irq_state = 1;
372			irq_set_irq_type(skt->socket.pci_irq,
373					 IRQ_TYPE_EDGE_FALLING);
374		} else if (skt->irq_state == 1 && state->io_irq == 0) {
375			skt->irq_state = 0;
376			irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
377		}
378
379		skt->cs_state = *state;
380	}
381
382	return ret;
383}
384
385/* soc_common_pcmcia_sock_init()
386 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
387 *
388 * (Re-)Initialise the socket, turning on status interrupts
389 * and PCMCIA bus.  This must wait for power to stabilise
390 * so that the card status signals report correctly.
391 *
392 * Returns: 0
393 */
394static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
395{
396	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
397
398	debug(skt, 2, "initializing socket\n");
399	if (skt->ops->socket_init)
400		skt->ops->socket_init(skt);
401	soc_pcmcia_hw_enable(skt);
402	return 0;
403}
404
405
406/*
407 * soc_common_pcmcia_suspend()
408 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
409 *
410 * Remove power on the socket, disable IRQs from the card.
411 * Turn off status interrupts, and disable the PCMCIA bus.
412 *
413 * Returns: 0
414 */
415static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
416{
417	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
418
419	debug(skt, 2, "suspending socket\n");
420
421	soc_pcmcia_hw_disable(skt);
422	if (skt->ops->socket_suspend)
423		skt->ops->socket_suspend(skt);
424
425	return 0;
426}
427
428static DEFINE_SPINLOCK(status_lock);
429
430static void soc_common_check_status(struct soc_pcmcia_socket *skt)
431{
432	unsigned int events;
433
434	debug(skt, 4, "entering PCMCIA monitoring thread\n");
435
436	do {
437		unsigned int status;
438		unsigned long flags;
439
440		status = soc_common_pcmcia_skt_state(skt);
441
442		spin_lock_irqsave(&status_lock, flags);
443		events = (status ^ skt->status) & skt->cs_state.csc_mask;
444		skt->status = status;
445		spin_unlock_irqrestore(&status_lock, flags);
446
447		debug(skt, 4, "events: %s%s%s%s%s%s\n",
448			events == 0         ? "<NONE>"   : "",
449			events & SS_DETECT  ? "DETECT "  : "",
450			events & SS_READY   ? "READY "   : "",
451			events & SS_BATDEAD ? "BATDEAD " : "",
452			events & SS_BATWARN ? "BATWARN " : "",
453			events & SS_STSCHG  ? "STSCHG "  : "");
454
455		if (events)
456			pcmcia_parse_events(&skt->socket, events);
457	} while (events);
458}
459
460/* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
461static void soc_common_pcmcia_poll_event(struct timer_list *t)
462{
463	struct soc_pcmcia_socket *skt = timer_container_of(skt, t, poll_timer);
464	debug(skt, 4, "polling for events\n");
465
466	mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
467
468	soc_common_check_status(skt);
469}
470
471
472/*
473 * Service routine for socket driver interrupts (requested by the
474 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
475 * The actual interrupt-servicing work is performed by
476 * soc_common_pcmcia_thread(), largely because the Card Services event-
477 * handling code performs scheduling operations which cannot be
478 * executed from within an interrupt context.
479 */
480static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
481{
482	struct soc_pcmcia_socket *skt = dev;
483
484	debug(skt, 3, "servicing IRQ %d\n", irq);
485
486	soc_common_check_status(skt);
487
488	return IRQ_HANDLED;
489}
490
491
492/*
493 *  Implements the get_status() operation for the in-kernel PCMCIA
494 * service (formerly SS_GetStatus in Card Services). Essentially just
495 * fills in bits in `status' according to internal driver state or
496 * the value of the voltage detect chipselect register.
497 *
498 * As a debugging note, during card startup, the PCMCIA core issues
499 * three set_socket() commands in a row the first with RESET deasserted,
500 * the second with RESET asserted, and the last with RESET deasserted
501 * again. Following the third set_socket(), a get_status() command will
502 * be issued. The kernel is looking for the SS_READY flag (see
503 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
504 *
505 * Returns: 0
506 */
507static int
508soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
509{
510	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
511
512	skt->status = soc_common_pcmcia_skt_state(skt);
513	*status = skt->status;
514
515	return 0;
516}
517
518
519/*
520 * Implements the set_socket() operation for the in-kernel PCMCIA
521 * service (formerly SS_SetSocket in Card Services). We more or
522 * less punt all of this work and let the kernel handle the details
523 * of power configuration, reset, &c. We also record the value of
524 * `state' in order to regurgitate it to the PCMCIA core later.
525 */
526static int soc_common_pcmcia_set_socket(
527	struct pcmcia_socket *sock, socket_state_t *state)
528{
529	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
530
531	debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
532			(state->csc_mask == 0)		? "<NONE> " :	"",
533			(state->csc_mask & SS_DETECT)	? "DETECT " :	"",
534			(state->csc_mask & SS_READY)	? "READY " :	"",
535			(state->csc_mask & SS_BATDEAD)	? "BATDEAD " :	"",
536			(state->csc_mask & SS_BATWARN)	? "BATWARN " :	"",
537			(state->csc_mask & SS_STSCHG)	? "STSCHG " :	"",
538			(state->flags == 0)		? "<NONE> " :	"",
539			(state->flags & SS_PWR_AUTO)	? "PWR_AUTO " :	"",
540			(state->flags & SS_IOCARD)	? "IOCARD " :	"",
541			(state->flags & SS_RESET)	? "RESET " :	"",
542			(state->flags & SS_SPKR_ENA)	? "SPKR_ENA " :	"",
543			(state->flags & SS_OUTPUT_ENA)	? "OUTPUT_ENA " : "",
544			state->Vcc, state->Vpp, state->io_irq);
545
546	return soc_common_pcmcia_config_skt(skt, state);
547}
548
549
550/*
551 * Implements the set_io_map() operation for the in-kernel PCMCIA
552 * service (formerly SS_SetIOMap in Card Services). We configure
553 * the map speed as requested, but override the address ranges
554 * supplied by Card Services.
555 *
556 * Returns: 0 on success, -1 on error
557 */
558static int soc_common_pcmcia_set_io_map(
559	struct pcmcia_socket *sock, struct pccard_io_map *map)
560{
561	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
562	unsigned short speed = map->speed;
563
564	debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
565		map->map, map->speed, (unsigned long long)map->start,
566		(unsigned long long)map->stop);
567	debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
568		(map->flags == 0)		? "<NONE>"	: "",
569		(map->flags & MAP_ACTIVE)	? "ACTIVE "	: "",
570		(map->flags & MAP_16BIT)	? "16BIT "	: "",
571		(map->flags & MAP_AUTOSZ)	? "AUTOSZ "	: "",
572		(map->flags & MAP_0WS)		? "0WS "	: "",
573		(map->flags & MAP_WRPROT)	? "WRPROT "	: "",
574		(map->flags & MAP_USE_WAIT)	? "USE_WAIT "	: "",
575		(map->flags & MAP_PREFETCH)	? "PREFETCH "	: "");
576
577	if (map->map >= MAX_IO_WIN) {
578		printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
579		       map->map);
580		return -1;
581	}
582
583	if (map->flags & MAP_ACTIVE) {
584		if (speed == 0)
585			speed = SOC_PCMCIA_IO_ACCESS;
586	} else {
587		speed = 0;
588	}
589
590	skt->spd_io[map->map] = speed;
591	skt->ops->set_timing(skt);
592
593	if (map->stop == 1)
594		map->stop = PAGE_SIZE-1;
595
596	map->stop -= map->start;
597	map->stop += skt->socket.io_offset;
598	map->start = skt->socket.io_offset;
599
600	return 0;
601}
602
603
604/*
605 * Implements the set_mem_map() operation for the in-kernel PCMCIA
606 * service (formerly SS_SetMemMap in Card Services). We configure
607 * the map speed as requested, but override the address ranges
608 * supplied by Card Services.
609 *
610 * Returns: 0 on success, -ERRNO on error
611 */
612static int soc_common_pcmcia_set_mem_map(
613	struct pcmcia_socket *sock, struct pccard_mem_map *map)
614{
615	struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
616	struct resource *res;
617	unsigned short speed = map->speed;
618
619	debug(skt, 2, "map %u speed %u card_start %08x\n",
620		map->map, map->speed, map->card_start);
621	debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
622		(map->flags == 0)		? "<NONE>"	: "",
623		(map->flags & MAP_ACTIVE)	? "ACTIVE "	: "",
624		(map->flags & MAP_16BIT)	? "16BIT "	: "",
625		(map->flags & MAP_AUTOSZ)	? "AUTOSZ "	: "",
626		(map->flags & MAP_0WS)		? "0WS "	: "",
627		(map->flags & MAP_WRPROT)	? "WRPROT "	: "",
628		(map->flags & MAP_ATTRIB)	? "ATTRIB "	: "",
629		(map->flags & MAP_USE_WAIT)	? "USE_WAIT "	: "");
630
631	if (map->map >= MAX_WIN)
632		return -EINVAL;
633
634	if (map->flags & MAP_ACTIVE) {
635		if (speed == 0)
636			speed = 300;
637	} else {
638		speed = 0;
639	}
640
641	if (map->flags & MAP_ATTRIB) {
642		res = &skt->res_attr;
643		skt->spd_attr[map->map] = speed;
644		skt->spd_mem[map->map] = 0;
645	} else {
646		res = &skt->res_mem;
647		skt->spd_attr[map->map] = 0;
648		skt->spd_mem[map->map] = speed;
649	}
650
651	skt->ops->set_timing(skt);
652
653	map->static_start = res->start + map->card_start;
654
655	return 0;
656}
657
658struct bittbl {
659	unsigned int mask;
660	const char *name;
661};
662
663static struct bittbl status_bits[] = {
664	{ SS_WRPROT,		"SS_WRPROT"	},
665	{ SS_BATDEAD,		"SS_BATDEAD"	},
666	{ SS_BATWARN,		"SS_BATWARN"	},
667	{ SS_READY,		"SS_READY"	},
668	{ SS_DETECT,		"SS_DETECT"	},
669	{ SS_POWERON,		"SS_POWERON"	},
670	{ SS_STSCHG,		"SS_STSCHG"	},
671	{ SS_3VCARD,		"SS_3VCARD"	},
672	{ SS_XVCARD,		"SS_XVCARD"	},
673};
674
675static struct bittbl conf_bits[] = {
676	{ SS_PWR_AUTO,		"SS_PWR_AUTO"	},
677	{ SS_IOCARD,		"SS_IOCARD"	},
678	{ SS_RESET,		"SS_RESET"	},
679	{ SS_DMA_MODE,		"SS_DMA_MODE"	},
680	{ SS_SPKR_ENA,		"SS_SPKR_ENA"	},
681	{ SS_OUTPUT_ENA,	"SS_OUTPUT_ENA"	},
682};
683
684static void dump_bits(char **p, const char *prefix,
685	unsigned int val, struct bittbl *bits, int sz)
686{
687	char *b = *p;
688	int i;
689
690	b += sprintf(b, "%-9s:", prefix);
691	for (i = 0; i < sz; i++)
692		if (val & bits[i].mask)
693			b += sprintf(b, " %s", bits[i].name);
694	*b++ = '\n';
695	*p = b;
696}
697
698/*
699 * Implements the /sys/class/pcmcia_socket/??/status file.
700 *
701 * Returns: the number of characters added to the buffer
702 */
703static ssize_t show_status(
704	struct device *dev, struct device_attribute *attr, char *buf)
705{
706	struct soc_pcmcia_socket *skt =
707		container_of(dev, struct soc_pcmcia_socket, socket.dev);
708	char *p = buf;
709
710	p += sprintf(p, "slot     : %d\n", skt->nr);
711
712	dump_bits(&p, "status", skt->status,
713		  status_bits, ARRAY_SIZE(status_bits));
714	dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
715		  status_bits, ARRAY_SIZE(status_bits));
716	dump_bits(&p, "cs_flags", skt->cs_state.flags,
717		  conf_bits, ARRAY_SIZE(conf_bits));
718
719	p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
720	p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
721	p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
722		skt->socket.pci_irq);
723	if (skt->ops->show_timing)
724		p += skt->ops->show_timing(skt, p);
725
726	return p-buf;
727}
728static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
729
730
731static struct pccard_operations soc_common_pcmcia_operations = {
732	.init			= soc_common_pcmcia_sock_init,
733	.suspend		= soc_common_pcmcia_suspend,
734	.get_status		= soc_common_pcmcia_get_status,
735	.set_socket		= soc_common_pcmcia_set_socket,
736	.set_io_map		= soc_common_pcmcia_set_io_map,
737	.set_mem_map		= soc_common_pcmcia_set_mem_map,
738};
739
740
741#ifdef CONFIG_CPU_FREQ
742static int soc_common_pcmcia_cpufreq_nb(struct notifier_block *nb,
743	unsigned long val, void *data)
744{
745	struct soc_pcmcia_socket *skt = container_of(nb, struct soc_pcmcia_socket, cpufreq_nb);
746	struct cpufreq_freqs *freqs = data;
747
748	return skt->ops->frequency_change(skt, val, freqs);
749}
750#endif
751
752void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt,
753	const struct pcmcia_low_level *ops, struct device *dev)
754{
755	int i;
756
757	skt->ops = ops;
758	skt->socket.owner = ops->owner;
759	skt->socket.dev.parent = dev;
760	skt->socket.pci_irq = NO_IRQ;
761
762	for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
763		skt->stat[i].gpio = -EINVAL;
764}
765EXPORT_SYMBOL(soc_pcmcia_init_one);
766
767void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
768{
769	timer_delete_sync(&skt->poll_timer);
770
771	pcmcia_unregister_socket(&skt->socket);
772
773#ifdef CONFIG_CPU_FREQ
774	if (skt->ops->frequency_change)
775		cpufreq_unregister_notifier(&skt->cpufreq_nb,
776					    CPUFREQ_TRANSITION_NOTIFIER);
777#endif
778
779	soc_pcmcia_hw_shutdown(skt);
780
781	/* should not be required; violates some lowlevel drivers */
782	soc_common_pcmcia_config_skt(skt, &dead_socket);
783
784	iounmap(PCI_IOBASE + skt->res_io_io.start);
785	release_resource(&skt->res_attr);
786	release_resource(&skt->res_mem);
787	release_resource(&skt->res_io);
788	release_resource(&skt->res_skt);
789}
790EXPORT_SYMBOL(soc_pcmcia_remove_one);
791
792int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
793{
794	int ret;
795
796	skt->cs_state = dead_socket;
797
798	timer_setup(&skt->poll_timer, soc_common_pcmcia_poll_event, 0);
799	skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
800
801	ret = request_resource(&iomem_resource, &skt->res_skt);
802	if (ret)
803		goto out_err_1;
804
805	ret = request_resource(&skt->res_skt, &skt->res_io);
806	if (ret)
807		goto out_err_2;
808
809	ret = request_resource(&skt->res_skt, &skt->res_mem);
810	if (ret)
811		goto out_err_3;
812
813	ret = request_resource(&skt->res_skt, &skt->res_attr);
814	if (ret)
815		goto out_err_4;
816
817	skt->res_io_io = (struct resource)
818		 DEFINE_RES_IO_NAMED(skt->nr * 0x1000 + 0x10000, 0x1000,
819				     "PCMCIA I/O");
820	ret = pci_remap_iospace(&skt->res_io_io, skt->res_io.start);
821	if (ret)
822		goto out_err_5;
823
824	/*
825	 * We initialize default socket timing here, because
826	 * we are not guaranteed to see a SetIOMap operation at
827	 * runtime.
828	 */
829	skt->ops->set_timing(skt);
830
831	ret = soc_pcmcia_hw_init(skt);
832	if (ret)
833		goto out_err_6;
834
835	skt->socket.ops = &soc_common_pcmcia_operations;
836	skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
837	skt->socket.resource_ops = &pccard_static_ops;
838	skt->socket.irq_mask = 0;
839	skt->socket.map_size = PAGE_SIZE;
840	skt->socket.io_offset = (unsigned long)skt->res_io_io.start;
841
842	skt->status = soc_common_pcmcia_skt_state(skt);
843
844#ifdef CONFIG_CPU_FREQ
845	if (skt->ops->frequency_change) {
846		skt->cpufreq_nb.notifier_call = soc_common_pcmcia_cpufreq_nb;
847
848		ret = cpufreq_register_notifier(&skt->cpufreq_nb,
849						CPUFREQ_TRANSITION_NOTIFIER);
850		if (ret < 0)
851			dev_err(skt->socket.dev.parent,
852				"unable to register CPU frequency change notifier for PCMCIA (%d)\n",
853				ret);
854	}
855#endif
856
857	ret = pcmcia_register_socket(&skt->socket);
858	if (ret)
859		goto out_err_7;
860
861	ret = device_create_file(&skt->socket.dev, &dev_attr_status);
862	if (ret)
863		goto out_err_8;
864
865	return ret;
866
867 out_err_8:
868	timer_delete_sync(&skt->poll_timer);
869	pcmcia_unregister_socket(&skt->socket);
870
871 out_err_7:
872	soc_pcmcia_hw_shutdown(skt);
873 out_err_6:
874	iounmap(PCI_IOBASE + skt->res_io_io.start);
875 out_err_5:
876	release_resource(&skt->res_attr);
877 out_err_4:
878	release_resource(&skt->res_mem);
879 out_err_3:
880	release_resource(&skt->res_io);
881 out_err_2:
882	release_resource(&skt->res_skt);
883 out_err_1:
884
885	return ret;
886}
887EXPORT_SYMBOL(soc_pcmcia_add_one);
888
889MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
890MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
891MODULE_LICENSE("Dual MPL/GPL");