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