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