Linux-2.6.12-rc2
[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 #include <asm/mach-db1x00/db1x00.h>
44
45 #include "au1000_generic.h"
46
47 #if 0
48 #define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args)
49 #else
50 #define debug(x,args...)
51 #endif
52
53 static BCSR * const bcsr = (BCSR *)BCSR_KSEG1_ADDR;
54
55 struct au1000_pcmcia_socket au1000_pcmcia_socket[PCMCIA_NUM_SOCKS];
56 extern int au1x00_pcmcia_socket_probe(struct device *, struct pcmcia_low_level *, int, int);
57
58 static int db1x00_pcmcia_hw_init(struct au1000_pcmcia_socket *skt)
59 {
60 #ifdef CONFIG_MIPS_DB1550
61         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_3;
62 #else
63         skt->irq = skt->nr ? AU1000_GPIO_5 : AU1000_GPIO_2;
64 #endif
65         return 0;
66 }
67
68 static void db1x00_pcmcia_shutdown(struct au1000_pcmcia_socket *skt)
69 {
70         bcsr->pcmcia = 0; /* turn off power */
71         au_sync_delay(2);
72 }
73
74 static void
75 db1x00_pcmcia_socket_state(struct au1000_pcmcia_socket *skt, struct pcmcia_state *state)
76 {
77         u32 inserted;
78         unsigned char vs;
79
80         state->ready = 0;
81         state->vs_Xv = 0;
82         state->vs_3v = 0;
83         state->detect = 0;
84
85         switch (skt->nr) {
86         case 0:
87                 vs = bcsr->status & 0x3;
88                 inserted = !(bcsr->status & (1<<4));
89                 break;
90         case 1:
91                 vs = (bcsr->status & 0xC)>>2;
92                 inserted = !(bcsr->status & (1<<5));
93                 break;
94         default:/* should never happen */
95                 return;
96         }
97
98         if (inserted)
99                 debug("db1x00 socket %d: inserted %d, vs %d pcmcia %x\n",
100                                 skt->nr, inserted, vs, bcsr->pcmcia);
101
102         if (inserted) {
103                 switch (vs) {
104                         case 0:
105                         case 2:
106                                 state->vs_3v=1;
107                                 break;
108                         case 3: /* 5V */
109                                 break;
110                         default:
111                                 /* return without setting 'detect' */
112                                 printk(KERN_ERR "db1x00 bad VS (%d)\n",
113                                                 vs);
114                 }
115                 state->detect = 1;
116                 state->ready = 1;
117         }
118         else {
119                 /* if the card was previously inserted and then ejected,
120                  * we should turn off power to it
121                  */
122                 if ((skt->nr == 0) && (bcsr->pcmcia & BCSR_PCMCIA_PC0RST)) {
123                         bcsr->pcmcia &= ~(BCSR_PCMCIA_PC0RST |
124                                         BCSR_PCMCIA_PC0DRVEN |
125                                         BCSR_PCMCIA_PC0VPP |
126                                         BCSR_PCMCIA_PC0VCC);
127                         au_sync_delay(10);
128                 }
129                 else if ((skt->nr == 1) && bcsr->pcmcia & BCSR_PCMCIA_PC1RST) {
130                         bcsr->pcmcia &= ~(BCSR_PCMCIA_PC1RST |
131                                         BCSR_PCMCIA_PC1DRVEN |
132                                         BCSR_PCMCIA_PC1VPP |
133                                         BCSR_PCMCIA_PC1VCC);
134                         au_sync_delay(10);
135                 }
136         }
137
138         state->bvd1=1;
139         state->bvd2=1;
140         state->wrprot=0;
141 }
142
143 static int
144 db1x00_pcmcia_configure_socket(struct au1000_pcmcia_socket *skt, struct socket_state_t *state)
145 {
146         u16 pwr;
147         int sock = skt->nr;
148
149         debug("config_skt %d Vcc %dV Vpp %dV, reset %d\n",
150                         sock, state->Vcc, state->Vpp,
151                         state->flags & SS_RESET);
152
153         /* pcmcia reg was set to zero at init time. Be careful when
154          * initializing a socket not to wipe out the settings of the
155          * other socket.
156          */
157         pwr = bcsr->pcmcia;
158         pwr &= ~(0xf << sock*8); /* clear voltage settings */
159
160         state->Vpp = 0;
161         switch(state->Vcc){
162                 case 0:  /* Vcc 0 */
163                         pwr |= SET_VCC_VPP(0,0,sock);
164                         break;
165                 case 50: /* Vcc 5V */
166                         switch(state->Vpp) {
167                                 case 0:
168                                         pwr |= SET_VCC_VPP(2,0,sock);
169                                         break;
170                                 case 50:
171                                         pwr |= SET_VCC_VPP(2,1,sock);
172                                         break;
173                                 case 12:
174                                         pwr |= SET_VCC_VPP(2,2,sock);
175                                         break;
176                                 case 33:
177                                 default:
178                                         pwr |= SET_VCC_VPP(0,0,sock);
179                                         printk("%s: bad Vcc/Vpp (%d:%d)\n",
180                                                         __FUNCTION__,
181                                                         state->Vcc,
182                                                         state->Vpp);
183                                         break;
184                         }
185                         break;
186                 case 33: /* Vcc 3.3V */
187                         switch(state->Vpp) {
188                                 case 0:
189                                         pwr |= SET_VCC_VPP(1,0,sock);
190                                         break;
191                                 case 12:
192                                         pwr |= SET_VCC_VPP(1,2,sock);
193                                         break;
194                                 case 33:
195                                         pwr |= SET_VCC_VPP(1,1,sock);
196                                         break;
197                                 case 50:
198                                 default:
199                                         pwr |= SET_VCC_VPP(0,0,sock);
200                                         printk("%s: bad Vcc/Vpp (%d:%d)\n",
201                                                         __FUNCTION__,
202                                                         state->Vcc,
203                                                         state->Vpp);
204                                         break;
205                         }
206                         break;
207                 default: /* what's this ? */
208                         pwr |= SET_VCC_VPP(0,0,sock);
209                         printk(KERN_ERR "%s: bad Vcc %d\n",
210                                         __FUNCTION__, state->Vcc);
211                         break;
212         }
213
214         bcsr->pcmcia = pwr;
215         au_sync_delay(300);
216
217         if (sock == 0) {
218                 if (!(state->flags & SS_RESET)) {
219                         pwr |= BCSR_PCMCIA_PC0DRVEN;
220                         bcsr->pcmcia = pwr;
221                         au_sync_delay(300);
222                         pwr |= BCSR_PCMCIA_PC0RST;
223                         bcsr->pcmcia = pwr;
224                         au_sync_delay(100);
225                 }
226                 else {
227                         pwr &= ~(BCSR_PCMCIA_PC0RST | BCSR_PCMCIA_PC0DRVEN);
228                         bcsr->pcmcia = pwr;
229                         au_sync_delay(100);
230                 }
231         }
232         else {
233                 if (!(state->flags & SS_RESET)) {
234                         pwr |= BCSR_PCMCIA_PC1DRVEN;
235                         bcsr->pcmcia = pwr;
236                         au_sync_delay(300);
237                         pwr |= BCSR_PCMCIA_PC1RST;
238                         bcsr->pcmcia = pwr;
239                         au_sync_delay(100);
240                 }
241                 else {
242                         pwr &= ~(BCSR_PCMCIA_PC1RST | BCSR_PCMCIA_PC1DRVEN);
243                         bcsr->pcmcia = pwr;
244                         au_sync_delay(100);
245                 }
246         }
247         return 0;
248 }
249
250 /*
251  * Enable card status IRQs on (re-)initialisation.  This can
252  * be called at initialisation, power management event, or
253  * pcmcia event.
254  */
255 void db1x00_socket_init(struct au1000_pcmcia_socket *skt)
256 {
257         /* nothing to do for now */
258 }
259
260 /*
261  * Disable card status IRQs and PCMCIA bus on suspend.
262  */
263 void db1x00_socket_suspend(struct au1000_pcmcia_socket *skt)
264 {
265         /* nothing to do for now */
266 }
267
268 struct pcmcia_low_level db1x00_pcmcia_ops = {
269         .owner                  = THIS_MODULE,
270
271         .hw_init                = db1x00_pcmcia_hw_init,
272         .hw_shutdown            = db1x00_pcmcia_shutdown,
273
274         .socket_state           = db1x00_pcmcia_socket_state,
275         .configure_socket       = db1x00_pcmcia_configure_socket,
276
277         .socket_init            = db1x00_socket_init,
278         .socket_suspend         = db1x00_socket_suspend
279 };
280
281 int __init au1x_board_init(struct device *dev)
282 {
283         int ret = -ENODEV;
284         bcsr->pcmcia = 0; /* turn off power, if it's not already off */
285         au_sync_delay(2);
286         ret = au1x00_pcmcia_socket_probe(dev, &db1x00_pcmcia_ops, 0, 2);
287         return ret;
288 }