1 /*======================================================================
3 Device driver for the PCMCIA control functionality of StrongARM
4 SA-1100 microprocessors.
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/
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.
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.
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.
31 ======================================================================*/
33 * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
34 * on the low-level kernel interface.
37 #include <linux/module.h>
38 #include <linux/moduleparam.h>
39 #include <linux/init.h>
40 #include <linux/config.h>
41 #include <linux/cpufreq.h>
42 #include <linux/ioport.h>
43 #include <linux/kernel.h>
44 #include <linux/timer.h>
46 #include <linux/notifier.h>
47 #include <linux/interrupt.h>
48 #include <linux/spinlock.h>
50 #include <asm/hardware.h>
53 #include <asm/system.h>
55 #include "sa11xx_core.h"
61 module_param(pc_debug, int, 0644);
63 #define debug(skt, lvl, fmt, arg...) do { \
64 if (pc_debug > (lvl)) \
65 printk(KERN_DEBUG "skt%u: %s: " fmt, \
66 (skt)->nr, __func__ , ## arg); \
70 #define debug(skt, lvl, fmt, arg...) do { } while (0)
73 #define to_sa1100_socket(x) container_of(x, struct sa1100_pcmcia_socket, socket)
76 * sa1100_pcmcia_default_mecr_timing
77 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
79 * Calculate MECR clock wait states for given CPU clock
80 * speed and command wait state. This function can be over-
81 * written by a board specific version.
83 * The default is to simply calculate the BS values as specified in
84 * the INTEL SA1100 development manual
85 * "Expansion Memory (PCMCIA) Configuration Register (MECR)"
86 * that's section 10.2.5 in _my_ version of the manual ;)
89 sa1100_pcmcia_default_mecr_timing(struct sa1100_pcmcia_socket *skt,
90 unsigned int cpu_speed,
91 unsigned int cmd_time)
93 return sa1100_pcmcia_mecr_bs(cmd_time, cpu_speed);
97 calc_speed(unsigned short *spds, int num, unsigned short dflt)
99 unsigned short speed = 0;
102 for (i = 0; i < num; i++)
111 /* sa1100_pcmcia_set_mecr()
112 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
114 * set MECR value for socket <sock> based on this sockets
115 * io, mem and attribute space access speed.
116 * Call board specific BS value calculation to allow boards
117 * to tweak the BS values.
120 sa1100_pcmcia_set_mecr(struct sa1100_pcmcia_socket *skt, unsigned int cpu_clock)
124 unsigned short speed;
125 unsigned int bs_io, bs_mem, bs_attr;
127 speed = calc_speed(skt->spd_io, MAX_IO_WIN, SA1100_PCMCIA_IO_ACCESS);
128 bs_io = skt->ops->socket_get_timing(skt, cpu_clock, speed);
130 speed = calc_speed(skt->spd_mem, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS);
131 bs_mem = skt->ops->socket_get_timing(skt, cpu_clock, speed);
133 speed = calc_speed(skt->spd_attr, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS);
134 bs_attr = skt->ops->socket_get_timing(skt, cpu_clock, speed);
136 local_irq_save(flags);
138 old_mecr = mecr = MECR;
139 MECR_FAST_SET(mecr, skt->nr, 0);
140 MECR_BSIO_SET(mecr, skt->nr, bs_io);
141 MECR_BSA_SET(mecr, skt->nr, bs_attr);
142 MECR_BSM_SET(mecr, skt->nr, bs_mem);
143 if (old_mecr != mecr)
146 local_irq_restore(flags);
148 debug(skt, 2, "FAST %X BSM %X BSA %X BSIO %X\n",
149 MECR_FAST_GET(mecr, skt->nr),
150 MECR_BSM_GET(mecr, skt->nr), MECR_BSA_GET(mecr, skt->nr),
151 MECR_BSIO_GET(mecr, skt->nr));
156 static unsigned int sa1100_pcmcia_skt_state(struct sa1100_pcmcia_socket *skt)
158 struct pcmcia_state state;
161 memset(&state, 0, sizeof(struct pcmcia_state));
163 skt->ops->socket_state(skt, &state);
165 stat = state.detect ? SS_DETECT : 0;
166 stat |= state.ready ? SS_READY : 0;
167 stat |= state.wrprot ? SS_WRPROT : 0;
168 stat |= state.vs_3v ? SS_3VCARD : 0;
169 stat |= state.vs_Xv ? SS_XVCARD : 0;
171 /* The power status of individual sockets is not available
172 * explicitly from the hardware, so we just remember the state
173 * and regurgitate it upon request:
175 stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
177 if (skt->cs_state.flags & SS_IOCARD)
178 stat |= state.bvd1 ? SS_STSCHG : 0;
182 else if (state.bvd2 == 0)
189 * sa1100_pcmcia_config_skt
190 * ^^^^^^^^^^^^^^^^^^^^^^^^
192 * Convert PCMCIA socket state to our socket configure structure.
195 sa1100_pcmcia_config_skt(struct sa1100_pcmcia_socket *skt, socket_state_t *state)
199 ret = skt->ops->configure_socket(skt, state);
202 * This really needs a better solution. The IRQ
203 * may or may not be claimed by the driver.
205 if (skt->irq_state != 1 && state->io_irq) {
207 set_irq_type(skt->irq, IRQT_FALLING);
208 } else if (skt->irq_state == 1 && state->io_irq == 0) {
210 set_irq_type(skt->irq, IRQT_NOEDGE);
213 skt->cs_state = *state;
217 printk(KERN_ERR "sa1100_pcmcia: unable to configure "
218 "socket %d\n", skt->nr);
223 /* sa1100_pcmcia_sock_init()
224 * ^^^^^^^^^^^^^^^^^^^^^^^^^
226 * (Re-)Initialise the socket, turning on status interrupts
227 * and PCMCIA bus. This must wait for power to stabilise
228 * so that the card status signals report correctly.
232 static int sa1100_pcmcia_sock_init(struct pcmcia_socket *sock)
234 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
236 debug(skt, 2, "initializing socket\n");
238 skt->ops->socket_init(skt);
244 * sa1100_pcmcia_suspend()
245 * ^^^^^^^^^^^^^^^^^^^^^^^
247 * Remove power on the socket, disable IRQs from the card.
248 * Turn off status interrupts, and disable the PCMCIA bus.
252 static int sa1100_pcmcia_suspend(struct pcmcia_socket *sock)
254 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
257 debug(skt, 2, "suspending socket\n");
259 ret = sa1100_pcmcia_config_skt(skt, &dead_socket);
261 skt->ops->socket_suspend(skt);
266 static spinlock_t status_lock = SPIN_LOCK_UNLOCKED;
268 /* sa1100_check_status()
269 * ^^^^^^^^^^^^^^^^^^^^^
271 static void sa1100_check_status(struct sa1100_pcmcia_socket *skt)
275 debug(skt, 4, "entering PCMCIA monitoring thread\n");
281 status = sa1100_pcmcia_skt_state(skt);
283 spin_lock_irqsave(&status_lock, flags);
284 events = (status ^ skt->status) & skt->cs_state.csc_mask;
285 skt->status = status;
286 spin_unlock_irqrestore(&status_lock, flags);
288 debug(skt, 4, "events: %s%s%s%s%s%s\n",
289 events == 0 ? "<NONE>" : "",
290 events & SS_DETECT ? "DETECT " : "",
291 events & SS_READY ? "READY " : "",
292 events & SS_BATDEAD ? "BATDEAD " : "",
293 events & SS_BATWARN ? "BATWARN " : "",
294 events & SS_STSCHG ? "STSCHG " : "");
297 pcmcia_parse_events(&skt->socket, events);
301 /* sa1100_pcmcia_poll_event()
302 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
303 * Let's poll for events in addition to IRQs since IRQ only is unreliable...
305 static void sa1100_pcmcia_poll_event(unsigned long dummy)
307 struct sa1100_pcmcia_socket *skt = (struct sa1100_pcmcia_socket *)dummy;
308 debug(skt, 4, "polling for events\n");
310 mod_timer(&skt->poll_timer, jiffies + SA1100_PCMCIA_POLL_PERIOD);
312 sa1100_check_status(skt);
316 /* sa1100_pcmcia_interrupt()
317 * ^^^^^^^^^^^^^^^^^^^^^^^^^
318 * Service routine for socket driver interrupts (requested by the
319 * low-level PCMCIA init() operation via sa1100_pcmcia_thread()).
320 * The actual interrupt-servicing work is performed by
321 * sa1100_pcmcia_thread(), largely because the Card Services event-
322 * handling code performs scheduling operations which cannot be
323 * executed from within an interrupt context.
325 static irqreturn_t sa1100_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
327 struct sa1100_pcmcia_socket *skt = dev;
329 debug(skt, 3, "servicing IRQ %d\n", irq);
331 sa1100_check_status(skt);
337 /* sa1100_pcmcia_get_status()
338 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
339 * Implements the get_status() operation for the in-kernel PCMCIA
340 * service (formerly SS_GetStatus in Card Services). Essentially just
341 * fills in bits in `status' according to internal driver state or
342 * the value of the voltage detect chipselect register.
344 * As a debugging note, during card startup, the PCMCIA core issues
345 * three set_socket() commands in a row the first with RESET deasserted,
346 * the second with RESET asserted, and the last with RESET deasserted
347 * again. Following the third set_socket(), a get_status() command will
348 * be issued. The kernel is looking for the SS_READY flag (see
349 * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
354 sa1100_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
356 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
358 skt->status = sa1100_pcmcia_skt_state(skt);
359 *status = skt->status;
365 /* sa1100_pcmcia_get_socket()
366 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
367 * Implements the get_socket() operation for the in-kernel PCMCIA
368 * service (formerly SS_GetSocket in Card Services). Not a very
374 sa1100_pcmcia_get_socket(struct pcmcia_socket *sock, socket_state_t *state)
376 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
380 *state = skt->cs_state;
385 /* sa1100_pcmcia_set_socket()
386 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
387 * Implements the set_socket() operation for the in-kernel PCMCIA
388 * service (formerly SS_SetSocket in Card Services). We more or
389 * less punt all of this work and let the kernel handle the details
390 * of power configuration, reset, &c. We also record the value of
391 * `state' in order to regurgitate it to the PCMCIA core later.
396 sa1100_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
398 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
400 debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
401 (state->csc_mask==0)?"<NONE> ":"",
402 (state->csc_mask&SS_DETECT)?"DETECT ":"",
403 (state->csc_mask&SS_READY)?"READY ":"",
404 (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
405 (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
406 (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
407 (state->flags==0)?"<NONE> ":"",
408 (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
409 (state->flags&SS_IOCARD)?"IOCARD ":"",
410 (state->flags&SS_RESET)?"RESET ":"",
411 (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
412 (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
413 state->Vcc, state->Vpp, state->io_irq);
415 return sa1100_pcmcia_config_skt(skt, state);
416 } /* sa1100_pcmcia_set_socket() */
419 /* sa1100_pcmcia_set_io_map()
420 * ^^^^^^^^^^^^^^^^^^^^^^^^^^
421 * Implements the set_io_map() operation for the in-kernel PCMCIA
422 * service (formerly SS_SetIOMap in Card Services). We configure
423 * the map speed as requested, but override the address ranges
424 * supplied by Card Services.
426 * Returns: 0 on success, -1 on error
429 sa1100_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
431 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
432 unsigned short speed = map->speed;
434 debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
435 map->map, map->speed, map->start, map->stop);
436 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
437 (map->flags==0)?"<NONE>":"",
438 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
439 (map->flags&MAP_16BIT)?"16BIT ":"",
440 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
441 (map->flags&MAP_0WS)?"0WS ":"",
442 (map->flags&MAP_WRPROT)?"WRPROT ":"",
443 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
444 (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
446 if (map->map >= MAX_IO_WIN) {
447 printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
452 if (map->flags & MAP_ACTIVE) {
454 speed = SA1100_PCMCIA_IO_ACCESS;
459 skt->spd_io[map->map] = speed;
460 sa1100_pcmcia_set_mecr(skt, cpufreq_get(0));
463 map->stop = PAGE_SIZE-1;
465 map->stop -= map->start;
466 map->stop += (unsigned long)skt->virt_io;
467 map->start = (unsigned long)skt->virt_io;
470 } /* sa1100_pcmcia_set_io_map() */
473 /* sa1100_pcmcia_set_mem_map()
474 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
475 * Implements the set_mem_map() operation for the in-kernel PCMCIA
476 * service (formerly SS_SetMemMap in Card Services). We configure
477 * the map speed as requested, but override the address ranges
478 * supplied by Card Services.
480 * Returns: 0 on success, -1 on error
483 sa1100_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
485 struct sa1100_pcmcia_socket *skt = to_sa1100_socket(sock);
486 struct resource *res;
487 unsigned short speed = map->speed;
489 debug(skt, 2, "map %u speed %u card_start %08x\n",
490 map->map, map->speed, map->card_start);
491 debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
492 (map->flags==0)?"<NONE>":"",
493 (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
494 (map->flags&MAP_16BIT)?"16BIT ":"",
495 (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
496 (map->flags&MAP_0WS)?"0WS ":"",
497 (map->flags&MAP_WRPROT)?"WRPROT ":"",
498 (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
499 (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
501 if (map->map >= MAX_WIN)
504 if (map->flags & MAP_ACTIVE) {
511 if (map->flags & MAP_ATTRIB) {
512 res = &skt->res_attr;
513 skt->spd_attr[map->map] = speed;
514 skt->spd_mem[map->map] = 0;
517 skt->spd_attr[map->map] = 0;
518 skt->spd_mem[map->map] = speed;
521 sa1100_pcmcia_set_mecr(skt, cpufreq_get(0));
523 map->sys_stop -= map->sys_start;
524 map->sys_stop += res->start + map->card_start;
525 map->sys_start = res->start + map->card_start;
535 static struct bittbl status_bits[] = {
536 { SS_WRPROT, "SS_WRPROT" },
537 { SS_BATDEAD, "SS_BATDEAD" },
538 { SS_BATWARN, "SS_BATWARN" },
539 { SS_READY, "SS_READY" },
540 { SS_DETECT, "SS_DETECT" },
541 { SS_POWERON, "SS_POWERON" },
542 { SS_STSCHG, "SS_STSCHG" },
543 { SS_3VCARD, "SS_3VCARD" },
544 { SS_XVCARD, "SS_XVCARD" },
547 static struct bittbl conf_bits[] = {
548 { SS_PWR_AUTO, "SS_PWR_AUTO" },
549 { SS_IOCARD, "SS_IOCARD" },
550 { SS_RESET, "SS_RESET" },
551 { SS_DMA_MODE, "SS_DMA_MODE" },
552 { SS_SPKR_ENA, "SS_SPKR_ENA" },
553 { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
557 dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
562 b += sprintf(b, "%-9s:", prefix);
563 for (i = 0; i < sz; i++)
564 if (val & bits[i].mask)
565 b += sprintf(b, " %s", bits[i].name);
571 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
572 * Implements the /sys/class/pcmcia_socket/??/status file.
574 * Returns: the number of characters added to the buffer
576 static ssize_t show_status(struct class_device *class_dev, char *buf)
578 struct sa1100_pcmcia_socket *skt = container_of(class_dev,
579 struct sa1100_pcmcia_socket, socket.dev);
580 unsigned int clock = cpufreq_get(0);
581 unsigned long mecr = MECR;
584 p+=sprintf(p, "slot : %d\n", skt->nr);
586 dump_bits(&p, "status", skt->status,
587 status_bits, ARRAY_SIZE(status_bits));
588 dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
589 status_bits, ARRAY_SIZE(status_bits));
590 dump_bits(&p, "cs_flags", skt->cs_state.flags,
591 conf_bits, ARRAY_SIZE(conf_bits));
593 p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
594 p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
595 p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
597 p+=sprintf(p, "I/O : %u (%u)\n",
598 calc_speed(skt->spd_io, MAX_IO_WIN, SA1100_PCMCIA_IO_ACCESS),
599 sa1100_pcmcia_cmd_time(clock, MECR_BSIO_GET(mecr, skt->nr)));
601 p+=sprintf(p, "attribute: %u (%u)\n",
602 calc_speed(skt->spd_attr, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS),
603 sa1100_pcmcia_cmd_time(clock, MECR_BSA_GET(mecr, skt->nr)));
605 p+=sprintf(p, "common : %u (%u)\n",
606 calc_speed(skt->spd_mem, MAX_WIN, SA1100_PCMCIA_3V_MEM_ACCESS),
607 sa1100_pcmcia_cmd_time(clock, MECR_BSM_GET(mecr, skt->nr)));
611 static CLASS_DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
614 static struct pccard_operations sa11xx_pcmcia_operations = {
615 .init = sa1100_pcmcia_sock_init,
616 .suspend = sa1100_pcmcia_suspend,
617 .get_status = sa1100_pcmcia_get_status,
618 .get_socket = sa1100_pcmcia_get_socket,
619 .set_socket = sa1100_pcmcia_set_socket,
620 .set_io_map = sa1100_pcmcia_set_io_map,
621 .set_mem_map = sa1100_pcmcia_set_mem_map,
624 int sa11xx_request_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
628 for (i = 0; i < nr; i++) {
629 if (irqs[i].sock != skt->nr)
631 res = request_irq(irqs[i].irq, sa1100_pcmcia_interrupt,
632 SA_INTERRUPT, irqs[i].str, skt);
635 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
639 printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
643 if (irqs[i].sock == skt->nr)
644 free_irq(irqs[i].irq, skt);
648 EXPORT_SYMBOL(sa11xx_request_irqs);
650 void sa11xx_free_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
654 for (i = 0; i < nr; i++)
655 if (irqs[i].sock == skt->nr)
656 free_irq(irqs[i].irq, skt);
658 EXPORT_SYMBOL(sa11xx_free_irqs);
660 void sa11xx_disable_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
664 for (i = 0; i < nr; i++)
665 if (irqs[i].sock == skt->nr)
666 set_irq_type(irqs[i].irq, IRQT_NOEDGE);
668 EXPORT_SYMBOL(sa11xx_disable_irqs);
670 void sa11xx_enable_irqs(struct sa1100_pcmcia_socket *skt, struct pcmcia_irqs *irqs, int nr)
674 for (i = 0; i < nr; i++)
675 if (irqs[i].sock == skt->nr) {
676 set_irq_type(irqs[i].irq, IRQT_RISING);
677 set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
680 EXPORT_SYMBOL(sa11xx_enable_irqs);
682 static LIST_HEAD(sa1100_sockets);
683 static DECLARE_MUTEX(sa1100_sockets_lock);
685 static const char *skt_names[] = {
690 struct skt_dev_info {
692 struct sa1100_pcmcia_socket skt[0];
695 #define SKT_DEV_INFO_SIZE(n) \
696 (sizeof(struct skt_dev_info) + (n)*sizeof(struct sa1100_pcmcia_socket))
698 int sa11xx_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
700 struct skt_dev_info *sinfo;
701 unsigned int cpu_clock;
705 * set default MECR calculation if the board specific
706 * code did not specify one...
708 if (!ops->socket_get_timing)
709 ops->socket_get_timing = sa1100_pcmcia_default_mecr_timing;
711 down(&sa1100_sockets_lock);
713 sinfo = kmalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
719 memset(sinfo, 0, SKT_DEV_INFO_SIZE(nr));
722 cpu_clock = cpufreq_get(0);
725 * Initialise the per-socket structure.
727 for (i = 0; i < nr; i++) {
728 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
730 skt->socket.ops = &sa11xx_pcmcia_operations;
731 skt->socket.owner = ops->owner;
732 skt->socket.dev.dev = dev;
734 init_timer(&skt->poll_timer);
735 skt->poll_timer.function = sa1100_pcmcia_poll_event;
736 skt->poll_timer.data = (unsigned long)skt;
737 skt->poll_timer.expires = jiffies + SA1100_PCMCIA_POLL_PERIOD;
744 skt->res_skt.start = _PCMCIA(skt->nr);
745 skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
746 skt->res_skt.name = skt_names[skt->nr];
747 skt->res_skt.flags = IORESOURCE_MEM;
749 ret = request_resource(&iomem_resource, &skt->res_skt);
753 skt->res_io.start = _PCMCIAIO(skt->nr);
754 skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
755 skt->res_io.name = "io";
756 skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
758 ret = request_resource(&skt->res_skt, &skt->res_io);
762 skt->res_mem.start = _PCMCIAMem(skt->nr);
763 skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
764 skt->res_mem.name = "memory";
765 skt->res_mem.flags = IORESOURCE_MEM;
767 ret = request_resource(&skt->res_skt, &skt->res_mem);
771 skt->res_attr.start = _PCMCIAAttr(skt->nr);
772 skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
773 skt->res_attr.name = "attribute";
774 skt->res_attr.flags = IORESOURCE_MEM;
776 ret = request_resource(&skt->res_skt, &skt->res_attr);
780 skt->virt_io = ioremap(skt->res_io.start, 0x10000);
781 if (skt->virt_io == NULL) {
786 list_add(&skt->node, &sa1100_sockets);
789 * We initialize the MECR to default values here, because
790 * we are not guaranteed to see a SetIOMap operation at
793 sa1100_pcmcia_set_mecr(skt, cpu_clock);
795 ret = ops->hw_init(skt);
799 skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
800 skt->socket.irq_mask = 0;
801 skt->socket.map_size = PAGE_SIZE;
802 skt->socket.pci_irq = skt->irq;
803 skt->socket.io_offset = (unsigned long)skt->virt_io;
805 skt->status = sa1100_pcmcia_skt_state(skt);
807 ret = pcmcia_register_socket(&skt->socket);
811 WARN_ON(skt->socket.sock != i);
813 add_timer(&skt->poll_timer);
815 class_device_create_file(&skt->socket.dev, &class_device_attr_status);
818 dev_set_drvdata(dev, sinfo);
823 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
825 del_timer_sync(&skt->poll_timer);
826 pcmcia_unregister_socket(&skt->socket);
829 flush_scheduled_work();
831 ops->hw_shutdown(skt);
833 list_del(&skt->node);
834 iounmap(skt->virt_io);
836 release_resource(&skt->res_attr);
838 release_resource(&skt->res_mem);
840 release_resource(&skt->res_io);
842 release_resource(&skt->res_skt);
850 up(&sa1100_sockets_lock);
853 EXPORT_SYMBOL(sa11xx_drv_pcmcia_probe);
855 int sa11xx_drv_pcmcia_remove(struct device *dev)
857 struct skt_dev_info *sinfo = dev_get_drvdata(dev);
860 dev_set_drvdata(dev, NULL);
862 down(&sa1100_sockets_lock);
863 for (i = 0; i < sinfo->nskt; i++) {
864 struct sa1100_pcmcia_socket *skt = &sinfo->skt[i];
866 del_timer_sync(&skt->poll_timer);
868 pcmcia_unregister_socket(&skt->socket);
870 flush_scheduled_work();
872 skt->ops->hw_shutdown(skt);
874 sa1100_pcmcia_config_skt(skt, &dead_socket);
876 list_del(&skt->node);
877 iounmap(skt->virt_io);
879 release_resource(&skt->res_attr);
880 release_resource(&skt->res_mem);
881 release_resource(&skt->res_io);
882 release_resource(&skt->res_skt);
884 up(&sa1100_sockets_lock);
890 EXPORT_SYMBOL(sa11xx_drv_pcmcia_remove);
892 #ifdef CONFIG_CPU_FREQ
894 /* sa1100_pcmcia_update_mecr()
895 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
896 * When sa1100_pcmcia_notifier() decides that a MECR adjustment (due
897 * to a core clock frequency change) is needed, this routine establishes
898 * new BS_xx values consistent with the clock speed `clock'.
900 static void sa1100_pcmcia_update_mecr(unsigned int clock)
902 struct sa1100_pcmcia_socket *skt;
904 down(&sa1100_sockets_lock);
905 list_for_each_entry(skt, &sa1100_sockets, node)
906 sa1100_pcmcia_set_mecr(skt, clock);
907 up(&sa1100_sockets_lock);
910 /* sa1100_pcmcia_notifier()
911 * ^^^^^^^^^^^^^^^^^^^^^^^^
912 * When changing the processor core clock frequency, it is necessary
913 * to adjust the MECR timings accordingly. We've recorded the timings
914 * requested by Card Services, so this is just a matter of finding
915 * out what our current speed is, and then recomputing the new MECR
918 * Returns: 0 on success, -1 on error
921 sa1100_pcmcia_notifier(struct notifier_block *nb, unsigned long val,
924 struct cpufreq_freqs *freqs = data;
927 case CPUFREQ_PRECHANGE:
928 if (freqs->new > freqs->old)
929 sa1100_pcmcia_update_mecr(freqs->new);
932 case CPUFREQ_POSTCHANGE:
933 if (freqs->new < freqs->old)
934 sa1100_pcmcia_update_mecr(freqs->new);
941 static struct notifier_block sa1100_pcmcia_notifier_block = {
942 .notifier_call = sa1100_pcmcia_notifier
945 static int __init sa11xx_pcmcia_init(void)
949 printk(KERN_INFO "SA11xx PCMCIA\n");
951 ret = cpufreq_register_notifier(&sa1100_pcmcia_notifier_block,
952 CPUFREQ_TRANSITION_NOTIFIER);
954 printk(KERN_ERR "Unable to register CPU frequency change "
955 "notifier (%d)\n", ret);
959 module_init(sa11xx_pcmcia_init);
961 static void __exit sa11xx_pcmcia_exit(void)
963 cpufreq_unregister_notifier(&sa1100_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
966 module_exit(sa11xx_pcmcia_exit);
969 MODULE_AUTHOR("John Dorsey <john+@cs.cmu.edu>");
970 MODULE_DESCRIPTION("Linux PCMCIA Card Services: SA-11xx core socket driver");
971 MODULE_LICENSE("Dual MPL/GPL");