5a9a392eacdf18d1ba9de1237f11f0a3efefbf7d
[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                         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                         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
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         skt->ops->socket_suspend(skt);
211
212         return 0;
213 }
214
215 static DEFINE_SPINLOCK(status_lock);
216
217 static void soc_common_check_status(struct soc_pcmcia_socket *skt)
218 {
219         unsigned int events;
220
221         debug(skt, 4, "entering PCMCIA monitoring thread\n");
222
223         do {
224                 unsigned int status;
225                 unsigned long flags;
226
227                 status = soc_common_pcmcia_skt_state(skt);
228
229                 spin_lock_irqsave(&status_lock, flags);
230                 events = (status ^ skt->status) & skt->cs_state.csc_mask;
231                 skt->status = status;
232                 spin_unlock_irqrestore(&status_lock, flags);
233
234                 debug(skt, 4, "events: %s%s%s%s%s%s\n",
235                         events == 0         ? "<NONE>"   : "",
236                         events & SS_DETECT  ? "DETECT "  : "",
237                         events & SS_READY   ? "READY "   : "",
238                         events & SS_BATDEAD ? "BATDEAD " : "",
239                         events & SS_BATWARN ? "BATWARN " : "",
240                         events & SS_STSCHG  ? "STSCHG "  : "");
241
242                 if (events)
243                         pcmcia_parse_events(&skt->socket, events);
244         } while (events);
245 }
246
247 /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
248 static void soc_common_pcmcia_poll_event(unsigned long dummy)
249 {
250         struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
251         debug(skt, 4, "polling for events\n");
252
253         mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
254
255         soc_common_check_status(skt);
256 }
257
258
259 /*
260  * Service routine for socket driver interrupts (requested by the
261  * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
262  * The actual interrupt-servicing work is performed by
263  * soc_common_pcmcia_thread(), largely because the Card Services event-
264  * handling code performs scheduling operations which cannot be
265  * executed from within an interrupt context.
266  */
267 static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
268 {
269         struct soc_pcmcia_socket *skt = dev;
270
271         debug(skt, 3, "servicing IRQ %d\n", irq);
272
273         soc_common_check_status(skt);
274
275         return IRQ_HANDLED;
276 }
277
278
279 /*
280  *  Implements the get_status() operation for the in-kernel PCMCIA
281  * service (formerly SS_GetStatus in Card Services). Essentially just
282  * fills in bits in `status' according to internal driver state or
283  * the value of the voltage detect chipselect register.
284  *
285  * As a debugging note, during card startup, the PCMCIA core issues
286  * three set_socket() commands in a row the first with RESET deasserted,
287  * the second with RESET asserted, and the last with RESET deasserted
288  * again. Following the third set_socket(), a get_status() command will
289  * be issued. The kernel is looking for the SS_READY flag (see
290  * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
291  *
292  * Returns: 0
293  */
294 static int
295 soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
296 {
297         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
298
299         skt->status = soc_common_pcmcia_skt_state(skt);
300         *status = skt->status;
301
302         return 0;
303 }
304
305
306 /*
307  * Implements the set_socket() operation for the in-kernel PCMCIA
308  * service (formerly SS_SetSocket in Card Services). We more or
309  * less punt all of this work and let the kernel handle the details
310  * of power configuration, reset, &c. We also record the value of
311  * `state' in order to regurgitate it to the PCMCIA core later.
312  */
313 static int soc_common_pcmcia_set_socket(
314         struct pcmcia_socket *sock, socket_state_t *state)
315 {
316         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
317
318         debug(skt, 2, "mask: %s%s%s%s%s%s flags: %s%s%s%s%s%s Vcc %d Vpp %d irq %d\n",
319                         (state->csc_mask == 0)          ? "<NONE> " :   "",
320                         (state->csc_mask & SS_DETECT)   ? "DETECT " :   "",
321                         (state->csc_mask & SS_READY)    ? "READY " :    "",
322                         (state->csc_mask & SS_BATDEAD)  ? "BATDEAD " :  "",
323                         (state->csc_mask & SS_BATWARN)  ? "BATWARN " :  "",
324                         (state->csc_mask & SS_STSCHG)   ? "STSCHG " :   "",
325                         (state->flags == 0)             ? "<NONE> " :   "",
326                         (state->flags & SS_PWR_AUTO)    ? "PWR_AUTO " : "",
327                         (state->flags & SS_IOCARD)      ? "IOCARD " :   "",
328                         (state->flags & SS_RESET)       ? "RESET " :    "",
329                         (state->flags & SS_SPKR_ENA)    ? "SPKR_ENA " : "",
330                         (state->flags & SS_OUTPUT_ENA)  ? "OUTPUT_ENA " : "",
331                         state->Vcc, state->Vpp, state->io_irq);
332
333         return soc_common_pcmcia_config_skt(skt, state);
334 }
335
336
337 /*
338  * Implements the set_io_map() operation for the in-kernel PCMCIA
339  * service (formerly SS_SetIOMap in Card Services). We configure
340  * the map speed as requested, but override the address ranges
341  * supplied by Card Services.
342  *
343  * Returns: 0 on success, -1 on error
344  */
345 static int soc_common_pcmcia_set_io_map(
346         struct pcmcia_socket *sock, struct pccard_io_map *map)
347 {
348         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
349         unsigned short speed = map->speed;
350
351         debug(skt, 2, "map %u  speed %u start 0x%08llx stop 0x%08llx\n",
352                 map->map, map->speed, (unsigned long long)map->start,
353                 (unsigned long long)map->stop);
354         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
355                 (map->flags == 0)               ? "<NONE>"      : "",
356                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
357                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
358                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
359                 (map->flags & MAP_0WS)          ? "0WS "        : "",
360                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
361                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "",
362                 (map->flags & MAP_PREFETCH)     ? "PREFETCH "   : "");
363
364         if (map->map >= MAX_IO_WIN) {
365                 printk(KERN_ERR "%s(): map (%d) out of range\n", __func__,
366                        map->map);
367                 return -1;
368         }
369
370         if (map->flags & MAP_ACTIVE) {
371                 if (speed == 0)
372                         speed = SOC_PCMCIA_IO_ACCESS;
373         } else {
374                 speed = 0;
375         }
376
377         skt->spd_io[map->map] = speed;
378         skt->ops->set_timing(skt);
379
380         if (map->stop == 1)
381                 map->stop = PAGE_SIZE-1;
382
383         map->stop -= map->start;
384         map->stop += skt->socket.io_offset;
385         map->start = skt->socket.io_offset;
386
387         return 0;
388 }
389
390
391 /*
392  * Implements the set_mem_map() operation for the in-kernel PCMCIA
393  * service (formerly SS_SetMemMap in Card Services). We configure
394  * the map speed as requested, but override the address ranges
395  * supplied by Card Services.
396  *
397  * Returns: 0 on success, -ERRNO on error
398  */
399 static int soc_common_pcmcia_set_mem_map(
400         struct pcmcia_socket *sock, struct pccard_mem_map *map)
401 {
402         struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
403         struct resource *res;
404         unsigned short speed = map->speed;
405
406         debug(skt, 2, "map %u speed %u card_start %08x\n",
407                 map->map, map->speed, map->card_start);
408         debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
409                 (map->flags == 0)               ? "<NONE>"      : "",
410                 (map->flags & MAP_ACTIVE)       ? "ACTIVE "     : "",
411                 (map->flags & MAP_16BIT)        ? "16BIT "      : "",
412                 (map->flags & MAP_AUTOSZ)       ? "AUTOSZ "     : "",
413                 (map->flags & MAP_0WS)          ? "0WS "        : "",
414                 (map->flags & MAP_WRPROT)       ? "WRPROT "     : "",
415                 (map->flags & MAP_ATTRIB)       ? "ATTRIB "     : "",
416                 (map->flags & MAP_USE_WAIT)     ? "USE_WAIT "   : "");
417
418         if (map->map >= MAX_WIN)
419                 return -EINVAL;
420
421         if (map->flags & MAP_ACTIVE) {
422                 if (speed == 0)
423                         speed = 300;
424         } else {
425                 speed = 0;
426         }
427
428         if (map->flags & MAP_ATTRIB) {
429                 res = &skt->res_attr;
430                 skt->spd_attr[map->map] = speed;
431                 skt->spd_mem[map->map] = 0;
432         } else {
433                 res = &skt->res_mem;
434                 skt->spd_attr[map->map] = 0;
435                 skt->spd_mem[map->map] = speed;
436         }
437
438         skt->ops->set_timing(skt);
439
440         map->static_start = res->start + map->card_start;
441
442         return 0;
443 }
444
445 struct bittbl {
446         unsigned int mask;
447         const char *name;
448 };
449
450 static struct bittbl status_bits[] = {
451         { SS_WRPROT,            "SS_WRPROT"     },
452         { SS_BATDEAD,           "SS_BATDEAD"    },
453         { SS_BATWARN,           "SS_BATWARN"    },
454         { SS_READY,             "SS_READY"      },
455         { SS_DETECT,            "SS_DETECT"     },
456         { SS_POWERON,           "SS_POWERON"    },
457         { SS_STSCHG,            "SS_STSCHG"     },
458         { SS_3VCARD,            "SS_3VCARD"     },
459         { SS_XVCARD,            "SS_XVCARD"     },
460 };
461
462 static struct bittbl conf_bits[] = {
463         { SS_PWR_AUTO,          "SS_PWR_AUTO"   },
464         { SS_IOCARD,            "SS_IOCARD"     },
465         { SS_RESET,             "SS_RESET"      },
466         { SS_DMA_MODE,          "SS_DMA_MODE"   },
467         { SS_SPKR_ENA,          "SS_SPKR_ENA"   },
468         { SS_OUTPUT_ENA,        "SS_OUTPUT_ENA" },
469 };
470
471 static void dump_bits(char **p, const char *prefix,
472         unsigned int val, struct bittbl *bits, int sz)
473 {
474         char *b = *p;
475         int i;
476
477         b += sprintf(b, "%-9s:", prefix);
478         for (i = 0; i < sz; i++)
479                 if (val & bits[i].mask)
480                         b += sprintf(b, " %s", bits[i].name);
481         *b++ = '\n';
482         *p = b;
483 }
484
485 /*
486  * Implements the /sys/class/pcmcia_socket/??/status file.
487  *
488  * Returns: the number of characters added to the buffer
489  */
490 static ssize_t show_status(
491         struct device *dev, struct device_attribute *attr, char *buf)
492 {
493         struct soc_pcmcia_socket *skt =
494                 container_of(dev, struct soc_pcmcia_socket, socket.dev);
495         char *p = buf;
496
497         p += sprintf(p, "slot     : %d\n", skt->nr);
498
499         dump_bits(&p, "status", skt->status,
500                   status_bits, ARRAY_SIZE(status_bits));
501         dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
502                   status_bits, ARRAY_SIZE(status_bits));
503         dump_bits(&p, "cs_flags", skt->cs_state.flags,
504                   conf_bits, ARRAY_SIZE(conf_bits));
505
506         p += sprintf(p, "Vcc      : %d\n", skt->cs_state.Vcc);
507         p += sprintf(p, "Vpp      : %d\n", skt->cs_state.Vpp);
508         p += sprintf(p, "IRQ      : %d (%d)\n", skt->cs_state.io_irq,
509                 skt->socket.pci_irq);
510         if (skt->ops->show_timing)
511                 p += skt->ops->show_timing(skt, p);
512
513         return p-buf;
514 }
515 static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
516
517
518 static struct pccard_operations soc_common_pcmcia_operations = {
519         .init                   = soc_common_pcmcia_sock_init,
520         .suspend                = soc_common_pcmcia_suspend,
521         .get_status             = soc_common_pcmcia_get_status,
522         .set_socket             = soc_common_pcmcia_set_socket,
523         .set_io_map             = soc_common_pcmcia_set_io_map,
524         .set_mem_map            = soc_common_pcmcia_set_mem_map,
525 };
526
527
528 int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
529                             struct pcmcia_irqs *irqs, int nr)
530 {
531         int i, res = 0;
532
533         for (i = 0; i < nr; i++) {
534                 if (irqs[i].sock != skt->nr)
535                         continue;
536                 res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
537                                   IRQF_DISABLED, irqs[i].str, skt);
538                 if (res)
539                         break;
540                 set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
541         }
542
543         if (res) {
544                 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
545                         irqs[i].irq, res);
546
547                 while (i--)
548                         if (irqs[i].sock == skt->nr)
549                                 free_irq(irqs[i].irq, skt);
550         }
551         return res;
552 }
553 EXPORT_SYMBOL(soc_pcmcia_request_irqs);
554
555 void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
556                           struct pcmcia_irqs *irqs, int nr)
557 {
558         int i;
559
560         for (i = 0; i < nr; i++)
561                 if (irqs[i].sock == skt->nr)
562                         free_irq(irqs[i].irq, skt);
563 }
564 EXPORT_SYMBOL(soc_pcmcia_free_irqs);
565
566 void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
567                              struct pcmcia_irqs *irqs, int nr)
568 {
569         int i;
570
571         for (i = 0; i < nr; i++)
572                 if (irqs[i].sock == skt->nr)
573                         set_irq_type(irqs[i].irq, IRQ_TYPE_NONE);
574 }
575 EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
576
577 void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
578                             struct pcmcia_irqs *irqs, int nr)
579 {
580         int i;
581
582         for (i = 0; i < nr; i++)
583                 if (irqs[i].sock == skt->nr) {
584                         set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_RISING);
585                         set_irq_type(irqs[i].irq, IRQ_TYPE_EDGE_BOTH);
586                 }
587 }
588 EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
589
590
591 static LIST_HEAD(soc_pcmcia_sockets);
592 static DEFINE_MUTEX(soc_pcmcia_sockets_lock);
593
594 #ifdef CONFIG_CPU_FREQ
595 static int
596 soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
597 {
598         struct soc_pcmcia_socket *skt;
599         struct cpufreq_freqs *freqs = data;
600         int ret = 0;
601
602         mutex_lock(&soc_pcmcia_sockets_lock);
603         list_for_each_entry(skt, &soc_pcmcia_sockets, node)
604                 if (skt->ops->frequency_change)
605                         ret += skt->ops->frequency_change(skt, val, freqs);
606         mutex_unlock(&soc_pcmcia_sockets_lock);
607
608         return ret;
609 }
610
611 static struct notifier_block soc_pcmcia_notifier_block = {
612         .notifier_call  = soc_pcmcia_notifier
613 };
614
615 static int soc_pcmcia_cpufreq_register(void)
616 {
617         int ret;
618
619         ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
620                                         CPUFREQ_TRANSITION_NOTIFIER);
621         if (ret < 0)
622                 printk(KERN_ERR "Unable to register CPU frequency change "
623                                 "notifier for PCMCIA (%d)\n", ret);
624         return ret;
625 }
626 fs_initcall(soc_pcmcia_cpufreq_register);
627
628 static void soc_pcmcia_cpufreq_unregister(void)
629 {
630         cpufreq_unregister_notifier(&soc_pcmcia_notifier_block,
631                 CPUFREQ_TRANSITION_NOTIFIER);
632 }
633 module_exit(soc_pcmcia_cpufreq_unregister);
634
635 #endif
636
637 void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
638 {
639         mutex_lock(&soc_pcmcia_sockets_lock);
640         del_timer_sync(&skt->poll_timer);
641
642         pcmcia_unregister_socket(&skt->socket);
643
644         skt->ops->hw_shutdown(skt);
645
646         soc_common_pcmcia_config_skt(skt, &dead_socket);
647
648         list_del(&skt->node);
649         mutex_unlock(&soc_pcmcia_sockets_lock);
650
651         iounmap(skt->virt_io);
652         skt->virt_io = NULL;
653         release_resource(&skt->res_attr);
654         release_resource(&skt->res_mem);
655         release_resource(&skt->res_io);
656         release_resource(&skt->res_skt);
657 }
658 EXPORT_SYMBOL(soc_pcmcia_remove_one);
659
660 int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
661 {
662         int ret;
663
664         init_timer(&skt->poll_timer);
665         skt->poll_timer.function = soc_common_pcmcia_poll_event;
666         skt->poll_timer.data = (unsigned long)skt;
667         skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
668
669         ret = request_resource(&iomem_resource, &skt->res_skt);
670         if (ret)
671                 goto out_err_1;
672
673         ret = request_resource(&skt->res_skt, &skt->res_io);
674         if (ret)
675                 goto out_err_2;
676
677         ret = request_resource(&skt->res_skt, &skt->res_mem);
678         if (ret)
679                 goto out_err_3;
680
681         ret = request_resource(&skt->res_skt, &skt->res_attr);
682         if (ret)
683                 goto out_err_4;
684
685         skt->virt_io = ioremap(skt->res_io.start, 0x10000);
686         if (skt->virt_io == NULL) {
687                 ret = -ENOMEM;
688                 goto out_err_5;
689         }
690
691         mutex_lock(&soc_pcmcia_sockets_lock);
692
693         list_add(&skt->node, &soc_pcmcia_sockets);
694
695         /*
696          * We initialize default socket timing here, because
697          * we are not guaranteed to see a SetIOMap operation at
698          * runtime.
699          */
700         skt->ops->set_timing(skt);
701
702         ret = skt->ops->hw_init(skt);
703         if (ret)
704                 goto out_err_6;
705
706         skt->socket.ops = &soc_common_pcmcia_operations;
707         skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
708         skt->socket.resource_ops = &pccard_static_ops;
709         skt->socket.irq_mask = 0;
710         skt->socket.map_size = PAGE_SIZE;
711         skt->socket.io_offset = (unsigned long)skt->virt_io;
712
713         skt->status = soc_common_pcmcia_skt_state(skt);
714
715         ret = pcmcia_register_socket(&skt->socket);
716         if (ret)
717                 goto out_err_7;
718
719         add_timer(&skt->poll_timer);
720
721         mutex_unlock(&soc_pcmcia_sockets_lock);
722
723         ret = device_create_file(&skt->socket.dev, &dev_attr_status);
724         if (ret)
725                 goto out_err_8;
726
727         return ret;
728
729  out_err_8:
730         mutex_lock(&soc_pcmcia_sockets_lock);
731         del_timer_sync(&skt->poll_timer);
732         pcmcia_unregister_socket(&skt->socket);
733
734  out_err_7:
735         skt->ops->hw_shutdown(skt);
736  out_err_6:
737         list_del(&skt->node);
738         mutex_unlock(&soc_pcmcia_sockets_lock);
739         iounmap(skt->virt_io);
740  out_err_5:
741         release_resource(&skt->res_attr);
742  out_err_4:
743         release_resource(&skt->res_mem);
744  out_err_3:
745         release_resource(&skt->res_io);
746  out_err_2:
747         release_resource(&skt->res_skt);
748  out_err_1:
749
750         return ret;
751 }
752 EXPORT_SYMBOL(soc_pcmcia_add_one);
753
754 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
755 MODULE_DESCRIPTION("Linux PCMCIA Card Services: Common SoC support");
756 MODULE_LICENSE("Dual MPL/GPL");