2 * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
4 * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
8 /* This is a fairly generic PCMCIA socket driver suitable for the
9 * following Alchemy Development boards:
10 * Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200.
12 * The Db1000 is used as a reference: Per-socket card-, carddetect- and
13 * statuschange IRQs connected to SoC GPIOs, control and status register
14 * bits arranged in per-socket groups in an external PLD. All boards
15 * listed here use this layout, including bit positions and meanings.
16 * Of course there are exceptions in later boards:
18 * - Pb1100/Pb1500: single socket only; voltage key bits VS are
19 * at STATUS[5:4] (instead of STATUS[1:0]).
20 * - Au1200-based: additional card-eject irqs, irqs not gpios!
23 #include <linux/delay.h>
24 #include <linux/gpio.h>
25 #include <linux/interrupt.h>
27 #include <linux/platform_device.h>
28 #include <linux/resource.h>
29 #include <linux/spinlock.h>
31 #include <pcmcia/cs_types.h>
32 #include <pcmcia/ss.h>
34 #include <asm/mach-au1x00/au1000.h>
35 #include <asm/mach-db1x00/bcsr.h>
37 #define MEM_MAP_SIZE 0x400000
38 #define IO_MAP_SIZE 0x1000
40 struct db1x_pcmcia_sock {
41 struct pcmcia_socket socket;
42 int nr; /* socket number */
45 /* the "pseudo" addresses of the PCMCIA space. */
46 unsigned long phys_io;
47 unsigned long phys_attr;
48 unsigned long phys_mem;
50 /* previous flags for set_socket() */
51 unsigned int old_flags;
53 /* interrupt sources: linux irq numbers! */
54 int insert_irq; /* default carddetect irq */
55 int stschg_irq; /* card-status-change irq */
56 int card_irq; /* card irq */
57 int eject_irq; /* db1200/pb1200 have these */
59 #define BOARD_TYPE_DEFAULT 0 /* most boards */
60 #define BOARD_TYPE_DB1200 1 /* IRQs aren't gpios */
61 #define BOARD_TYPE_PB1100 2 /* VS bits slightly different */
65 #define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)
67 /* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
68 static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
70 unsigned short sigstat;
72 sigstat = bcsr_read(BCSR_SIGSTAT);
73 return sigstat & 1 << (8 + 2 * sock->nr);
76 /* carddetect gpio: low-active */
77 static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
79 return !gpio_get_value(irq_to_gpio(sock->insert_irq));
82 static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
84 switch (sock->board_type) {
85 case BOARD_TYPE_DB1200:
86 return db1200_card_inserted(sock);
88 return db1000_card_inserted(sock);
92 /* STSCHG tends to bounce heavily when cards are inserted/ejected.
93 * To avoid this, the interrupt is normally disabled and only enabled
94 * after reset to a card has been de-asserted.
96 static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
98 if (sock->stschg_irq != -1) {
100 enable_irq(sock->stschg_irq);
102 disable_irq(sock->stschg_irq);
106 static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
108 struct db1x_pcmcia_sock *sock = data;
110 pcmcia_parse_events(&sock->socket, SS_DETECT);
115 static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
117 struct db1x_pcmcia_sock *sock = data;
119 pcmcia_parse_events(&sock->socket, SS_STSCHG);
124 static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
126 struct db1x_pcmcia_sock *sock = data;
128 /* Db/Pb1200 have separate per-socket insertion and ejection
129 * interrupts which stay asserted as long as the card is
130 * inserted/missing. The one which caused us to be called
131 * needs to be disabled and the other one enabled.
133 if (irq == sock->insert_irq) {
134 disable_irq_nosync(sock->insert_irq);
135 enable_irq(sock->eject_irq);
137 disable_irq_nosync(sock->eject_irq);
138 enable_irq(sock->insert_irq);
141 pcmcia_parse_events(&sock->socket, SS_DETECT);
146 static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
151 if (sock->stschg_irq != -1) {
152 ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
153 0, "pcmcia_stschg", sock);
158 /* Db/Pb1200 have separate per-socket insertion and ejection
159 * interrupts, which should show edge behaviour but don't.
160 * So interrupts are disabled until both insertion and
161 * ejection handler have been registered and the currently
162 * active one disabled.
164 if (sock->board_type == BOARD_TYPE_DB1200) {
165 local_irq_save(flags);
167 ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq,
168 IRQF_DISABLED, "pcmcia_insert", sock);
172 ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq,
173 IRQF_DISABLED, "pcmcia_eject", sock);
175 free_irq(sock->insert_irq, sock);
176 local_irq_restore(flags);
180 /* disable the currently active one */
181 if (db1200_card_inserted(sock))
182 disable_irq_nosync(sock->insert_irq);
184 disable_irq_nosync(sock->eject_irq);
186 local_irq_restore(flags);
188 /* all other (older) Db1x00 boards use a GPIO to show
189 * card detection status: use both-edge triggers.
191 set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
192 ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
193 0, "pcmcia_carddetect", sock);
199 return 0; /* all done */
202 if (sock->stschg_irq != -1)
203 free_irq(sock->stschg_irq, sock);
208 static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
210 if (sock->stschg_irq != -1)
211 free_irq(sock->stschg_irq, sock);
213 free_irq(sock->insert_irq, sock);
214 if (sock->eject_irq != -1)
215 free_irq(sock->eject_irq, sock);
219 * configure a PCMCIA socket on the Db1x00 series of boards (and
222 * 2 external registers are involved:
223 * pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
224 * pcmcia_control(offset 0x10):
225 * bits[0:1] set vcc for card
226 * bits[2:3] set vpp for card
227 * bit 4: enable data buffers
228 * bit 7: reset# for card
229 * add 8 for second socket.
231 static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
232 struct socket_state_t *state)
234 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
235 unsigned short cr_clr, cr_set;
236 unsigned int changed;
239 /* card voltage setup */
240 cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
244 switch (state->Vcc) {
252 printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
253 sock->nr, state->Vcc);
256 switch (state->Vpp) {
265 printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
266 sock->nr, state->Vpp);
269 /* sanity check: Vpp must be 0, 12, or Vcc */
270 if (((state->Vcc == 33) && (state->Vpp == 50)) ||
271 ((state->Vcc == 50) && (state->Vpp == 33))) {
272 printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
273 sock->nr, state->Vcc, state->Vpp);
278 /* create new voltage code */
279 cr_set |= ((v << 2) | p) << (sock->nr * 8);
281 changed = state->flags ^ sock->old_flags;
283 if (changed & SS_RESET) {
284 if (state->flags & SS_RESET) {
286 /* assert reset, disable io buffers */
287 cr_clr |= (1 << (7 + (sock->nr * 8)));
288 cr_clr |= (1 << (4 + (sock->nr * 8)));
290 /* de-assert reset, enable io buffers */
291 cr_set |= 1 << (7 + (sock->nr * 8));
292 cr_set |= 1 << (4 + (sock->nr * 8));
296 /* update PCMCIA configuration */
297 bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);
299 sock->old_flags = state->flags;
301 /* reset was taken away: give card time to initialize properly */
302 if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
310 /* VCC bits at [3:2]/[11:10] */
311 #define GET_VCC(cr, socknr) \
312 ((((cr) >> 2) >> ((socknr) * 8)) & 3)
314 /* VS bits at [0:1]/[3:2] */
315 #define GET_VS(sr, socknr) \
316 (((sr) >> (2 * (socknr))) & 3)
318 /* reset bits at [7]/[15] */
319 #define GET_RESET(cr, socknr) \
320 ((cr) & (1 << (7 + (8 * (socknr)))))
322 static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
325 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
326 unsigned short cr, sr;
329 status = db1x_card_inserted(sock) ? SS_DETECT : 0;
331 cr = bcsr_read(BCSR_PCMCIA);
332 sr = bcsr_read(BCSR_STATUS);
334 /* PB1100/PB1500: voltage key bits are at [5:4] */
335 if (sock->board_type == BOARD_TYPE_PB1100)
338 /* determine card type */
339 switch (GET_VS(sr, sock->nr)) {
342 status |= SS_3VCARD; /* 3V card */
344 break; /* 5V card: set nothing */
346 status |= SS_XVCARD; /* treated as unsupported in core */
349 /* if Vcc is not zero, we have applied power to a card */
350 status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;
352 /* reset de-asserted? then we're ready */
353 status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;
360 static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
365 static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
370 static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
371 struct pccard_io_map *map)
373 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
375 map->start = (u32)sock->virt_io;
376 map->stop = map->start + IO_MAP_SIZE;
381 static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
382 struct pccard_mem_map *map)
384 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
386 if (map->flags & MAP_ATTRIB)
387 map->static_start = sock->phys_attr + map->card_start;
389 map->static_start = sock->phys_mem + map->card_start;
394 static struct pccard_operations db1x_pcmcia_operations = {
395 .init = db1x_pcmcia_sock_init,
396 .suspend = db1x_pcmcia_sock_suspend,
397 .get_status = db1x_pcmcia_get_status,
398 .set_socket = db1x_pcmcia_configure,
399 .set_io_map = au1x00_pcmcia_set_io_map,
400 .set_mem_map = au1x00_pcmcia_set_mem_map,
403 static int __devinit db1x_pcmcia_socket_probe(struct platform_device *pdev)
405 struct db1x_pcmcia_sock *sock;
410 sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
416 bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
418 case BCSR_WHOAMI_PB1500:
419 case BCSR_WHOAMI_PB1500R2:
420 case BCSR_WHOAMI_PB1100:
421 sock->board_type = BOARD_TYPE_PB1100;
423 case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
424 sock->board_type = BOARD_TYPE_DEFAULT;
426 case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
427 sock->board_type = BOARD_TYPE_DB1200;
430 printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
436 * gather resources necessary and optional nice-to-haves to
438 * This includes IRQs for Carddetection/ejection, the card
439 * itself and optional status change detection.
440 * Also, the memory areas covered by a socket. For these
441 * we require the 32bit "pseudo" addresses (see the au1000.h
442 * header for more information).
445 /* card: irq assigned to the card itself. */
446 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
447 sock->card_irq = r ? r->start : 0;
449 /* insert: irq which triggers on card insertion/ejection */
450 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
451 sock->insert_irq = r ? r->start : -1;
453 /* stschg: irq which trigger on card status change (optional) */
454 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
455 sock->stschg_irq = r ? r->start : -1;
457 /* eject: irq which triggers on ejection (DB1200/PB1200 only) */
458 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
459 sock->eject_irq = r ? r->start : -1;
464 * pseudo-attr: The 32bit address of the PCMCIA attribute space
465 * for this socket (usually the 36bit address shifted 4 to the
468 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-attr");
470 printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
474 sock->phys_attr = r->start;
477 * pseudo-mem: The 32bit address of the PCMCIA memory space for
478 * this socket (usually the 36bit address shifted 4 to the right)
480 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-mem");
482 printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
486 sock->phys_mem = r->start;
489 * pseudo-io: The 32bit address of the PCMCIA IO space for this
490 * socket (usually the 36bit address shifted 4 to the right).
492 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pseudo-io");
494 printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
498 sock->phys_io = r->start;
501 /* IO: we must remap the full 36bit address (for reference see
502 * alchemy/common/setup.c::__fixup_bigphys_addr())
504 physio = ((phys_t)sock->phys_io) << 4;
507 * PCMCIA client drivers use the inb/outb macros to access
508 * the IO registers. Since mips_io_port_base is added
509 * to the access address of the mips implementation of
510 * inb/outb, we need to subtract it here because we want
511 * to access the I/O or MEM address directly, without
512 * going through this "mips_io_port_base" mechanism.
514 sock->virt_io = (void *)(ioremap(physio, IO_MAP_SIZE) -
517 if (!sock->virt_io) {
518 printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
524 sock->socket.ops = &db1x_pcmcia_operations;
525 sock->socket.owner = THIS_MODULE;
526 sock->socket.pci_irq = sock->card_irq;
527 sock->socket.features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
528 sock->socket.map_size = MEM_MAP_SIZE;
529 sock->socket.io_offset = (unsigned long)sock->virt_io;
530 sock->socket.dev.parent = &pdev->dev;
531 sock->socket.resource_ops = &pccard_static_ops;
533 platform_set_drvdata(pdev, sock);
535 ret = db1x_pcmcia_setup_irqs(sock);
537 printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
544 ret = pcmcia_register_socket(&sock->socket);
546 printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
550 printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %08lx"
551 "(%p) %08lx %08lx card/insert/stschg/eject irqs @ %d "
552 "%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
553 sock->phys_attr, sock->phys_mem, sock->card_irq,
554 sock->insert_irq, sock->stschg_irq, sock->eject_irq);
559 db1x_pcmcia_free_irqs(sock);
561 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
567 static int __devexit db1x_pcmcia_socket_remove(struct platform_device *pdev)
569 struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);
571 db1x_pcmcia_free_irqs(sock);
572 pcmcia_unregister_socket(&sock->socket);
573 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
580 static int db1x_pcmcia_suspend(struct device *dev)
582 return pcmcia_socket_dev_suspend(dev);
585 static int db1x_pcmcia_resume(struct device *dev)
587 return pcmcia_socket_dev_resume(dev);
590 static struct dev_pm_ops db1x_pcmcia_pmops = {
591 .resume = db1x_pcmcia_resume,
592 .suspend = db1x_pcmcia_suspend,
593 .thaw = db1x_pcmcia_resume,
594 .freeze = db1x_pcmcia_suspend,
597 #define DB1XXX_SS_PMOPS &db1x_pcmcia_pmops
601 #define DB1XXX_SS_PMOPS NULL
605 static struct platform_driver db1x_pcmcia_socket_driver = {
607 .name = "db1xxx_pcmcia",
608 .owner = THIS_MODULE,
609 .pm = DB1XXX_SS_PMOPS
611 .probe = db1x_pcmcia_socket_probe,
612 .remove = __devexit_p(db1x_pcmcia_socket_remove),
615 int __init db1x_pcmcia_socket_load(void)
617 return platform_driver_register(&db1x_pcmcia_socket_driver);
620 void __exit db1x_pcmcia_socket_unload(void)
622 platform_driver_unregister(&db1x_pcmcia_socket_driver);
625 module_init(db1x_pcmcia_socket_load);
626 module_exit(db1x_pcmcia_socket_unload);
628 MODULE_LICENSE("GPL");
629 MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
630 MODULE_AUTHOR("Manuel Lauss");