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