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