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