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