blob: a2bc6ee1702e14f2c722b510c304863c7b9d0060 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*======================================================================
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
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +010034#include <linux/cpufreq.h>
Russell Kingd9dc8782011-12-19 22:00:22 +000035#include <linux/gpio.h>
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +010036#include <linux/init.h>
37#include <linux/interrupt.h>
38#include <linux/io.h>
39#include <linux/irq.h>
40#include <linux/kernel.h>
41#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/module.h>
43#include <linux/moduleparam.h>
Andrew Morton23d077e2008-05-01 04:34:54 -070044#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/spinlock.h>
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +010046#include <linux/timer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Russell Kinga09e64f2008-08-05 16:14:15 +010048#include <mach/hardware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#include "soc_common.h"
51
Russell Kingd9dc8782011-12-19 22:00:22 +000052static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev);
53
Dominik Brodowski7d16b652008-08-02 21:02:01 +020054#ifdef CONFIG_PCMCIA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56static int pc_debug;
57module_param(pc_debug, int, 0644);
58
59void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
60 int lvl, const char *fmt, ...)
61{
Joe Perches106665d2010-11-09 17:14:01 -080062 struct va_format vaf;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 va_list args;
64 if (pc_debug > lvl) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 va_start(args, fmt);
Joe Perches106665d2010-11-09 17:14:01 -080066
67 vaf.fmt = fmt;
68 vaf.va = &args;
69
70 printk(KERN_DEBUG "skt%u: %s: %pV", skt->nr, func, &vaf);
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 va_end(args);
73 }
74}
Marcelo Roberto Jimenezb9f515e2010-10-18 22:38:08 +010075EXPORT_SYMBOL(soc_pcmcia_debug);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77#endif
78
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +010079#define to_soc_pcmcia_socket(x) \
80 container_of(x, struct soc_pcmcia_socket, socket)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82static unsigned short
83calc_speed(unsigned short *spds, int num, unsigned short dflt)
84{
85 unsigned short speed = 0;
86 int i;
87
88 for (i = 0; i < num; i++)
89 if (speed < spds[i])
90 speed = spds[i];
91 if (speed == 0)
92 speed = dflt;
93
94 return speed;
95}
96
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +010097void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt,
98 struct soc_pcmcia_timing *timing)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100100 timing->io =
101 calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
102 timing->mem =
103 calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
104 timing->attr =
105 calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
108
Russell Kingd9dc8782011-12-19 22:00:22 +0000109static void __soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt,
110 unsigned int nr)
111{
112 unsigned int i;
113
114 for (i = 0; i < nr; i++) {
115 if (skt->stat[i].irq)
116 free_irq(skt->stat[i].irq, skt);
117 if (gpio_is_valid(skt->stat[i].gpio))
118 gpio_free(skt->stat[i].gpio);
119 }
120
121 if (skt->ops->hw_shutdown)
122 skt->ops->hw_shutdown(skt);
123}
124
125static void soc_pcmcia_hw_shutdown(struct soc_pcmcia_socket *skt)
126{
127 __soc_pcmcia_hw_shutdown(skt, ARRAY_SIZE(skt->stat));
128}
129
130static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
131{
132 int ret = 0, i;
133
134 if (skt->ops->hw_init) {
135 ret = skt->ops->hw_init(skt);
136 if (ret)
137 return ret;
138 }
139
140 for (i = 0; i < ARRAY_SIZE(skt->stat); i++) {
141 if (gpio_is_valid(skt->stat[i].gpio)) {
142 int irq;
143
144 ret = gpio_request_one(skt->stat[i].gpio, GPIOF_IN,
145 skt->stat[i].name);
146 if (ret) {
147 __soc_pcmcia_hw_shutdown(skt, i);
148 return ret;
149 }
150
151 irq = gpio_to_irq(skt->stat[i].gpio);
152
153 if (i == SOC_STAT_RDY)
154 skt->socket.pci_irq = irq;
155 else
156 skt->stat[i].irq = irq;
157 }
158
159 if (skt->stat[i].irq) {
160 ret = request_irq(skt->stat[i].irq,
161 soc_common_pcmcia_interrupt,
162 IRQF_TRIGGER_NONE,
163 skt->stat[i].name, skt);
164 if (ret) {
165 if (gpio_is_valid(skt->stat[i].gpio))
166 gpio_free(skt->stat[i].gpio);
167 __soc_pcmcia_hw_shutdown(skt, i);
168 return ret;
169 }
170 }
171 }
172
173 return ret;
174}
175
176static void soc_pcmcia_hw_enable(struct soc_pcmcia_socket *skt)
177{
178 int i;
179
180 for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
181 if (skt->stat[i].irq) {
182 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_RISING);
183 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_EDGE_BOTH);
184 }
185}
186
187static void soc_pcmcia_hw_disable(struct soc_pcmcia_socket *skt)
188{
189 int i;
190
191 for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
192 if (skt->stat[i].irq)
193 irq_set_irq_type(skt->stat[i].irq, IRQ_TYPE_NONE);
194}
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
197{
198 struct pcmcia_state state;
199 unsigned int stat;
200
201 memset(&state, 0, sizeof(struct pcmcia_state));
202
Russell Kingd9dc8782011-12-19 22:00:22 +0000203 /* Make battery voltage state report 'good' */
204 state.bvd1 = 1;
205 state.bvd2 = 1;
206
207 /* CD is active low by default */
208 if (gpio_is_valid(skt->stat[SOC_STAT_CD].gpio))
209 state.detect = !gpio_get_value(skt->stat[SOC_STAT_CD].gpio);
210
211 /* RDY and BVD are active high by default */
212 if (gpio_is_valid(skt->stat[SOC_STAT_RDY].gpio))
213 state.ready = !!gpio_get_value(skt->stat[SOC_STAT_RDY].gpio);
214 if (gpio_is_valid(skt->stat[SOC_STAT_BVD1].gpio))
215 state.bvd1 = !!gpio_get_value(skt->stat[SOC_STAT_BVD1].gpio);
216 if (gpio_is_valid(skt->stat[SOC_STAT_BVD2].gpio))
217 state.bvd2 = !!gpio_get_value(skt->stat[SOC_STAT_BVD2].gpio);
218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 skt->ops->socket_state(skt, &state);
220
221 stat = state.detect ? SS_DETECT : 0;
222 stat |= state.ready ? SS_READY : 0;
223 stat |= state.wrprot ? SS_WRPROT : 0;
224 stat |= state.vs_3v ? SS_3VCARD : 0;
225 stat |= state.vs_Xv ? SS_XVCARD : 0;
226
227 /* The power status of individual sockets is not available
228 * explicitly from the hardware, so we just remember the state
229 * and regurgitate it upon request:
230 */
231 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
232
233 if (skt->cs_state.flags & SS_IOCARD)
234 stat |= state.bvd1 ? SS_STSCHG : 0;
235 else {
236 if (state.bvd1 == 0)
237 stat |= SS_BATDEAD;
238 else if (state.bvd2 == 0)
239 stat |= SS_BATWARN;
240 }
241 return stat;
242}
243
244/*
245 * soc_common_pcmcia_config_skt
246 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
247 *
248 * Convert PCMCIA socket state to our socket configure structure.
249 */
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100250static int soc_common_pcmcia_config_skt(
251 struct soc_pcmcia_socket *skt, socket_state_t *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 int ret;
254
255 ret = skt->ops->configure_socket(skt, state);
256 if (ret == 0) {
257 /*
258 * This really needs a better solution. The IRQ
259 * may or may not be claimed by the driver.
260 */
261 if (skt->irq_state != 1 && state->io_irq) {
262 skt->irq_state = 1;
Thomas Gleixnerdced35a2011-03-28 17:49:12 +0200263 irq_set_irq_type(skt->socket.pci_irq,
264 IRQ_TYPE_EDGE_FALLING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 } else if (skt->irq_state == 1 && state->io_irq == 0) {
266 skt->irq_state = 0;
Thomas Gleixnerdced35a2011-03-28 17:49:12 +0200267 irq_set_irq_type(skt->socket.pci_irq, IRQ_TYPE_NONE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 }
269
270 skt->cs_state = *state;
271 }
272
273 if (ret < 0)
274 printk(KERN_ERR "soc_common_pcmcia: unable to configure "
275 "socket %d\n", skt->nr);
276
277 return ret;
278}
279
280/* soc_common_pcmcia_sock_init()
281 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
282 *
283 * (Re-)Initialise the socket, turning on status interrupts
284 * and PCMCIA bus. This must wait for power to stabilise
285 * so that the card status signals report correctly.
286 *
287 * Returns: 0
288 */
289static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
290{
291 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
292
293 debug(skt, 2, "initializing socket\n");
Jonathan Camerona747ce82011-07-13 15:54:56 +0100294 if (skt->ops->socket_init)
295 skt->ops->socket_init(skt);
Russell Kingd9dc8782011-12-19 22:00:22 +0000296 soc_pcmcia_hw_enable(skt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return 0;
298}
299
300
301/*
302 * soc_common_pcmcia_suspend()
303 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
304 *
305 * Remove power on the socket, disable IRQs from the card.
306 * Turn off status interrupts, and disable the PCMCIA bus.
307 *
308 * Returns: 0
309 */
310static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
311{
312 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
313
314 debug(skt, 2, "suspending socket\n");
315
Russell Kingd9dc8782011-12-19 22:00:22 +0000316 soc_pcmcia_hw_disable(skt);
Jonathan Camerona747ce82011-07-13 15:54:56 +0100317 if (skt->ops->socket_suspend)
318 skt->ops->socket_suspend(skt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 return 0;
321}
322
323static DEFINE_SPINLOCK(status_lock);
324
325static void soc_common_check_status(struct soc_pcmcia_socket *skt)
326{
327 unsigned int events;
328
329 debug(skt, 4, "entering PCMCIA monitoring thread\n");
330
331 do {
332 unsigned int status;
333 unsigned long flags;
334
335 status = soc_common_pcmcia_skt_state(skt);
336
337 spin_lock_irqsave(&status_lock, flags);
338 events = (status ^ skt->status) & skt->cs_state.csc_mask;
339 skt->status = status;
340 spin_unlock_irqrestore(&status_lock, flags);
341
342 debug(skt, 4, "events: %s%s%s%s%s%s\n",
343 events == 0 ? "<NONE>" : "",
344 events & SS_DETECT ? "DETECT " : "",
345 events & SS_READY ? "READY " : "",
346 events & SS_BATDEAD ? "BATDEAD " : "",
347 events & SS_BATWARN ? "BATWARN " : "",
348 events & SS_STSCHG ? "STSCHG " : "");
349
350 if (events)
351 pcmcia_parse_events(&skt->socket, events);
352 } while (events);
353}
354
355/* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
356static void soc_common_pcmcia_poll_event(unsigned long dummy)
357{
358 struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
359 debug(skt, 4, "polling for events\n");
360
361 mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
362
363 soc_common_check_status(skt);
364}
365
366
367/*
368 * Service routine for socket driver interrupts (requested by the
369 * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
370 * The actual interrupt-servicing work is performed by
371 * soc_common_pcmcia_thread(), largely because the Card Services event-
372 * handling code performs scheduling operations which cannot be
373 * executed from within an interrupt context.
374 */
David Howells7d12e782006-10-05 14:55:46 +0100375static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
377 struct soc_pcmcia_socket *skt = dev;
378
379 debug(skt, 3, "servicing IRQ %d\n", irq);
380
381 soc_common_check_status(skt);
382
383 return IRQ_HANDLED;
384}
385
386
387/*
388 * Implements the get_status() operation for the in-kernel PCMCIA
389 * service (formerly SS_GetStatus in Card Services). Essentially just
390 * fills in bits in `status' according to internal driver state or
391 * the value of the voltage detect chipselect register.
392 *
393 * As a debugging note, during card startup, the PCMCIA core issues
394 * three set_socket() commands in a row the first with RESET deasserted,
395 * the second with RESET asserted, and the last with RESET deasserted
396 * again. Following the third set_socket(), a get_status() command will
397 * be issued. The kernel is looking for the SS_READY flag (see
398 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
399 *
400 * Returns: 0
401 */
402static int
403soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
404{
405 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
406
407 skt->status = soc_common_pcmcia_skt_state(skt);
408 *status = skt->status;
409
410 return 0;
411}
412
413
414/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 * Implements the set_socket() operation for the in-kernel PCMCIA
416 * service (formerly SS_SetSocket in Card Services). We more or
417 * less punt all of this work and let the kernel handle the details
418 * of power configuration, reset, &c. We also record the value of
419 * `state' in order to regurgitate it to the PCMCIA core later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 */
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100421static int soc_common_pcmcia_set_socket(
422 struct pcmcia_socket *sock, socket_state_t *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423{
424 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
425
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100426 debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
427 (state->csc_mask == 0) ? "<NONE> " : "",
428 (state->csc_mask & SS_DETECT) ? "DETECT " : "",
429 (state->csc_mask & SS_READY) ? "READY " : "",
430 (state->csc_mask & SS_BATDEAD) ? "BATDEAD " : "",
431 (state->csc_mask & SS_BATWARN) ? "BATWARN " : "",
432 (state->csc_mask & SS_STSCHG) ? "STSCHG " : "",
433 (state->flags == 0) ? "<NONE> " : "",
434 (state->flags & SS_PWR_AUTO) ? "PWR_AUTO " : "",
435 (state->flags & SS_IOCARD) ? "IOCARD " : "",
436 (state->flags & SS_RESET) ? "RESET " : "",
437 (state->flags & SS_SPKR_ENA) ? "SPKR_ENA " : "",
438 (state->flags & SS_OUTPUT_ENA) ? "OUTPUT_ENA " : "",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 state->Vcc, state->Vpp, state->io_irq);
440
441 return soc_common_pcmcia_config_skt(skt, state);
442}
443
444
445/*
446 * Implements the set_io_map() operation for the in-kernel PCMCIA
447 * service (formerly SS_SetIOMap in Card Services). We configure
448 * the map speed as requested, but override the address ranges
449 * supplied by Card Services.
450 *
451 * Returns: 0 on success, -1 on error
452 */
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100453static int soc_common_pcmcia_set_io_map(
454 struct pcmcia_socket *sock, struct pccard_io_map *map)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
456 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
457 unsigned short speed = map->speed;
458
Wolfram Sang5f784332009-10-19 11:42:13 +0200459 debug(skt, 2, "map %u speed %u start 0x%08llx stop 0x%08llx\n",
460 map->map, map->speed, (unsigned long long)map->start,
461 (unsigned long long)map->stop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100463 (map->flags == 0) ? "<NONE>" : "",
464 (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
465 (map->flags & MAP_16BIT) ? "16BIT " : "",
466 (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
467 (map->flags & MAP_0WS) ? "0WS " : "",
468 (map->flags & MAP_WRPROT) ? "WRPROT " : "",
469 (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "",
470 (map->flags & MAP_PREFETCH) ? "PREFETCH " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 if (map->map >= MAX_IO_WIN) {
Harvey Harrison2e11cb42008-05-01 04:34:54 -0700473 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 map->map);
475 return -1;
476 }
477
478 if (map->flags & MAP_ACTIVE) {
479 if (speed == 0)
480 speed = SOC_PCMCIA_IO_ACCESS;
481 } else {
482 speed = 0;
483 }
484
485 skt->spd_io[map->map] = speed;
486 skt->ops->set_timing(skt);
487
488 if (map->stop == 1)
489 map->stop = PAGE_SIZE-1;
490
491 map->stop -= map->start;
492 map->stop += skt->socket.io_offset;
493 map->start = skt->socket.io_offset;
494
495 return 0;
496}
497
498
499/*
500 * Implements the set_mem_map() operation for the in-kernel PCMCIA
501 * service (formerly SS_SetMemMap in Card Services). We configure
502 * the map speed as requested, but override the address ranges
503 * supplied by Card Services.
504 *
Pavel Machek4846d012005-10-14 15:59:02 -0700505 * Returns: 0 on success, -ERRNO on error
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 */
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100507static int soc_common_pcmcia_set_mem_map(
508 struct pcmcia_socket *sock, struct pccard_mem_map *map)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509{
510 struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
511 struct resource *res;
512 unsigned short speed = map->speed;
513
514 debug(skt, 2, "map %u speed %u card_start %08x\n",
515 map->map, map->speed, map->card_start);
516 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100517 (map->flags == 0) ? "<NONE>" : "",
518 (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
519 (map->flags & MAP_16BIT) ? "16BIT " : "",
520 (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
521 (map->flags & MAP_0WS) ? "0WS " : "",
522 (map->flags & MAP_WRPROT) ? "WRPROT " : "",
523 (map->flags & MAP_ATTRIB) ? "ATTRIB " : "",
524 (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
526 if (map->map >= MAX_WIN)
527 return -EINVAL;
528
529 if (map->flags & MAP_ACTIVE) {
530 if (speed == 0)
531 speed = 300;
532 } else {
533 speed = 0;
534 }
535
536 if (map->flags & MAP_ATTRIB) {
537 res = &skt->res_attr;
538 skt->spd_attr[map->map] = speed;
539 skt->spd_mem[map->map] = 0;
540 } else {
541 res = &skt->res_mem;
542 skt->spd_attr[map->map] = 0;
543 skt->spd_mem[map->map] = speed;
544 }
545
546 skt->ops->set_timing(skt);
547
548 map->static_start = res->start + map->card_start;
549
550 return 0;
551}
552
553struct bittbl {
554 unsigned int mask;
555 const char *name;
556};
557
558static struct bittbl status_bits[] = {
559 { SS_WRPROT, "SS_WRPROT" },
560 { SS_BATDEAD, "SS_BATDEAD" },
561 { SS_BATWARN, "SS_BATWARN" },
562 { SS_READY, "SS_READY" },
563 { SS_DETECT, "SS_DETECT" },
564 { SS_POWERON, "SS_POWERON" },
565 { SS_STSCHG, "SS_STSCHG" },
566 { SS_3VCARD, "SS_3VCARD" },
567 { SS_XVCARD, "SS_XVCARD" },
568};
569
570static struct bittbl conf_bits[] = {
571 { SS_PWR_AUTO, "SS_PWR_AUTO" },
572 { SS_IOCARD, "SS_IOCARD" },
573 { SS_RESET, "SS_RESET" },
574 { SS_DMA_MODE, "SS_DMA_MODE" },
575 { SS_SPKR_ENA, "SS_SPKR_ENA" },
576 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
577};
578
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100579static void dump_bits(char **p, const char *prefix,
580 unsigned int val, struct bittbl *bits, int sz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581{
582 char *b = *p;
583 int i;
584
585 b += sprintf(b, "%-9s:", prefix);
586 for (i = 0; i < sz; i++)
587 if (val & bits[i].mask)
588 b += sprintf(b, " %s", bits[i].name);
589 *b++ = '\n';
590 *p = b;
591}
592
593/*
594 * Implements the /sys/class/pcmcia_socket/??/status file.
595 *
596 * Returns: the number of characters added to the buffer
597 */
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100598static ssize_t show_status(
599 struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 struct soc_pcmcia_socket *skt =
Greg Kroah-Hartman87373312006-09-12 17:00:10 +0200602 container_of(dev, struct soc_pcmcia_socket, socket.dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 char *p = buf;
604
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100605 p += sprintf(p, "slot : %d\n", skt->nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 dump_bits(&p, "status", skt->status,
608 status_bits, ARRAY_SIZE(status_bits));
609 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
610 status_bits, ARRAY_SIZE(status_bits));
611 dump_bits(&p, "cs_flags", skt->cs_state.flags,
612 conf_bits, ARRAY_SIZE(conf_bits));
613
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100614 p += sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
615 p += sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
616 p += sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq,
Russell King - ARM Linux66024db2009-03-29 22:45:26 +0100617 skt->socket.pci_irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 if (skt->ops->show_timing)
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100619 p += skt->ops->show_timing(skt, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 return p-buf;
622}
Alexey Dobriyane4a3c3f2007-02-13 22:39:27 -0800623static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625
626static struct pccard_operations soc_common_pcmcia_operations = {
627 .init = soc_common_pcmcia_sock_init,
628 .suspend = soc_common_pcmcia_suspend,
629 .get_status = soc_common_pcmcia_get_status,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 .set_socket = soc_common_pcmcia_set_socket,
631 .set_io_map = soc_common_pcmcia_set_io_map,
632 .set_mem_map = soc_common_pcmcia_set_mem_map,
633};
634
635
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000636static LIST_HEAD(soc_pcmcia_sockets);
Andrew Morton23d077e2008-05-01 04:34:54 -0700637static DEFINE_MUTEX(soc_pcmcia_sockets_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639#ifdef CONFIG_CPU_FREQ
640static int
641soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
642{
643 struct soc_pcmcia_socket *skt;
644 struct cpufreq_freqs *freqs = data;
645 int ret = 0;
646
Andrew Morton23d077e2008-05-01 04:34:54 -0700647 mutex_lock(&soc_pcmcia_sockets_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 list_for_each_entry(skt, &soc_pcmcia_sockets, node)
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100649 if (skt->ops->frequency_change)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 ret += skt->ops->frequency_change(skt, val, freqs);
Andrew Morton23d077e2008-05-01 04:34:54 -0700651 mutex_unlock(&soc_pcmcia_sockets_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 return ret;
654}
655
656static struct notifier_block soc_pcmcia_notifier_block = {
657 .notifier_call = soc_pcmcia_notifier
658};
659
660static int soc_pcmcia_cpufreq_register(void)
661{
662 int ret;
663
664 ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
665 CPUFREQ_TRANSITION_NOTIFIER);
666 if (ret < 0)
667 printk(KERN_ERR "Unable to register CPU frequency change "
668 "notifier for PCMCIA (%d)\n", ret);
669 return ret;
670}
Russell King - ARM Linux0f767de2009-03-26 21:14:19 +0000671fs_initcall(soc_pcmcia_cpufreq_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673static void soc_pcmcia_cpufreq_unregister(void)
674{
Marcelo Roberto Jimenez17b38eb2010-10-18 22:39:05 +0100675 cpufreq_unregister_notifier(&soc_pcmcia_notifier_block,
676 CPUFREQ_TRANSITION_NOTIFIER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
Russell King - ARM Linux0f767de2009-03-26 21:14:19 +0000678module_exit(soc_pcmcia_cpufreq_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680#endif
681
Russell Kinge0d21172011-12-19 14:07:31 +0000682void soc_pcmcia_init_one(struct soc_pcmcia_socket *skt,
683 struct pcmcia_low_level *ops, struct device *dev)
684{
Russell Kingd9dc8782011-12-19 22:00:22 +0000685 int i;
686
Russell Kinge0d21172011-12-19 14:07:31 +0000687 skt->ops = ops;
688 skt->socket.owner = ops->owner;
689 skt->socket.dev.parent = dev;
690 skt->socket.pci_irq = NO_IRQ;
Russell Kingd9dc8782011-12-19 22:00:22 +0000691
692 for (i = 0; i < ARRAY_SIZE(skt->stat); i++)
693 skt->stat[i].gpio = -EINVAL;
Russell Kinge0d21172011-12-19 14:07:31 +0000694}
695EXPORT_SYMBOL(soc_pcmcia_init_one);
696
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000697void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
698{
699 mutex_lock(&soc_pcmcia_sockets_lock);
700 del_timer_sync(&skt->poll_timer);
701
702 pcmcia_unregister_socket(&skt->socket);
703
Russell Kingd9dc8782011-12-19 22:00:22 +0000704 soc_pcmcia_hw_shutdown(skt);
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000705
Russell Kingd9dc8782011-12-19 22:00:22 +0000706 /* should not be required; violates some lowlevel drivers */
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000707 soc_common_pcmcia_config_skt(skt, &dead_socket);
708
709 list_del(&skt->node);
710 mutex_unlock(&soc_pcmcia_sockets_lock);
711
712 iounmap(skt->virt_io);
713 skt->virt_io = NULL;
714 release_resource(&skt->res_attr);
715 release_resource(&skt->res_mem);
716 release_resource(&skt->res_io);
717 release_resource(&skt->res_skt);
718}
719EXPORT_SYMBOL(soc_pcmcia_remove_one);
720
721int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
722{
723 int ret;
724
725 init_timer(&skt->poll_timer);
726 skt->poll_timer.function = soc_common_pcmcia_poll_event;
727 skt->poll_timer.data = (unsigned long)skt;
728 skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
729
730 ret = request_resource(&iomem_resource, &skt->res_skt);
731 if (ret)
732 goto out_err_1;
733
734 ret = request_resource(&skt->res_skt, &skt->res_io);
735 if (ret)
736 goto out_err_2;
737
738 ret = request_resource(&skt->res_skt, &skt->res_mem);
739 if (ret)
740 goto out_err_3;
741
742 ret = request_resource(&skt->res_skt, &skt->res_attr);
743 if (ret)
744 goto out_err_4;
745
746 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
747 if (skt->virt_io == NULL) {
748 ret = -ENOMEM;
749 goto out_err_5;
750 }
751
752 mutex_lock(&soc_pcmcia_sockets_lock);
753
754 list_add(&skt->node, &soc_pcmcia_sockets);
755
756 /*
757 * We initialize default socket timing here, because
758 * we are not guaranteed to see a SetIOMap operation at
759 * runtime.
760 */
761 skt->ops->set_timing(skt);
762
Russell Kingd9dc8782011-12-19 22:00:22 +0000763 ret = soc_pcmcia_hw_init(skt);
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000764 if (ret)
765 goto out_err_6;
766
767 skt->socket.ops = &soc_common_pcmcia_operations;
768 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
769 skt->socket.resource_ops = &pccard_static_ops;
770 skt->socket.irq_mask = 0;
771 skt->socket.map_size = PAGE_SIZE;
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000772 skt->socket.io_offset = (unsigned long)skt->virt_io;
773
774 skt->status = soc_common_pcmcia_skt_state(skt);
775
776 ret = pcmcia_register_socket(&skt->socket);
777 if (ret)
778 goto out_err_7;
779
780 add_timer(&skt->poll_timer);
781
782 mutex_unlock(&soc_pcmcia_sockets_lock);
783
784 ret = device_create_file(&skt->socket.dev, &dev_attr_status);
785 if (ret)
786 goto out_err_8;
787
788 return ret;
789
790 out_err_8:
791 mutex_lock(&soc_pcmcia_sockets_lock);
792 del_timer_sync(&skt->poll_timer);
793 pcmcia_unregister_socket(&skt->socket);
794
795 out_err_7:
Russell Kingd9dc8782011-12-19 22:00:22 +0000796 soc_pcmcia_hw_shutdown(skt);
Russell King - ARM Linux097e2962009-03-26 21:45:05 +0000797 out_err_6:
798 list_del(&skt->node);
799 mutex_unlock(&soc_pcmcia_sockets_lock);
800 iounmap(skt->virt_io);
801 out_err_5:
802 release_resource(&skt->res_attr);
803 out_err_4:
804 release_resource(&skt->res_mem);
805 out_err_3:
806 release_resource(&skt->res_io);
807 out_err_2:
808 release_resource(&skt->res_skt);
809 out_err_1:
810
811 return ret;
812}
813EXPORT_SYMBOL(soc_pcmcia_add_one);
814
Russell King - ARM Linux0f767de2009-03-26 21:14:19 +0000815MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
816MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
817MODULE_LICENSE("Dual MPL/GPL");