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