blob: 27575e6378a1a6259410e3882004cbb68a716281 [file] [log] [blame]
Manuel Lauss66213b32009-10-04 14:55:27 +02001/*
2 * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
3 *
4 * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
5 *
6 */
7
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.
11 *
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:
17 *
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!
21 */
22
23#include <linux/delay.h>
24#include <linux/gpio.h>
25#include <linux/interrupt.h>
26#include <linux/pm.h>
27#include <linux/platform_device.h>
28#include <linux/resource.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090029#include <linux/slab.h>
Manuel Lauss66213b32009-10-04 14:55:27 +020030#include <linux/spinlock.h>
31
Manuel Lauss66213b32009-10-04 14:55:27 +020032#include <pcmcia/ss.h>
33
34#include <asm/mach-au1x00/au1000.h>
35#include <asm/mach-db1x00/bcsr.h>
36
37#define MEM_MAP_SIZE 0x400000
38#define IO_MAP_SIZE 0x1000
39
40struct db1x_pcmcia_sock {
41 struct pcmcia_socket socket;
42 int nr; /* socket number */
43 void *virt_io;
44
Manuel Lauss11b897c2010-02-24 17:40:21 +010045 phys_addr_t phys_io;
46 phys_addr_t phys_attr;
47 phys_addr_t phys_mem;
Manuel Lauss66213b32009-10-04 14:55:27 +020048
49 /* previous flags for set_socket() */
50 unsigned int old_flags;
51
52 /* interrupt sources: linux irq numbers! */
53 int insert_irq; /* default carddetect irq */
54 int stschg_irq; /* card-status-change irq */
55 int card_irq; /* card irq */
56 int eject_irq; /* db1200/pb1200 have these */
57
58#define BOARD_TYPE_DEFAULT 0 /* most boards */
59#define BOARD_TYPE_DB1200 1 /* IRQs aren't gpios */
60#define BOARD_TYPE_PB1100 2 /* VS bits slightly different */
61 int board_type;
62};
63
64#define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)
65
66/* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
67static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
68{
69 unsigned short sigstat;
70
71 sigstat = bcsr_read(BCSR_SIGSTAT);
72 return sigstat & 1 << (8 + 2 * sock->nr);
73}
74
75/* carddetect gpio: low-active */
76static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
77{
78 return !gpio_get_value(irq_to_gpio(sock->insert_irq));
79}
80
81static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
82{
83 switch (sock->board_type) {
84 case BOARD_TYPE_DB1200:
85 return db1200_card_inserted(sock);
86 default:
87 return db1000_card_inserted(sock);
88 }
89}
90
91/* STSCHG tends to bounce heavily when cards are inserted/ejected.
92 * To avoid this, the interrupt is normally disabled and only enabled
93 * after reset to a card has been de-asserted.
94 */
95static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
96{
97 if (sock->stschg_irq != -1) {
98 if (en)
99 enable_irq(sock->stschg_irq);
100 else
101 disable_irq(sock->stschg_irq);
102 }
103}
104
105static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
106{
107 struct db1x_pcmcia_sock *sock = data;
108
109 pcmcia_parse_events(&sock->socket, SS_DETECT);
110
111 return IRQ_HANDLED;
112}
113
114static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
115{
116 struct db1x_pcmcia_sock *sock = data;
117
118 pcmcia_parse_events(&sock->socket, SS_STSCHG);
119
120 return IRQ_HANDLED;
121}
122
123static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
124{
125 struct db1x_pcmcia_sock *sock = data;
126
127 /* Db/Pb1200 have separate per-socket insertion and ejection
128 * interrupts which stay asserted as long as the card is
129 * inserted/missing. The one which caused us to be called
130 * needs to be disabled and the other one enabled.
131 */
132 if (irq == sock->insert_irq) {
133 disable_irq_nosync(sock->insert_irq);
134 enable_irq(sock->eject_irq);
135 } else {
136 disable_irq_nosync(sock->eject_irq);
137 enable_irq(sock->insert_irq);
138 }
139
140 pcmcia_parse_events(&sock->socket, SS_DETECT);
141
142 return IRQ_HANDLED;
143}
144
145static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
146{
147 int ret;
Manuel Lauss66213b32009-10-04 14:55:27 +0200148
149 if (sock->stschg_irq != -1) {
150 ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
151 0, "pcmcia_stschg", sock);
152 if (ret)
153 return ret;
154 }
155
156 /* Db/Pb1200 have separate per-socket insertion and ejection
157 * interrupts, which should show edge behaviour but don't.
158 * So interrupts are disabled until both insertion and
159 * ejection handler have been registered and the currently
160 * active one disabled.
161 */
162 if (sock->board_type == BOARD_TYPE_DB1200) {
Manuel Lauss66213b32009-10-04 14:55:27 +0200163 ret = request_irq(sock->insert_irq, db1200_pcmcia_cdirq,
164 IRQF_DISABLED, "pcmcia_insert", sock);
Manuel Lauss0000a532010-04-21 17:41:59 +0200165 if (ret)
Manuel Lauss66213b32009-10-04 14:55:27 +0200166 goto out1;
167
168 ret = request_irq(sock->eject_irq, db1200_pcmcia_cdirq,
169 IRQF_DISABLED, "pcmcia_eject", sock);
170 if (ret) {
171 free_irq(sock->insert_irq, sock);
Manuel Lauss66213b32009-10-04 14:55:27 +0200172 goto out1;
173 }
174
Manuel Lauss0000a532010-04-21 17:41:59 +0200175 /* enable the currently silent one */
Manuel Lauss66213b32009-10-04 14:55:27 +0200176 if (db1200_card_inserted(sock))
Manuel Lauss0000a532010-04-21 17:41:59 +0200177 enable_irq(sock->eject_irq);
Manuel Lauss66213b32009-10-04 14:55:27 +0200178 else
Manuel Lauss0000a532010-04-21 17:41:59 +0200179 enable_irq(sock->insert_irq);
Manuel Lauss66213b32009-10-04 14:55:27 +0200180 } else {
181 /* all other (older) Db1x00 boards use a GPIO to show
182 * card detection status: use both-edge triggers.
183 */
184 set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
185 ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
186 0, "pcmcia_carddetect", sock);
187
188 if (ret)
189 goto out1;
190 }
191
192 return 0; /* all done */
193
194out1:
195 if (sock->stschg_irq != -1)
196 free_irq(sock->stschg_irq, sock);
197
198 return ret;
199}
200
201static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
202{
203 if (sock->stschg_irq != -1)
204 free_irq(sock->stschg_irq, sock);
205
206 free_irq(sock->insert_irq, sock);
207 if (sock->eject_irq != -1)
208 free_irq(sock->eject_irq, sock);
209}
210
211/*
212 * configure a PCMCIA socket on the Db1x00 series of boards (and
213 * compatibles).
214 *
215 * 2 external registers are involved:
216 * pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
217 * pcmcia_control(offset 0x10):
218 * bits[0:1] set vcc for card
219 * bits[2:3] set vpp for card
220 * bit 4: enable data buffers
221 * bit 7: reset# for card
222 * add 8 for second socket.
223 */
224static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
225 struct socket_state_t *state)
226{
227 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
228 unsigned short cr_clr, cr_set;
229 unsigned int changed;
230 int v, p, ret;
231
232 /* card voltage setup */
233 cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
234 cr_set = 0;
235 v = p = ret = 0;
236
237 switch (state->Vcc) {
238 case 50:
239 ++v;
240 case 33:
241 ++v;
242 case 0:
243 break;
244 default:
245 printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
246 sock->nr, state->Vcc);
247 }
248
249 switch (state->Vpp) {
250 case 12:
251 ++p;
252 case 33:
253 case 50:
254 ++p;
255 case 0:
256 break;
257 default:
258 printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
259 sock->nr, state->Vpp);
260 }
261
262 /* sanity check: Vpp must be 0, 12, or Vcc */
263 if (((state->Vcc == 33) && (state->Vpp == 50)) ||
264 ((state->Vcc == 50) && (state->Vpp == 33))) {
265 printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
266 sock->nr, state->Vcc, state->Vpp);
267 v = p = 0;
268 ret = -EINVAL;
269 }
270
271 /* create new voltage code */
272 cr_set |= ((v << 2) | p) << (sock->nr * 8);
273
274 changed = state->flags ^ sock->old_flags;
275
276 if (changed & SS_RESET) {
277 if (state->flags & SS_RESET) {
278 set_stschg(sock, 0);
279 /* assert reset, disable io buffers */
280 cr_clr |= (1 << (7 + (sock->nr * 8)));
281 cr_clr |= (1 << (4 + (sock->nr * 8)));
282 } else {
283 /* de-assert reset, enable io buffers */
284 cr_set |= 1 << (7 + (sock->nr * 8));
285 cr_set |= 1 << (4 + (sock->nr * 8));
286 }
287 }
288
289 /* update PCMCIA configuration */
290 bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);
291
292 sock->old_flags = state->flags;
293
294 /* reset was taken away: give card time to initialize properly */
295 if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
296 msleep(500);
297 set_stschg(sock, 1);
298 }
299
300 return ret;
301}
302
303/* VCC bits at [3:2]/[11:10] */
304#define GET_VCC(cr, socknr) \
305 ((((cr) >> 2) >> ((socknr) * 8)) & 3)
306
307/* VS bits at [0:1]/[3:2] */
308#define GET_VS(sr, socknr) \
309 (((sr) >> (2 * (socknr))) & 3)
310
311/* reset bits at [7]/[15] */
312#define GET_RESET(cr, socknr) \
313 ((cr) & (1 << (7 + (8 * (socknr)))))
314
315static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
316 unsigned int *value)
317{
318 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
319 unsigned short cr, sr;
320 unsigned int status;
321
322 status = db1x_card_inserted(sock) ? SS_DETECT : 0;
323
324 cr = bcsr_read(BCSR_PCMCIA);
325 sr = bcsr_read(BCSR_STATUS);
326
327 /* PB1100/PB1500: voltage key bits are at [5:4] */
328 if (sock->board_type == BOARD_TYPE_PB1100)
329 sr >>= 4;
330
331 /* determine card type */
332 switch (GET_VS(sr, sock->nr)) {
333 case 0:
334 case 2:
335 status |= SS_3VCARD; /* 3V card */
336 case 3:
337 break; /* 5V card: set nothing */
338 default:
339 status |= SS_XVCARD; /* treated as unsupported in core */
340 }
341
342 /* if Vcc is not zero, we have applied power to a card */
343 status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;
344
345 /* reset de-asserted? then we're ready */
346 status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;
347
348 *value = status;
349
350 return 0;
351}
352
353static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
354{
355 return 0;
356}
357
358static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
359{
360 return 0;
361}
362
363static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
364 struct pccard_io_map *map)
365{
366 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
367
368 map->start = (u32)sock->virt_io;
369 map->stop = map->start + IO_MAP_SIZE;
370
371 return 0;
372}
373
374static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
375 struct pccard_mem_map *map)
376{
377 struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
378
379 if (map->flags & MAP_ATTRIB)
380 map->static_start = sock->phys_attr + map->card_start;
381 else
382 map->static_start = sock->phys_mem + map->card_start;
383
384 return 0;
385}
386
387static struct pccard_operations db1x_pcmcia_operations = {
388 .init = db1x_pcmcia_sock_init,
389 .suspend = db1x_pcmcia_sock_suspend,
390 .get_status = db1x_pcmcia_get_status,
391 .set_socket = db1x_pcmcia_configure,
392 .set_io_map = au1x00_pcmcia_set_io_map,
393 .set_mem_map = au1x00_pcmcia_set_mem_map,
394};
395
396static int __devinit db1x_pcmcia_socket_probe(struct platform_device *pdev)
397{
398 struct db1x_pcmcia_sock *sock;
399 struct resource *r;
Manuel Lauss66213b32009-10-04 14:55:27 +0200400 int ret, bid;
401
402 sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
403 if (!sock)
404 return -ENOMEM;
405
406 sock->nr = pdev->id;
407
408 bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
409 switch (bid) {
410 case BCSR_WHOAMI_PB1500:
411 case BCSR_WHOAMI_PB1500R2:
412 case BCSR_WHOAMI_PB1100:
413 sock->board_type = BOARD_TYPE_PB1100;
414 break;
415 case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
416 sock->board_type = BOARD_TYPE_DEFAULT;
417 break;
418 case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
419 sock->board_type = BOARD_TYPE_DB1200;
420 break;
421 default:
422 printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
423 ret = -ENODEV;
424 goto out0;
425 };
426
427 /*
428 * gather resources necessary and optional nice-to-haves to
429 * operate a socket:
430 * This includes IRQs for Carddetection/ejection, the card
431 * itself and optional status change detection.
432 * Also, the memory areas covered by a socket. For these
Manuel Laussf25e1882010-03-01 21:40:56 +0100433 * we require the real 36bit addresses (see the au1000.h
Manuel Lauss66213b32009-10-04 14:55:27 +0200434 * header for more information).
435 */
436
437 /* card: irq assigned to the card itself. */
438 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
439 sock->card_irq = r ? r->start : 0;
440
441 /* insert: irq which triggers on card insertion/ejection */
442 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
443 sock->insert_irq = r ? r->start : -1;
444
445 /* stschg: irq which trigger on card status change (optional) */
446 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
447 sock->stschg_irq = r ? r->start : -1;
448
449 /* eject: irq which triggers on ejection (DB1200/PB1200 only) */
450 r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
451 sock->eject_irq = r ? r->start : -1;
452
453 ret = -ENODEV;
454
Manuel Laussf25e1882010-03-01 21:40:56 +0100455 /* 36bit PCMCIA Attribute area address */
Manuel Lauss11b897c2010-02-24 17:40:21 +0100456 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-attr");
Manuel Lauss66213b32009-10-04 14:55:27 +0200457 if (!r) {
458 printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
459 sock->nr);
460 goto out0;
461 }
462 sock->phys_attr = r->start;
463
Manuel Laussf25e1882010-03-01 21:40:56 +0100464 /* 36bit PCMCIA Memory area address */
Manuel Lauss11b897c2010-02-24 17:40:21 +0100465 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-mem");
Manuel Lauss66213b32009-10-04 14:55:27 +0200466 if (!r) {
467 printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
468 sock->nr);
469 goto out0;
470 }
471 sock->phys_mem = r->start;
472
Manuel Laussf25e1882010-03-01 21:40:56 +0100473 /* 36bit PCMCIA IO area address */
Manuel Lauss11b897c2010-02-24 17:40:21 +0100474 r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-io");
Manuel Lauss66213b32009-10-04 14:55:27 +0200475 if (!r) {
476 printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
477 sock->nr);
478 goto out0;
479 }
480 sock->phys_io = r->start;
481
Manuel Lauss66213b32009-10-04 14:55:27 +0200482 /*
483 * PCMCIA client drivers use the inb/outb macros to access
484 * the IO registers. Since mips_io_port_base is added
485 * to the access address of the mips implementation of
486 * inb/outb, we need to subtract it here because we want
487 * to access the I/O or MEM address directly, without
488 * going through this "mips_io_port_base" mechanism.
489 */
Manuel Lauss11b897c2010-02-24 17:40:21 +0100490 sock->virt_io = (void *)(ioremap(sock->phys_io, IO_MAP_SIZE) -
Manuel Lauss66213b32009-10-04 14:55:27 +0200491 mips_io_port_base);
492
493 if (!sock->virt_io) {
494 printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
495 sock->nr);
496 ret = -ENOMEM;
497 goto out0;
498 }
499
500 sock->socket.ops = &db1x_pcmcia_operations;
501 sock->socket.owner = THIS_MODULE;
502 sock->socket.pci_irq = sock->card_irq;
503 sock->socket.features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
504 sock->socket.map_size = MEM_MAP_SIZE;
505 sock->socket.io_offset = (unsigned long)sock->virt_io;
506 sock->socket.dev.parent = &pdev->dev;
507 sock->socket.resource_ops = &pccard_static_ops;
508
509 platform_set_drvdata(pdev, sock);
510
511 ret = db1x_pcmcia_setup_irqs(sock);
512 if (ret) {
513 printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
514 sock->nr);
515 goto out1;
516 }
517
518 set_stschg(sock, 0);
519
520 ret = pcmcia_register_socket(&sock->socket);
521 if (ret) {
522 printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
523 goto out2;
524 }
525
Manuel Lauss11b897c2010-02-24 17:40:21 +0100526 printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %09llx"
527 "(%p) %09llx %09llx card/insert/stschg/eject irqs @ %d "
Manuel Lauss66213b32009-10-04 14:55:27 +0200528 "%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
529 sock->phys_attr, sock->phys_mem, sock->card_irq,
530 sock->insert_irq, sock->stschg_irq, sock->eject_irq);
531
532 return 0;
533
534out2:
535 db1x_pcmcia_free_irqs(sock);
536out1:
537 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
538out0:
539 kfree(sock);
540 return ret;
541}
542
543static int __devexit db1x_pcmcia_socket_remove(struct platform_device *pdev)
544{
545 struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);
546
547 db1x_pcmcia_free_irqs(sock);
548 pcmcia_unregister_socket(&sock->socket);
549 iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
550 kfree(sock);
551
552 return 0;
553}
554
Manuel Lauss66213b32009-10-04 14:55:27 +0200555static struct platform_driver db1x_pcmcia_socket_driver = {
556 .driver = {
557 .name = "db1xxx_pcmcia",
558 .owner = THIS_MODULE,
Manuel Lauss66213b32009-10-04 14:55:27 +0200559 },
560 .probe = db1x_pcmcia_socket_probe,
561 .remove = __devexit_p(db1x_pcmcia_socket_remove),
562};
563
564int __init db1x_pcmcia_socket_load(void)
565{
566 return platform_driver_register(&db1x_pcmcia_socket_driver);
567}
568
569void __exit db1x_pcmcia_socket_unload(void)
570{
571 platform_driver_unregister(&db1x_pcmcia_socket_driver);
572}
573
574module_init(db1x_pcmcia_socket_load);
575module_exit(db1x_pcmcia_socket_unload);
576
577MODULE_LICENSE("GPL");
578MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
579MODULE_AUTHOR("Manuel Lauss");