?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sync hh.org
[hh.org.git] / drivers / pcmcia / pxa2xx_core.c
bloba67e095ea2749cf84591b5eaf5993929a643edef
1 /*======================================================================
2
3 Device driver for the PCMCIA control functionality of PXA2xx
4 microprocessors.
5
6 The contents of this file may be used under the
7 terms of the GNU Public License version 2 (the "GPL")
8
9 (c) Ian Molton (spyro@f2s.com) 2003
10 (c) Stefan Eletzhofer (stefan.eletzhofer@inquant.de) 2003,4
11
12 derived from sa11xx_core.c
13
14 Portions created by John G. Dorsey are
15 Copyright (C) 1999 John G. Dorsey.
16
17 ======================================================================*/
18 /*
19 * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
20 * on the low-level kernel interface.
21 */
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/cpufreq.h>
26 #include <linux/ioport.h>
27 #include <linux/kernel.h>
28 #include <linux/timer.h>
29 #include <linux/mm.h>
30 #include <linux/notifier.h>
31 #include <linux/interrupt.h>
32 #include <linux/spinlock.h>
33
34 #include <asm/hardware.h>
35 #include <asm/io.h>
36 #include <asm/irq.h>
37 #include <asm/system.h>
38
39 #include "pxa2xx_core.h"
40 #include "pxa2xx.h"
41
42 #define to_pxa2xx_socket(x) container_of(x, struct pxa2xx_pcmcia_socket, socket)
43
44 #ifdef DEBUG
45 static int pc_debug;
46
47 module_param(pc_debug, int, 0644);
48
49 #define debug(skt, lvl, fmt, arg...) do { \
50 if (pc_debug > (lvl)) \
51 printk(KERN_DEBUG "skt%u: %s: " fmt, \
52 (skt)->nr, __func__ , ## arg); \
53 } while (0)
54
55 #else
56 #define debug(skt, lvl, fmt, arg...) do { } while (0)
57 #endif
58
59 /* FIXME */
60 #define cpufreq_get(dummy) (get_clk_frequency_khz())
61
62 #if 0
63 /*
64 * pxa2xx_core_pcmcia_default_mecr_timing
65 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
66 *
67 * Calculate MECR clock wait states for given CPU clock
68 * speed and command wait state. This function can be over-
69 * written by a board specific version.
70 *
71 * The default is to simply calculate the BS values as specified in
72 * the INTEL SA1100 development manual
73 * "Expansion Memory (PCMCIA) Configuration Register (MECR)"
74 * that's section 10.2.5 in _my_ version of the manual ;)
75 */
76 static unsigned int
77 pxa2xx_core_pcmcia_default_mecr_timing(struct pxa2xx_pcmcia_socket *skt,
78 unsigned int cpu_speed,
79 unsigned int cmd_time)
80 {
81 debug(1, "skt->nr=%d, speed=%d, time=%d", skt->nr, cpu_speed, cmd_time);
82 return pxa2xx_core_pcmcia_mecr_bs(cmd_time, cpu_speed);
83 }
84 #endif
85
86 static unsigned short calc_speed(unsigned short *spds, int num, unsigned short dflt)
87 {
88 unsigned short speed = 0;
89 int i;
90
91 for (i = 0; i < num; i++)
92 if (speed < spds[i])
93 speed = spds[i];
94 if (speed == 0)
95 speed = dflt;
96
97 return speed;
98 }
99
100 static int pxa2xx_core_pcmcia_set_mcmem( int sock, int speed, int clock )
101 {
102 MCMEM(sock) = ((pxa2xx_mcxx_setup(speed, clock)
103 & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
104 | ((pxa2xx_mcxx_asst(speed, clock)
105 & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
106 | ((pxa2xx_mcxx_hold(speed, clock)
107 & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
108
109 return 0;
110 }
111
112 static int pxa2xx_core_pcmcia_set_mcio( int sock, int speed, int clock )
113 {
114 MCIO(sock) = ((pxa2xx_mcxx_setup(speed, clock)
115 & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
116 | ((pxa2xx_mcxx_asst(speed, clock)
117 & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
118 | ((pxa2xx_mcxx_hold(speed, clock)
119 & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
120
121 return 0;
122 }
123
124 static int pxa2xx_core_pcmcia_set_mcatt( int sock, int speed, int clock )
125 {
126 MCATT(sock) = ((pxa2xx_mcxx_setup(speed, clock)
127 & MCXX_SETUP_MASK) << MCXX_SETUP_SHIFT)
128 | ((pxa2xx_mcxx_asst(speed, clock)
129 & MCXX_ASST_MASK) << MCXX_ASST_SHIFT)
130 | ((pxa2xx_mcxx_hold(speed, clock)
131 & MCXX_HOLD_MASK) << MCXX_HOLD_SHIFT);
132
133 return 0;
134 }
135
136 static int pxa2xx_core_pcmcia_set_mcxx(struct pxa2xx_pcmcia_socket *skt, unsigned int cpu_clock)
137 {
138 int sock = skt->nr;
139
140 pxa2xx_core_pcmcia_set_mcmem( sock, PXA_PCMCIA_5V_MEM_ACCESS, cpu_clock );
141 pxa2xx_core_pcmcia_set_mcatt( sock, PXA_PCMCIA_ATTR_MEM_ACCESS, cpu_clock );
142 pxa2xx_core_pcmcia_set_mcio( sock, PXA_PCMCIA_IO_ACCESS, cpu_clock );
143
144 return 0;
145 }
146
147 static unsigned int pxa2xx_core_pcmcia_skt_state(struct pxa2xx_pcmcia_socket *skt)
148 {
149 struct pcmcia_state state;
150 unsigned int stat;
151
152 memset(&state, 0, sizeof(struct pcmcia_state));
153
154 skt->ops->socket_state(skt, &state);
155
156 stat = state.detect ? SS_DETECT : 0;
157 stat |= state.ready ? SS_READY : 0;
158 stat |= state.wrprot ? SS_WRPROT : 0;
159 stat |= state.vs_3v ? SS_3VCARD : 0;
160 stat |= state.vs_Xv ? SS_XVCARD : 0;
161
162 /* The power status of individual sockets is not available
163 * explicitly from the hardware, so we just remember the state
164 * and regurgitate it upon request:
165 */
166 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
167
168 if (skt->cs_state.flags & SS_IOCARD)
169 stat |= state.bvd1 ? SS_STSCHG : 0;
170 else {
171 if (state.bvd1 == 0)
172 stat |= SS_BATDEAD;
173 else if (state.bvd2 == 0)
174 stat |= SS_BATWARN;
175 }
176 return stat;
177 }
178
179 /*
180 * pxa2xx_core_pcmcia_config_skt
181 * ^^^^^^^^^^^^^^^^^^^^^^^^
182 *
183 * Convert PCMCIA socket state to our socket configure structure.
184 */
185 static int
186 pxa2xx_core_pcmcia_config_skt(struct pxa2xx_pcmcia_socket *skt, socket_state_t *state)
187 {
188 int ret;
189
190 ret = skt->ops->configure_socket(skt, state);
191 if (ret == 0) {
192 /*
193 * This really needs a better solution. The IRQ
194 * may or may not be claimed by the driver.
195 */
196 if (skt->irq_state != 1 && state->io_irq) {
197 skt->irq_state = 1;
198 set_irq_type(skt->irq, IRQT_FALLING);
199 } else if (skt->irq_state == 1 && state->io_irq == 0) {
200 skt->irq_state = 0;
201 set_irq_type(skt->irq, IRQT_NOEDGE);
202 }
203
204 skt->cs_state = *state;
205 }
206
207 if (ret < 0)
208 printk(KERN_ERR "pxa2xx_core_pcmcia: unable to configure "
209 "socket %d\n", skt->nr);
210
211 return ret;
212 }
213
214 /* pxa2xx_core_pcmcia_sock_init()
215 * ^^^^^^^^^^^^^^^^^^^^^^^^^
216 *
217 * (Re-)Initialise the socket, turning on status interrupts
218 * and PCMCIA bus. This must wait for power to stabilise
219 * so that the card status signals report correctly.
220 *
221 * Returns: 0
222 */
223 static int pxa2xx_core_pcmcia_sock_init(struct pcmcia_socket *sock)
224 {
225 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
226
227 debug(2, "initializing socket %u\n", skt->nr);
228
229 skt->ops->socket_init(skt);
230 if (skt->ops->cd_irq)
231 pxa2xx_core_enable_irqs (skt, skt->ops->cd_irq, skt->ops->nr);
232
233 return 0;
234 }
235
236
237 /*
238 * pxa2xx_core_pcmcia_suspend()
239 * ^^^^^^^^^^^^^^^^^^^^^^^
240 *
241 * Remove power on the socket, disable IRQs from the card.
242 * Turn off status interrupts, and disable the PCMCIA bus.
243 *
244 * Returns: 0
245 */
246 static int pxa2xx_core_pcmcia_suspend(struct pcmcia_socket *sock)
247 {
248 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
249 int ret;
250
251 debug(2, "suspending socket %u\n", skt->nr);
252
253 ret = pxa2xx_core_pcmcia_config_skt(skt, &dead_socket);
254 if (ret == 0) {
255 if (skt->ops->cd_irq)
256 pxa2xx_core_disable_irqs (skt, skt->ops->cd_irq, skt->ops->nr);
257 skt->ops->socket_suspend(skt);
258 }
259
260 return ret;
261 }
262
263 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
264
265 /* pxa2xx_core_check_status()
266 * ^^^^^^^^^^^^^^^^^^^^^
267 */
268 static void pxa2xx_core_check_status(struct pxa2xx_pcmcia_socket *skt)
269 {
270 unsigned int events;
271
272 //debug(4, "%s(): entering PCMCIA monitoring thread\n", __FUNCTION__);
273
274 //debug( "skt->nr=%d", skt->nr );
275
276 do {
277 unsigned int status;
278 unsigned long flags;
279
280 status = pxa2xx_core_pcmcia_skt_state(skt);
281
282 spin_lock_irqsave(&status_lock, flags);
283 events = (status ^ skt->status) & skt->cs_state.csc_mask;
284 skt->status = status;
285 spin_unlock_irqrestore(&status_lock, flags);
286
287 #if 0
288 debug(1, "events: %s%s%s%s%s%s\n",
289 events == 0 ? "<NONE>" : "",
290 events & SS_DETECT ? "DETECT " : "",
291 events & SS_READY ? "READY " : "",
292 events & SS_BATDEAD ? "BATDEAD " : "",
293 events & SS_BATWARN ? "BATWARN " : "",
294 events & SS_STSCHG ? "STSCHG " : "");
295 #endif
296
297 if (events)
298 pcmcia_parse_events(&skt->socket, events);
299 } while (events);
300 }
301
302 /* pxa2xx_core_pcmcia_poll_event()
303 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
304 * Let's poll for events in addition to IRQs since IRQ only is unreliable...
305 */
306 static void pxa2xx_core_pcmcia_poll_event(unsigned long dummy)
307 {
308 struct pxa2xx_pcmcia_socket *skt = (struct pxa2xx_pcmcia_socket *)dummy;
309 debug(4, "%s(): polling for events\n", __FUNCTION__);
310
311 mod_timer(&skt->poll_timer, jiffies + PXA_PCMCIA_POLL_PERIOD);
312
313 pxa2xx_core_check_status(skt);
314 }
315
316
317 /* pxa2xx_core_pcmcia_interrupt()
318 * ^^^^^^^^^^^^^^^^^^^^^^^^^
319 * Service routine for socket driver interrupts (requested by the
320 * low-level PCMCIA init() operation via pxa2xx_core_pcmcia_thread()).
321 * The actual interrupt-servicing work is performed by
322 * pxa2xx_core_pcmcia_thread(), largely because the Card Services event-
323 * handling code performs scheduling operations which cannot be
324 * executed from within an interrupt context.
325 */
326 static irqreturn_t pxa2xx_core_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
327 {
328 struct pxa2xx_pcmcia_socket *skt = dev;
329
330 debug(3, "%s(): servicing IRQ %d\n", __FUNCTION__, irq);
331
332 pxa2xx_core_check_status(skt);
333
334 return IRQ_HANDLED;
335 }
336
337
338 /* pxa2xx_core_pcmcia_get_status()
339 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
340 * Implements the get_status() operation for the in-kernel PCMCIA
341 * service (formerly SS_GetStatus in Card Services). Essentially just
342 * fills in bits in `status' according to internal driver state or
343 * the value of the voltage detect chipselect register.
344 *
345 * As a debugging note, during card startup, the PCMCIA core issues
346 * three set_socket() commands in a row the first with RESET deasserted,
347 * the second with RESET asserted, and the last with RESET deasserted
348 * again. Following the third set_socket(), a get_status() command will
349 * be issued. The kernel is looking for the SS_READY flag (see
350 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
351 *
352 * Returns: 0
353 */
354 static int
355 pxa2xx_core_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
356 {
357 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
358
359 skt->status = pxa2xx_core_pcmcia_skt_state(skt);
360 *status = skt->status;
361
362 return 0;
363 }
364
365
366 /* pxa2xx_core_pcmcia_get_socket()
367 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
368 * Implements the get_socket() operation for the in-kernel PCMCIA
369 * service (formerly SS_GetSocket in Card Services). Not a very
370 * exciting routine.
371 *
372 * Returns: 0
373 */
374 static int
375 pxa2xx_core_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
376 {
377 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
378
379 debug(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
380
381 *state = skt->cs_state;
382
383 return 0;
384 }
385
386 /* pxa2xx_core_pcmcia_set_socket()
387 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
388 * Implements the set_socket() operation for the in-kernel PCMCIA
389 * service (formerly SS_SetSocket in Card Services). We more or
390 * less punt all of this work and let the kernel handle the details
391 * of power configuration, reset, &c. We also record the value of
392 * `state' in order to regurgitate it to the PCMCIA core later.
393 *
394 * Returns: 0
395 */
396 static int
397 pxa2xx_core_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
398 {
399 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
400
401 debug(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
402
403 debug(3, "\tmask: %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n",
404 (state->csc_mask==0)?"<NONE>":"",
405 (state->csc_mask&SS_DETECT)?"DETECT ":"",
406 (state->csc_mask&SS_READY)?"READY ":"",
407 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
408 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
409 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
410 (state->flags==0)?"<NONE>":"",
411 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
412 (state->flags&SS_IOCARD)?"IOCARD ":"",
413 (state->flags&SS_RESET)?"RESET ":"",
414 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
415 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"");
416 debug(3, "\tVcc %d Vpp %d irq %d\n",
417 state->Vcc, state->Vpp, state->io_irq);
418
419 return pxa2xx_core_pcmcia_config_skt(skt, state);
420 } /* pxa2xx_core_pcmcia_set_socket() */
421
422
423 /* pxa2xx_core_pcmcia_set_io_map()
424 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
425 * Implements the set_io_map() operation for the in-kernel PCMCIA
426 * service (formerly SS_SetIOMap in Card Services). We configure
427 * the map speed as requested, but override the address ranges
428 * supplied by Card Services.
429 *
430 * Returns: 0 on success, -1 on error
431 */
432 static int
433 pxa2xx_core_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
434 {
435 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
436 unsigned short speed = map->speed;
437
438 debug(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
439
440 debug(3, "\tmap %u speed %u\n\tstart 0x%08x stop 0x%08x\n",
441 map->map, map->speed, map->start, map->stop);
442 debug(3, "\tflags: %s%s%s%s%s%s%s%s\n",
443 (map->flags==0)?"<NONE>":"",
444 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
445 (map->flags&MAP_16BIT)?"16BIT ":"",
446 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
447 (map->flags&MAP_0WS)?"0WS ":"",
448 (map->flags&MAP_WRPROT)?"WRPROT ":"",
449 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
450 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
451
452 if (map->map >= MAX_IO_WIN) {
453 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
454 map->map);
455 return -1;
456 }
457
458 if (map->flags & MAP_ACTIVE) {
459 if (speed == 0)
460 speed = PXA_PCMCIA_IO_ACCESS;
461 } else {
462 speed = 0;
463 }
464
465 skt->spd_io[map->map] = speed;
466 pxa2xx_core_pcmcia_set_mcio( skt->nr, speed, get_lclk_frequency_10khz() );
467
468 if (map->stop == 1)
469 map->stop = PAGE_SIZE-1;
470
471 map->stop -= map->start;
472 map->stop += (unsigned long)skt->virt_io;
473 map->start = (unsigned long)skt->virt_io;
474
475 return 0;
476 } /* pxa2xx_core_pcmcia_set_io_map() */
477
478
479 /* pxa2xx_core_pcmcia_set_mem_map()
480 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
481 * Implements the set_mem_map() operation for the in-kernel PCMCIA
482 * service (formerly SS_SetMemMap in Card Services). We configure
483 * the map speed as requested, but override the address ranges
484 * supplied by Card Services.
485 *
486 * Returns: 0 on success, -1 on error
487 */
488 static int
489 pxa2xx_core_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
490 {
491 struct pxa2xx_pcmcia_socket *skt = to_pxa2xx_socket(sock);
492 struct resource *res;
493 unsigned short speed = map->speed;
494
495 debug(2, "%s() for sock %u\n", __FUNCTION__, skt->nr);
496
497 debug(3, "\tmap %u speed %u card_start %08x\n",
498 map->map, map->speed, map->card_start);
499 debug(3, "\tflags: %s%s%s%s%s%s%s%s\n",
500 (map->flags==0)?"<NONE>":"",
501 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
502 (map->flags&MAP_16BIT)?"16BIT ":"",
503 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
504 (map->flags&MAP_0WS)?"0WS ":"",
505 (map->flags&MAP_WRPROT)?"WRPROT ":"",
506 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
507 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
508
509 if (map->map >= MAX_WIN)
510 return -EINVAL;
511
512 if (map->flags & MAP_ACTIVE) {
513 if (speed == 0)
514 speed = 300;
515 } else {
516 speed = 0;
517 }
518
519 if (map->flags & MAP_ATTRIB) {
520 res = &skt->res_attr;
521 skt->spd_attr[map->map] = speed;
522 skt->spd_mem[map->map] = 0;
523 pxa2xx_core_pcmcia_set_mcatt( skt->nr, speed, get_lclk_frequency_10khz() );
524 } else {
525 res = &skt->res_mem;
526 skt->spd_attr[map->map] = 0;
527 skt->spd_mem[map->map] = speed;
528 pxa2xx_core_pcmcia_set_mcmem( skt->nr, speed , get_lclk_frequency_10khz());
529 }
530
531 map->sys_stop -= map->sys_start;
532 map->sys_stop += res->start + map->card_start;
533 map->sys_start = res->start + map->card_start;
534
535 return 0;
536 }
537
538 struct bittbl {
539 unsigned int mask;
540 const char *name;
541 };
542
543 static struct bittbl status_bits[] = {
544 { SS_WRPROT, "SS_WRPROT" },
545 { SS_BATDEAD, "SS_BATDEAD" },
546 { SS_BATWARN, "SS_BATWARN" },
547 { SS_READY, "SS_READY" },
548 { SS_DETECT, "SS_DETECT" },
549 { SS_POWERON, "SS_POWERON" },
550 { SS_STSCHG, "SS_STSCHG" },
551 { SS_3VCARD, "SS_3VCARD" },
552 { SS_XVCARD, "SS_XVCARD" },
553 };
554
555 static struct bittbl conf_bits[] = {
556 { SS_PWR_AUTO, "SS_PWR_AUTO" },
557 { SS_IOCARD, "SS_IOCARD" },
558 { SS_RESET, "SS_RESET" },
559 { SS_DMA_MODE, "SS_DMA_MODE" },
560 { SS_SPKR_ENA, "SS_SPKR_ENA" },
561 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
562 };
563
564 static void
565 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
566 {
567 char *b = *p;
568 int i;
569
570 b += sprintf(b, "%-9s:", prefix);
571 for (i = 0; i < sz; i++)
572 if (val & bits[i].mask)
573 b += sprintf(b, " %s", bits[i].name);
574 *b++ = '\n';
575 *p = b;
576 }
577
578 /* show_status()
579 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
580 * Implements the /sys/class/pcmcia_socket/??/status file.
581 *
582 * Returns: the number of characters added to the buffer
583 */
584 static ssize_t show_status(struct class_device *class_dev, char *buf)
585 {
586 struct pxa2xx_pcmcia_socket *skt = container_of(class_dev,
587 struct pxa2xx_pcmcia_socket, socket.dev);
588 unsigned int clock = get_lclk_frequency_10khz();
589 char *p = buf;
590
591 p+=sprintf(p, "slot : %d\n", skt->nr);
592
593 dump_bits(&p, "status", skt->status,
594 status_bits, ARRAY_SIZE(status_bits));
595 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
596 status_bits, ARRAY_SIZE(status_bits));
597 dump_bits(&p, "cs_flags", skt->cs_state.flags,
598 conf_bits, ARRAY_SIZE(conf_bits));
599
600 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
601 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
602 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
603
604 p+=sprintf(p, "I/O : %u (%u)\n",
605 calc_speed(skt->spd_io, MAX_IO_WIN, PXA_PCMCIA_IO_ACCESS),
606 pxa2xx_pcmcia_cmd_time(clock, (MCIO(skt->nr)>>MCXX_ASST_SHIFT)&MCXX_ASST_MASK));
607
608 p+=sprintf(p, "attribute: %u (%u)\n",
609 calc_speed(skt->spd_attr, MAX_WIN, PXA_PCMCIA_3V_MEM_ACCESS),
610 pxa2xx_pcmcia_cmd_time(clock, (MCATT(skt->nr)>>MCXX_ASST_SHIFT)&MCXX_ASST_MASK));
611
612 p+=sprintf(p, "common : %u (%u)\n",
613 calc_speed(skt->spd_mem, MAX_WIN, PXA_PCMCIA_3V_MEM_ACCESS),
614 pxa2xx_pcmcia_cmd_time(clock, (MCMEM(skt->nr)>>MCXX_ASST_SHIFT)&MCXX_ASST_MASK));
615
616 return p-buf;
617 }
618 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
619
620
621 static struct pccard_operations pxa2xx_core_pcmcia_operations = {
622 .init = pxa2xx_core_pcmcia_sock_init,
623 .suspend = pxa2xx_core_pcmcia_suspend,
624 .get_status = pxa2xx_core_pcmcia_get_status,
625 .get_socket = pxa2xx_core_pcmcia_get_socket,
626 .set_socket = pxa2xx_core_pcmcia_set_socket,
627 .set_io_map = pxa2xx_core_pcmcia_set_io_map,
628 .set_mem_map = pxa2xx_core_pcmcia_set_mem_map,
629 };
630
631 int pxa2xx_core_request_irqs(struct pxa2xx_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
632 {
633 int i, res = 0;
634
635 for (i = 0; i < nr; i++) {
636 if (irqs[i].sock != skt->nr)
637 continue;
638 res = request_irq(irqs[i].irq, pxa2xx_core_pcmcia_interrupt,
639 SA_INTERRUPT, irqs[i].str, skt);
640 if (res)
641 break;
642 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
643 }
644
645 if (res) {
646 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
647 irqs[i].irq, res);
648
649 while (i--)
650 if (irqs[i].sock == skt->nr)
651 free_irq(irqs[i].irq, skt);
652 }
653 return res;
654 }
655 EXPORT_SYMBOL(pxa2xx_core_request_irqs);
656
657 void pxa2xx_core_free_irqs(struct pxa2xx_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
658 {
659 int i;
660
661 for (i = 0; i < nr; i++)
662 if (irqs[i].sock == skt->nr)
663 free_irq(irqs[i].irq, skt);
664 }
665 EXPORT_SYMBOL(pxa2xx_core_free_irqs);
666
667 void pxa2xx_core_disable_irqs(struct pxa2xx_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
668 {
669 int i;
670
671 for (i = 0; i < nr; i++)
672 if (irqs[i].sock == skt->nr)
673 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
674 }
675 EXPORT_SYMBOL(pxa2xx_core_disable_irqs);
676
677 void pxa2xx_core_enable_irqs(struct pxa2xx_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
678 {
679 int i;
680
681 for (i = 0; i < nr; i++)
682 if (irqs[i].sock == skt->nr) {
683 set_irq_type(irqs[i].irq, IRQT_RISING);
684 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
685 }
686 }
687 EXPORT_SYMBOL(pxa2xx_core_enable_irqs);
688
689 static LIST_HEAD(pxa2xx_sockets);
690 static DECLARE_MUTEX(pxa2xx_sockets_lock);
691
692 static const char *skt_names[] = {
693 "PCMCIA socket 0",
694 "PCMCIA socket 1",
695 };
696
697 struct skt_dev_info {
698 int nskt;
699 struct pxa2xx_pcmcia_socket skt[0];
700 };
701
702 #define SKT_DEV_INFO_SIZE(n) \
703 (sizeof(struct skt_dev_info) + (n)*sizeof(struct pxa2xx_pcmcia_socket))
704
705 int pxa2xx_core_drv_pcmcia_probe(struct device *dev)
706 {
707 struct skt_dev_info *sinfo;
708 unsigned int cpu_clock;
709 int ret = -ENODEV, i;
710 struct pcmcia_low_level *ops;
711 int first, nr;
712
713 #if 0
714 /* FIXME: fix this for pxa or kill it
715 * set default MECR calculation if the board specific
716 * code did not specify one...
717 */
718 if (!ops->socket_get_timing)
719 ops->socket_get_timing = pxa2xx_pcmcia_default_mecr_timing;
720 #endif
721
722 if (!dev || !dev->platform_data)
723 goto out;
724
725 ops = (struct pcmcia_low_level *)dev->platform_data;
726
727 first = ops->first;
728 nr = ops->nr;
729
730 /* Setup GPIOs for PCMCIA/CF alternate function mode.
731 *
732 * It would be nice if set_GPIO_mode included support
733 * for driving GPIO outputs to default high/low state
734 * before programming GPIOs as outputs. Setting GPIO
735 * outputs to default high/low state via GPSR/GPCR
736 * before defining them as outputs should reduce
737 * the possibility of glitching outputs during GPIO
738 * setup. This of course assumes external terminators
739 * are present to hold GPIOs in a defined state.
740 *
741 * In the meantime, setup default state of GPIO
742 * outputs before we enable them as outputs.
743 */
744
745 GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
746 GPIO_bit(GPIO49_nPWE) |
747 GPIO_bit(GPIO50_nPIOR) |
748 GPIO_bit(GPIO51_nPIOW) |
749 GPIO_bit(GPIO52_nPCE_1) |
750 GPIO_bit(GPIO53_nPCE_2);
751
752 pxa_gpio_mode(GPIO48_nPOE_MD);
753 pxa_gpio_mode(GPIO49_nPWE_MD);
754 pxa_gpio_mode(GPIO50_nPIOR_MD);
755 pxa_gpio_mode(GPIO51_nPIOW_MD);
756 pxa_gpio_mode(GPIO52_nPCE_1_MD);
757 pxa_gpio_mode(GPIO53_nPCE_2_MD);
758 pxa_gpio_mode(GPIO54_pSKTSEL_MD); /* REVISIT: s/b dependent on num sockets */
759 pxa_gpio_mode(GPIO55_nPREG_MD);
760 pxa_gpio_mode(GPIO56_nPWAIT_MD);
761 pxa_gpio_mode(GPIO57_nIOIS16_MD);
762
763
764 down(&pxa2xx_sockets_lock);
765
766 sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
767 if (!sinfo) {
768 ret = -ENOMEM;
769 goto out;
770 }
771
772 memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
773 sinfo->nskt = nr;
774
775 cpu_clock = get_lclk_frequency_10khz();
776
777 /*
778 * Initialise the per-socket structure.
779 */
780 for (i = 0; i < nr; i++) {
781 struct pxa2xx_pcmcia_socket *skt = &sinfo->skt[i];
782
783 skt->socket.ops = &pxa2xx_core_pcmcia_operations;
784 skt->socket.owner = ops->owner;
785 skt->socket.dev.dev = dev;
786
787 init_timer(&skt->poll_timer);
788 skt->poll_timer.function = pxa2xx_core_pcmcia_poll_event;
789 skt->poll_timer.data = (unsigned long)skt;
790 skt->poll_timer.expires = jiffies + PXA_PCMCIA_POLL_PERIOD;
791
792 skt->nr = first + i;
793 skt->irq = NO_IRQ;
794 skt->dev = dev;
795 skt->ops = ops;
796
797 skt->res_skt.start = _PCMCIA(skt->nr);
798 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
799 skt->res_skt.name = skt_names[skt->nr];
800 skt->res_skt.flags = IORESOURCE_MEM;
801
802 ret = request_resource(&iomem_resource, &skt->res_skt);
803 if (ret)
804 goto out_err_1;
805
806 skt->res_io.start = _PCMCIAIO(skt->nr);
807 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
808 skt->res_io.name = "io";
809 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
810
811 ret = request_resource(&skt->res_skt, &skt->res_io);
812 if (ret)
813 goto out_err_2;
814
815 skt->res_mem.start = _PCMCIAMem(skt->nr);
816 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
817 skt->res_mem.name = "memory";
818 skt->res_mem.flags = IORESOURCE_MEM;
819
820 ret = request_resource(&skt->res_skt, &skt->res_mem);
821 if (ret)
822 goto out_err_3;
823
824 skt->res_attr.start = _PCMCIAAttr(skt->nr);
825 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
826 skt->res_attr.name = "attribute";
827 skt->res_attr.flags = IORESOURCE_MEM;
828
829 ret = request_resource(&skt->res_skt, &skt->res_attr);
830 if (ret)
831 goto out_err_4;
832
833 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
834 if (skt->virt_io == NULL) {
835 ret = -ENOMEM;
836 goto out_err_5;
837 }
838
839 list_add(&skt->node, &pxa2xx_sockets);
840
841 /*
842 * We initialize the MECR to default values here, because
843 * we are not guaranteed to see a SetIOMap operation at
844 * runtime.
845 */
846 pxa2xx_core_pcmcia_set_mcxx(skt, cpu_clock);
847
848 ret = ops->hw_init(skt);
849 if (ret)
850 goto out_err_6;
851
852 if (ops->cd_irq &&
853 pxa2xx_core_request_irqs (skt, ops->cd_irq, ops->nr))
854 goto out_err_6;
855
856 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
857 skt->socket.irq_mask = 0;
858 skt->socket.map_size = PAGE_SIZE;
859 skt->socket.pci_irq = skt->irq;
860 skt->socket.io_offset = (unsigned long)skt->virt_io;
861
862 skt->status = pxa2xx_core_pcmcia_skt_state(skt);
863
864 ret = pcmcia_register_socket(&skt->socket);
865 if (ret)
866 goto out_err_7;
867
868 WARN_ON(skt->socket.sock != i);
869
870 add_timer(&skt->poll_timer);
871
872 //printk (KERN_DEBUG "dev=%p, attr=%p\n", &skt->socket.dev, &class_device_attr_status);
873 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
874 }
875
876 /* We have at last one socket, so set MECR:CIT (Card Is There) */
877 MECR |= MECR_CIT;
878
879 /* Set MECR:NOS (Number Of Sockets) */
880 if ( nr>1 )
881 MECR |= MECR_NOS;
882 else
883 MECR &= ~MECR_NOS;
884
885 dev_set_drvdata(dev, sinfo);
886 ret = 0;
887 goto out;
888
889 do {
890 struct pxa2xx_pcmcia_socket *skt = &sinfo->skt[i];
891
892 del_timer_sync(&skt->poll_timer);
893 pcmcia_unregister_socket(&skt->socket);
894
895 out_err_7:
896 flush_scheduled_work();
897
898 if (ops->cd_irq)
899 pxa2xx_core_free_irqs (skt, ops->cd_irq, ops->nr);
900 ops->hw_shutdown(skt);
901 out_err_6:
902 list_del(&skt->node);
903 iounmap(skt->virt_io);
904 out_err_5:
905 release_resource(&skt->res_attr);
906 out_err_4:
907 release_resource(&skt->res_mem);
908 out_err_3:
909 release_resource(&skt->res_io);
910 out_err_2:
911 release_resource(&skt->res_skt);
912 out_err_1:
913 i--;
914 } while (i > 0);
915
916 kfree(sinfo);
917
918 out:
919 up(&pxa2xx_sockets_lock);
920 return ret;
921 }
922 EXPORT_SYMBOL(pxa2xx_core_drv_pcmcia_probe);
923
924 int pxa2xx_core_drv_pcmcia_remove(struct device *dev)
925 {
926 struct skt_dev_info *sinfo = dev_get_drvdata(dev);
927 int i;
928
929 dev_set_drvdata(dev, NULL);
930
931 down(&pxa2xx_sockets_lock);
932 for (i = 0; i < sinfo->nskt; i++) {
933 struct pxa2xx_pcmcia_socket *skt = &sinfo->skt[i];
934
935 class_device_remove_file(&skt->socket.dev, &class_device_attr_status);
936
937 del_timer_sync(&skt->poll_timer);
938
939 pcmcia_unregister_socket(&skt->socket);
940
941 flush_scheduled_work();
942
943 if (skt->ops->cd_irq)
944 pxa2xx_core_free_irqs (skt, skt->ops->cd_irq, skt->ops->nr);
945
946 skt->ops->hw_shutdown(skt);
947
948 pxa2xx_core_pcmcia_config_skt(skt, &dead_socket);
949
950 list_del(&skt->node);
951 iounmap(skt->virt_io);
952 skt->virt_io = NULL;
953 release_resource(&skt->res_attr);
954 release_resource(&skt->res_mem);
955 release_resource(&skt->res_io);
956 release_resource(&skt->res_skt);
957 }
958 up(&pxa2xx_sockets_lock);
959
960 kfree(sinfo);
961
962 return 0;
963 }
964 EXPORT_SYMBOL(pxa2xx_core_drv_pcmcia_remove);
965
966 #ifdef CONFIG_CPU_FREQ
967
968 /* pxa2xx_core_pcmcia_update_mcxx()
969 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
970 * When pxa2xx_core_pcmcia_notifier() decides that a MC{IO,MEM,ATT} adjustment (due
971 * to a core clock frequency change) is needed, this routine establishes
972 * new values consistent with the clock speed `clock'.
973 */
974 static void pxa2xx_core_pcmcia_update_mcxx(unsigned int clock)
975 {
976 struct pxa2xx_pcmcia_socket *skt;
977
978 down(&pxa2xx_sockets_lock);
979 list_for_each_entry(skt, &pxa2xx_sockets, node) {
980 pxa2xx_core_pcmcia_set_mcio(skt->nr, calc_speed(skt->spd_io,
981 MAX_IO_WIN, PXA_PCMCIA_IO_ACCESS), clock);
982 pxa2xx_core_pcmcia_set_mcmem(skt->nr, calc_speed(skt->spd_io,
983 MAX_IO_WIN, PXA_PCMCIA_3V_MEM_ACCESS), clock );
984 pxa2xx_core_pcmcia_set_mcatt(skt->nr, calc_speed(skt->spd_io,
985 MAX_IO_WIN, PXA_PCMCIA_3V_MEM_ACCESS), clock );
986 }
987 up(&pxa2xx_sockets_lock);
988 }
989
990 /* pxa2xx_core_pcmcia_notifier()
991 * ^^^^^^^^^^^^^^^^^^^^^^^^
992 * When changing the processor core clock frequency, it is necessary
993 * to adjust the MECR timings accordingly. We've recorded the timings
994 * requested by Card Services, so this is just a matter of finding
995 * out what our current speed is, and then recomputing the new MCXX
996 * values.
997 *
998 * Returns: 0 on success, -1 on error
999 */
1000 static int
1001 pxa2xx_core_pcmcia_notifier(struct notifier_block *nb, unsigned long val,
1002 void *data)
1003 {
1004 struct cpufreq_freqs *freqs = data;
1005
1006 switch (val) {
1007 case CPUFREQ_PRECHANGE:
1008 if (freqs->new > freqs->old) {
1009 debug(2, "%s(): new frequency %u.%uMHz > %u.%uMHz, "
1010 "pre-updating\n", __FUNCTION__,
1011 freqs->new / 1000, (freqs->new / 100) % 10,
1012 freqs->old / 1000, (freqs->old / 100) % 10);
1013 pxa2xx_core_pcmcia_update_mcxx(freqs->new);
1014 }
1015 break;
1016
1017 case CPUFREQ_POSTCHANGE:
1018 if (freqs->new < freqs->old) {
1019 debug(2, "%s(): new frequency %u.%uMHz < %u.%uMHz, "
1020 "post-updating\n", __FUNCTION__,
1021 freqs->new / 1000, (freqs->new / 100) % 10,
1022 freqs->old / 1000, (freqs->old / 100) % 10);
1023 pxa2xx_core_pcmcia_update_mcxx(freqs->new);
1024 }
1025 break;
1026 }
1027
1028 return 0;
1029 }
1030
1031 static struct notifier_block pxa2xx_core_pcmcia_notifier_block = {
1032 .notifier_call = pxa2xx_core_pcmcia_notifier
1033 };
1034
1035 static int __init pxa2xx_core_pcmcia_init(void)
1036 {
1037 int ret;
1038
1039 printk(KERN_INFO "PXA2xx PCMCIA\n");
1040
1041 ret = cpufreq_register_notifier(&pxa2xx_core_pcmcia_notifier_block,
1042 CPUFREQ_TRANSITION_NOTIFIER);
1043 if (ret < 0)
1044 printk(KERN_ERR "Unable to register CPU frequency change "
1045 "notifier (%d)\n", ret);
1046
1047 return ret;
1048 }
1049 module_init(pxa2xx_core_pcmcia_init);
1050
1051 static void __exit pxa2xx_core_pcmcia_exit(void)
1052 {
1053 cpufreq_unregister_notifier(&pxa2xx_core_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
1054 }
1055
1056 module_exit(pxa2xx_core_pcmcia_exit);
1057 #endif
1058
1059 MODULE_AUTHOR("Stefan Eletzhofer <stefan.eletzhofer@inquant.de> and Ian Molton <spyro@f2s.com>");
1060 MODULE_DESCRIPTION("Linux PCMCIA Card Services: PXA2xx core socket driver");
1061 MODULE_LICENSE("GPL");
hh.org GIT migration