Updated pcmcia driver with pb1200 and db1200 support.
[linux-3.10.git] / drivers / pcmcia / au1000_db1x00.c
1 /*
2  *
3  * Alchemy Semi Db1x00 boards specific pcmcia routines.
4  *
5  * Copyright 2002 MontaVista Software Inc.
6  * Author: MontaVista Software, Inc.
7  *              ppopov@mvista.com or source@mvista.com
8  *
9  * Copyright 2004 Pete Popov, updated the driver to 2.6.
10  * Followed the sa11xx API and largely copied many of the hardware
11  * independent functions.
12  *
13  * ########################################################################
14  *
15  *  This program is free software; you can distribute it and/or modify it
16  *  under the terms of the GNU General Public License (Version 2) as
17  *  published by the Free Software Foundation.
18  *
19  *  This program is distributed in the hope it will be useful, but WITHOUT
20  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
22  *  for more details.
23  *
24  *  You should have received a copy of the GNU General Public License along
25  *  with this program; if not, write to the Free Software Foundation, Inc.,
26  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
27  *
28  * ########################################################################
29  *
30  *
31  */
32
33 #include <linux/module.h>
34 #include <linux/kernel.h>
35 #include <linux/errno.h>
36 #include <linux/interrupt.h>
37 #include <linux/device.h>
38 #include <linux/init.h>
39
40 #include <asm/irq.h>
41 #include <asm/signal.h>
42 #include <asm/mach-au1x00/au1000.h>
43
44 #if defined(CONFIG_MIPS_DB1200)
45         #include <db1200.h>
46 #elif defined(CONFIG_MIPS_PB1200)
47         #include <pb1200.h>
48 #else
49         #include <asm/mach-db1x00/db1x00.h>
50         static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
51 #endif
52
53 #include "au1000_generic.h"
54
55 #if 0
56 #define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
57 #else
58 #define debug(x,args...)
59 #endif
60
61
62 struct au1000_pcmcia_socket au1000_pcmcia_socket[PCMCIA_NUM_SOCKS];
63 extern int au1x00_pcmcia_socket_probe(struct device *, struct pcmcia_low_level *, int, int);
64
65 static int db1x00_pcmcia_hw_init(struct au1000_pcmcia_socket *skt)
66 {
67 #ifdef CONFIG_MIPS_DB1550
68         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_3;
69 #elif defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
70         skt->irq = skt->nr ? BOARD_PC1_INT : BOARD_PC0_INT;
71 #else
72         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_2;
73 #endif
74         return 0;
75 }
76
77 static void db1x00_pcmcia_shutdown(struct au1000_pcmcia_socket *skt)
78 {
79         bcsr->pcmcia = 0; /* turn off power */
80         au_sync_delay(2);
81 }
82
83 static void
84 db1x00_pcmcia_socket_state(struct au1000_pcmcia_socket *skt, struct pcmcia_state *state)
85 {
86         u32 inserted;
87         unsigned char vs;
88
89         state->ready = 0;
90         state->vs_Xv = 0;
91         state->vs_3v = 0;
92         state->detect = 0;
93
94         switch (skt->nr) {
95         case 0:
96                 vs = bcsr->status & 0x3;
97 #if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
98                 inserted = BOARD_CARD_INSERTED(0);
99 #else
100                 inserted = !(bcsr->status & (1<<4));
101 #endif
102                 break;
103         case 1:
104                 vs = (bcsr->status & 0xC)>>2;
105 #if defined(CONFIG_MIPS_DB1200) || defined(CONFIG_MIPS_PB1200)
106                 inserted = BOARD_CARD_INSERTED(1);
107 #else
108                 inserted = !(bcsr->status & (1<<5));
109 #endif
110                 break;
111         default:/* should never happen */
112                 return;
113         }
114
115         if (inserted)
116                 debug("db1x00 socket %d: inserted %d, vs %d pcmcia %x\n",
117                                 skt->nr, inserted, vs, bcsr->pcmcia);
118
119         if (inserted) {
120                 switch (vs) {
121                         case 0:
122                         case 2:
123                                 state->vs_3v=1;
124                                 break;
125                         case 3: /* 5V */
126                                 break;
127                         default:
128                                 /* return without setting 'detect' */
129                                 printk(KERN_ERR "db1x00 bad VS (%d)\n",
130                                                 vs);
131                 }
132                 state->detect = 1;
133                 state->ready = 1;
134         }
135         else {
136                 /* if the card was previously inserted and then ejected,
137                  * we should turn off power to it
138                  */
139                 if ((skt->nr == 0) && (bcsr->pcmcia & BCSR_PCMCIA_PC0RST)) {
140                         bcsr->pcmcia &= ~(BCSR_PCMCIA_PC0RST |
141                                         BCSR_PCMCIA_PC0DRVEN |
142                                         BCSR_PCMCIA_PC0VPP |
143                                         BCSR_PCMCIA_PC0VCC);
144                         au_sync_delay(10);
145                 }
146                 else if ((skt->nr == 1) && bcsr->pcmcia & BCSR_PCMCIA_PC1RST) {
147                         bcsr->pcmcia &= ~(BCSR_PCMCIA_PC1RST |
148                                         BCSR_PCMCIA_PC1DRVEN |
149                                         BCSR_PCMCIA_PC1VPP |
150                                         BCSR_PCMCIA_PC1VCC);
151                         au_sync_delay(10);
152                 }
153         }
154
155         state->bvd1=1;
156         state->bvd2=1;
157         state->wrprot=0;
158 }
159
160 static int
161 db1x00_pcmcia_configure_socket(struct au1000_pcmcia_socket *skt, struct socket_state_t *state)
162 {
163         u16 pwr;
164         int sock = skt->nr;
165
166         debug("config_skt %d Vcc %dV Vpp %dV, reset %d\n",
167                         sock, state->Vcc, state->Vpp,
168                         state->flags & SS_RESET);
169
170         /* pcmcia reg was set to zero at init time. Be careful when
171          * initializing a socket not to wipe out the settings of the
172          * other socket.
173          */
174         pwr = bcsr->pcmcia;
175         pwr &= ~(0xf << sock*8); /* clear voltage settings */
176
177         state->Vpp = 0;
178         switch(state->Vcc){
179                 case 0:  /* Vcc 0 */
180                         pwr |= SET_VCC_VPP(0,0,sock);
181                         break;
182                 case 50: /* Vcc 5V */
183                         switch(state->Vpp) {
184                                 case 0:
185                                         pwr |= SET_VCC_VPP(2,0,sock);
186                                         break;
187                                 case 50:
188                                         pwr |= SET_VCC_VPP(2,1,sock);
189                                         break;
190                                 case 12:
191                                         pwr |= SET_VCC_VPP(2,2,sock);
192                                         break;
193                                 case 33:
194                                 default:
195                                         pwr |= SET_VCC_VPP(0,0,sock);
196                                         printk("%s: bad Vcc/Vpp (%d:%d)\n",
197                                                         __FUNCTION__,
198                                                         state->Vcc,
199                                                         state->Vpp);
200                                         break;
201                         }
202                         break;
203                 case 33: /* Vcc 3.3V */
204                         switch(state->Vpp) {
205                                 case 0:
206                                         pwr |= SET_VCC_VPP(1,0,sock);
207                                         break;
208                                 case 12:
209                                         pwr |= SET_VCC_VPP(1,2,sock);
210                                         break;
211                                 case 33:
212                                         pwr |= SET_VCC_VPP(1,1,sock);
213                                         break;
214                                 case 50:
215                                 default:
216                                         pwr |= SET_VCC_VPP(0,0,sock);
217                                         printk("%s: bad Vcc/Vpp (%d:%d)\n",
218                                                         __FUNCTION__,
219                                                         state->Vcc,
220                                                         state->Vpp);
221                                         break;
222                         }
223                         break;
224                 default: /* what's this ? */
225                         pwr |= SET_VCC_VPP(0,0,sock);
226                         printk(KERN_ERR "%s: bad Vcc %d\n",
227                                         __FUNCTION__, state->Vcc);
228                         break;
229         }
230
231         bcsr->pcmcia = pwr;
232         au_sync_delay(300);
233
234         if (sock == 0) {
235                 if (!(state->flags & SS_RESET)) {
236                         pwr |= BCSR_PCMCIA_PC0DRVEN;
237                         bcsr->pcmcia = pwr;
238                         au_sync_delay(300);
239                         pwr |= BCSR_PCMCIA_PC0RST;
240                         bcsr->pcmcia = pwr;
241                         au_sync_delay(100);
242                 }
243                 else {
244                         pwr &= ~(BCSR_PCMCIA_PC0RST | BCSR_PCMCIA_PC0DRVEN);
245                         bcsr->pcmcia = pwr;
246                         au_sync_delay(100);
247                 }
248         }
249         else {
250                 if (!(state->flags & SS_RESET)) {
251                         pwr |= BCSR_PCMCIA_PC1DRVEN;
252                         bcsr->pcmcia = pwr;
253                         au_sync_delay(300);
254                         pwr |= BCSR_PCMCIA_PC1RST;
255                         bcsr->pcmcia = pwr;
256                         au_sync_delay(100);
257                 }
258                 else {
259                         pwr &= ~(BCSR_PCMCIA_PC1RST | BCSR_PCMCIA_PC1DRVEN);
260                         bcsr->pcmcia = pwr;
261                         au_sync_delay(100);
262                 }
263         }
264         return 0;
265 }
266
267 /*
268  * Enable card status IRQs on (re-)initialisation.  This can
269  * be called at initialisation, power management event, or
270  * pcmcia event.
271  */
272 void db1x00_socket_init(struct au1000_pcmcia_socket *skt)
273 {
274         /* nothing to do for now */
275 }
276
277 /*
278  * Disable card status IRQs and PCMCIA bus on suspend.
279  */
280 void db1x00_socket_suspend(struct au1000_pcmcia_socket *skt)
281 {
282         /* nothing to do for now */
283 }
284
285 struct pcmcia_low_level db1x00_pcmcia_ops = {
286         .owner                  = THIS_MODULE,
287
288         .hw_init                = db1x00_pcmcia_hw_init,
289         .hw_shutdown            = db1x00_pcmcia_shutdown,
290
291         .socket_state           = db1x00_pcmcia_socket_state,
292         .configure_socket       = db1x00_pcmcia_configure_socket,
293
294         .socket_init            = db1x00_socket_init,
295         .socket_suspend         = db1x00_socket_suspend
296 };
297
298 int __init au1x_board_init(struct device *dev)
299 {
300         int ret = -ENODEV;
301         bcsr->pcmcia = 0; /* turn off power, if it's not already off */
302         au_sync_delay(2);
303         ret = au1x00_pcmcia_socket_probe(dev, &db1x00_pcmcia_ops, 0, 2);
304         return ret;
305 }