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