xref: /netbsd-src/sys/arch/hpcarm/dev/wzero3_mci.c (revision 2388feef6162e5f55bc0fbaaa9d32d8dfc8354a3)
1 /*	$NetBSD: wzero3_mci.c,v 1.4 2012/01/21 19:44:29 nonaka Exp $	*/
2 
3 /*-
4  * Copyright (C) 2009 NONAKA Kimihiro <nonaka@netbsd.org>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: wzero3_mci.c,v 1.4 2012/01/21 19:44:29 nonaka Exp $");
30 
31 #include <sys/param.h>
32 #include <sys/device.h>
33 #include <sys/systm.h>
34 #include <sys/pmf.h>
35 #include <sys/bus.h>
36 
37 #include <machine/bootinfo.h>
38 #include <machine/platid.h>
39 #include <machine/platid_mask.h>
40 
41 #include <arm/xscale/pxa2x0cpu.h>
42 #include <arm/xscale/pxa2x0reg.h>
43 #include <arm/xscale/pxa2x0var.h>
44 #include <arm/xscale/pxa2x0_gpio.h>
45 #include <arm/xscale/pxa2x0_mci.h>
46 
47 #include <dev/sdmmc/sdmmcreg.h>
48 
49 #include <hpcarm/dev/wzero3_reg.h>
50 
51 #if defined(PXAMCI_DEBUG)
52 #define	DPRINTF(s)	do { printf s; } while (0)
53 #else
54 #define	DPRINTF(s)	do {} while (0)
55 #endif
56 
57 struct wzero3mci_softc {
58 	struct pxamci_softc sc;
59 
60 	void *sc_detect_ih;
61 	int sc_detect_pin;
62 	int sc_power_pin;
63 };
64 
65 static int pxamci_match(device_t, cfdata_t, void *);
66 static void pxamci_attach(device_t, device_t, void *);
67 
68 CFATTACH_DECL_NEW(wzero3mci, sizeof(struct wzero3mci_softc),
69     pxamci_match, pxamci_attach, NULL, NULL);
70 
71 static int wzero3mci_intr(void *arg);
72 
73 static uint32_t	wzero3mci_get_ocr(void *);
74 static int wzero3mci_set_power(void *, uint32_t);
75 static int wzero3mci_card_detect(void *);
76 static int wzero3mci_write_protect(void *);
77 
78 struct wzero3mci_model {
79 	platid_mask_t *platid;
80 	int detect_pin;	/* card detect pin# */
81 	int power_pin;	/* card power pin # */
82 } wzero3mci_table[] = {
83 	/* WS003SH */
84 	{
85 		&platid_mask_MACH_SHARP_WZERO3_WS003SH,
86 		GPIO_WS003SH_SD_DETECT,
87 		GPIO_WS003SH_SD_POWER,
88 	},
89 	/* WS004SH */
90 	{
91 		&platid_mask_MACH_SHARP_WZERO3_WS004SH,
92 		GPIO_WS003SH_SD_DETECT,
93 		GPIO_WS003SH_SD_POWER,
94 	},
95 	/* WS007SH */
96 	{
97 		&platid_mask_MACH_SHARP_WZERO3_WS007SH,
98 		GPIO_WS007SH_SD_DETECT,
99 		GPIO_WS007SH_SD_POWER,
100 	},
101 	/* WS011SH */
102 	{
103 		&platid_mask_MACH_SHARP_WZERO3_WS011SH,
104 		GPIO_WS011SH_SD_DETECT,
105 		GPIO_WS011SH_SD_POWER,
106 	},
107 	/* WS0020H */
108 	{
109 		&platid_mask_MACH_SHARP_WZERO3_WS020SH,
110 		GPIO_WS020SH_SD_DETECT,
111 		GPIO_WS020SH_SD_POWER,
112 	},
113 
114 	{
115 		NULL, -1, -1
116 	},
117 };
118 
119 
120 static const struct wzero3mci_model *
wzero3mci_lookup(void)121 wzero3mci_lookup(void)
122 {
123 	const struct wzero3mci_model *model;
124 
125 	for (model = wzero3mci_table; model->platid != NULL; model++) {
126 		if (platid_match(&platid, model->platid)) {
127 			return model;
128 		}
129 	}
130 	return NULL;
131 }
132 
133 static int
pxamci_match(device_t parent,cfdata_t cf,void * aux)134 pxamci_match(device_t parent, cfdata_t cf, void *aux)
135 {
136 
137 	if (strcmp(cf->cf_name, "pxamci") != 0)
138 		return 0;
139 	if (wzero3mci_lookup() == NULL)
140 		return 0;
141 	return 1;
142 }
143 
144 static void
pxamci_attach(device_t parent,device_t self,void * aux)145 pxamci_attach(device_t parent, device_t self, void *aux)
146 {
147 	struct wzero3mci_softc *sc = device_private(self);
148 	struct pxaip_attach_args *pxa = aux;
149 	const struct wzero3mci_model *model;
150 
151 	sc->sc.sc_dev = self;
152 
153 	model = wzero3mci_lookup();
154 	if (model == NULL) {
155 		aprint_error(": Unknown model.");
156 		return;
157 	}
158 
159 	sc->sc_detect_pin = model->detect_pin;
160 	sc->sc_power_pin = model->power_pin;
161 
162 	/* Establish SD detect interrupt */
163 	if (sc->sc_detect_pin >= 0) {
164 		pxa2x0_gpio_set_function(sc->sc_detect_pin, GPIO_IN);
165 		sc->sc_detect_ih = pxa2x0_gpio_intr_establish(sc->sc_detect_pin,
166 		    IST_EDGE_BOTH, IPL_BIO, wzero3mci_intr, sc);
167 		if (sc->sc_detect_ih == NULL) {
168 			aprint_error_dev(self,
169 			    "unable to establish card detect interrupt\n");
170 			return;
171 		}
172 	}
173 
174 	sc->sc.sc_tag.cookie = sc;
175 	sc->sc.sc_tag.get_ocr = wzero3mci_get_ocr;
176 	sc->sc.sc_tag.set_power = wzero3mci_set_power;
177 	sc->sc.sc_tag.card_detect = wzero3mci_card_detect;
178 	sc->sc.sc_tag.write_protect = wzero3mci_write_protect;
179 	sc->sc.sc_caps = PMC_CAPS_4BIT;
180 
181 	if (pxamci_attach_sub(self, pxa)) {
182 		aprint_error_dev(self, "unable to attach MMC controller\n");
183 		goto free_intr;
184 	}
185 
186 	if (!pmf_device_register(self, NULL, NULL)) {
187 		aprint_error_dev(self, "couldn't establish power handler\n");
188 	}
189 
190 	return;
191 
192 free_intr:
193 	pxa2x0_gpio_intr_disestablish(sc->sc_detect_ih);
194 	sc->sc_detect_ih = NULL;
195 }
196 
197 static int
wzero3mci_intr(void * arg)198 wzero3mci_intr(void *arg)
199 {
200 	struct wzero3mci_softc *sc = (struct wzero3mci_softc *)arg;
201 
202 	pxa2x0_gpio_clear_intr(sc->sc_detect_pin);
203 
204 	pxamci_card_detect_event(&sc->sc);
205 
206 	return 1;
207 }
208 
209 /*ARGSUSED*/
210 static uint32_t
wzero3mci_get_ocr(void * arg)211 wzero3mci_get_ocr(void *arg)
212 {
213 
214 	return MMC_OCR_3_2V_3_3V|MMC_OCR_3_3V_3_4V;
215 }
216 
217 static int
wzero3mci_set_power(void * arg,uint32_t ocr)218 wzero3mci_set_power(void *arg, uint32_t ocr)
219 {
220 	struct wzero3mci_softc *sc = (struct wzero3mci_softc *)arg;
221 	int error = 0;
222 
223 	if (sc->sc_power_pin >= 0) {
224 		if (ISSET(ocr, MMC_OCR_3_2V_3_3V|MMC_OCR_3_3V_3_4V)) {
225 			/* power on */
226 			pxa2x0_gpio_set_bit(sc->sc_power_pin);
227 		} else if (ocr == 0) {
228 			/* power off */
229 			pxa2x0_gpio_clear_bit(sc->sc_power_pin);
230 		} else {
231 			aprint_error_dev(sc->sc.sc_dev,
232 			    "unsupported OCR (%#x)\n", ocr);
233 			error = EINVAL;
234 		}
235 	}
236 	return error;
237 }
238 
239 /*
240  * Return non-zero if the card is currently inserted.
241  */
242 static int
wzero3mci_card_detect(void * arg)243 wzero3mci_card_detect(void *arg)
244 {
245 	struct wzero3mci_softc *sc = (struct wzero3mci_softc *)arg;
246 
247 	if (sc->sc_detect_pin >= 0) {
248 		if (pxa2x0_gpio_get_bit(sc->sc_detect_pin))
249 			return 0;
250 	}
251 	return 1;
252 }
253 
254 /*
255  * Return non-zero if the card is currently write-protected.
256  */
257 /*ARGSUSED*/
258 static int
wzero3mci_write_protect(void * arg)259 wzero3mci_write_protect(void *arg)
260 {
261 
262 	return 0;
263 }
264