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