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