1 /* $OpenBSD: sdmmc_mem.c,v 1.14 2010/02/10 23:33:08 drahn Exp $ */
2
3 /*
4 * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 /* Routines for SD/MMC memory cards. */
20
21 #include <sys/param.h>
22 #include <sys/device.h>
23 #include <sys/kernel.h>
24 #include <sys/malloc.h>
25 #include <sys/systm.h>
26
27 #include <dev/sdmmc/sdmmcchip.h>
28 #include <dev/sdmmc/sdmmcreg.h>
29 #include <dev/sdmmc/sdmmcvar.h>
30
31 int sdmmc_decode_csd(struct sdmmc_softc *, sdmmc_response,
32 struct sdmmc_function *);
33 int sdmmc_decode_cid(struct sdmmc_softc *, sdmmc_response,
34 struct sdmmc_function *);
35 void sdmmc_print_cid(struct sdmmc_cid *);
36
37 int sdmmc_mem_send_op_cond(struct sdmmc_softc *, u_int32_t, u_int32_t *);
38 int sdmmc_mem_set_blocklen(struct sdmmc_softc *, struct sdmmc_function *);
39
40 #ifdef SDMMC_DEBUG
41 #define DPRINTF(s) printf s
42 #else
43 #define DPRINTF(s) /**/
44 #endif
45
46 /*
47 * Initialize SD/MMC memory cards and memory in SDIO "combo" cards.
48 */
49 int
sdmmc_mem_enable(struct sdmmc_softc * sc)50 sdmmc_mem_enable(struct sdmmc_softc *sc)
51 {
52 u_int32_t host_ocr;
53 u_int32_t card_ocr;
54
55 SDMMC_ASSERT_LOCKED(sc);
56
57 /* Set host mode to SD "combo" card or SD memory-only. */
58 SET(sc->sc_flags, SMF_SD_MODE|SMF_MEM_MODE);
59
60 /* Reset memory (*must* do that before CMD55 or CMD1). */
61 sdmmc_go_idle_state(sc);
62
63 /*
64 * Read the SD/MMC memory OCR value by issuing CMD55 followed
65 * by ACMD41 to read the OCR value from memory-only SD cards.
66 * MMC cards will not respond to CMD55 or ACMD41 and this is
67 * how we distinguish them from SD cards.
68 */
69 mmc_mode:
70 if (sdmmc_mem_send_op_cond(sc, 0, &card_ocr) != 0) {
71 if (ISSET(sc->sc_flags, SMF_SD_MODE) &&
72 !ISSET(sc->sc_flags, SMF_IO_MODE)) {
73 /* Not a SD card, switch to MMC mode. */
74 CLR(sc->sc_flags, SMF_SD_MODE);
75 goto mmc_mode;
76 }
77 if (!ISSET(sc->sc_flags, SMF_SD_MODE)) {
78 DPRINTF(("%s: can't read memory OCR\n",
79 SDMMCDEVNAME(sc)));
80 return 1;
81 } else {
82 /* Not a "combo" card. */
83 CLR(sc->sc_flags, SMF_MEM_MODE);
84 return 0;
85 }
86 }
87
88 /* Set the lowest voltage supported by the card and host. */
89 host_ocr = sdmmc_chip_host_ocr(sc->sct, sc->sch);
90 if (sdmmc_set_bus_power(sc, host_ocr, card_ocr) != 0) {
91 DPRINTF(("%s: can't supply voltage requested by card\n",
92 SDMMCDEVNAME(sc)));
93 return 1;
94 }
95
96 /* Tell the card(s) to enter the idle state (again). */
97 sdmmc_go_idle_state(sc);
98
99 host_ocr &= card_ocr; /* only allow the common voltages */
100
101 if (sdmmc_send_if_cond(sc, card_ocr) == 0)
102 host_ocr |= SD_OCR_SDHC_CAP;
103
104 /* Send the new OCR value until all cards are ready. */
105 if (sdmmc_mem_send_op_cond(sc, host_ocr, NULL) != 0) {
106 DPRINTF(("%s: can't send memory OCR\n", SDMMCDEVNAME(sc)));
107 return 1;
108 }
109 return 0;
110 }
111
112 /*
113 * Read the CSD and CID from all cards and assign each card a unique
114 * relative card address (RCA). CMD2 is ignored by SDIO-only cards.
115 */
116 void
sdmmc_mem_scan(struct sdmmc_softc * sc)117 sdmmc_mem_scan(struct sdmmc_softc *sc)
118 {
119 struct sdmmc_command cmd;
120 struct sdmmc_function *sf;
121 u_int16_t next_rca;
122 int error;
123 int i;
124
125 SDMMC_ASSERT_LOCKED(sc);
126
127 /*
128 * CMD2 is a broadcast command understood by SD cards and MMC
129 * cards. All cards begin to respond to the command, but back
130 * off if another card drives the CMD line to a different level.
131 * Only one card will get its entire response through. That
132 * card remains silent once it has been assigned a RCA.
133 */
134 for (i = 0; i < 100; i++) {
135 bzero(&cmd, sizeof cmd);
136 cmd.c_opcode = MMC_ALL_SEND_CID;
137 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R2;
138
139 error = sdmmc_mmc_command(sc, &cmd);
140 if (error == ETIMEDOUT) {
141 /* No more cards there. */
142 break;
143 } else if (error != 0) {
144 DPRINTF(("%s: can't read CID\n", SDMMCDEVNAME(sc)));
145 break;
146 }
147
148 /* In MMC mode, find the next available RCA. */
149 next_rca = 1;
150 if (!ISSET(sc->sc_flags, SMF_SD_MODE))
151 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list)
152 next_rca++;
153
154 /* Allocate a sdmmc_function structure. */
155 sf = sdmmc_function_alloc(sc);
156 sf->rca = next_rca;
157
158 /*
159 * Remember the CID returned in the CMD2 response for
160 * later decoding.
161 */
162 bcopy(cmd.c_resp, sf->raw_cid, sizeof sf->raw_cid);
163
164 /*
165 * Silence the card by assigning it a unique RCA, or
166 * querying it for its RCA in the case of SD.
167 */
168 if (sdmmc_set_relative_addr(sc, sf) != 0) {
169 printf("%s: can't set mem RCA\n", SDMMCDEVNAME(sc));
170 sdmmc_function_free(sf);
171 break;
172 }
173
174 #if 0
175 /* Verify that the RCA has been set by selecting the card. */
176 if (sdmmc_select_card(sc, sf) != 0) {
177 printf("%s: can't select mem RCA %d\n",
178 SDMMCDEVNAME(sc), sf->rca);
179 sdmmc_function_free(sf);
180 break;
181 }
182
183 /* Deselect. */
184 (void)sdmmc_select_card(sc, NULL);
185 #endif
186
187 /*
188 * If this is a memory-only card, the card responding
189 * first becomes an alias for SDIO function 0.
190 */
191 if (sc->sc_fn0 == NULL)
192 sc->sc_fn0 = sf;
193
194 SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf, sf_list);
195 }
196
197 /*
198 * All cards are either inactive or awaiting further commands.
199 * Read the CSDs and decode the raw CID for each card.
200 */
201 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
202 bzero(&cmd, sizeof cmd);
203 cmd.c_opcode = MMC_SEND_CSD;
204 cmd.c_arg = MMC_ARG_RCA(sf->rca);
205 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R2;
206
207 if (sdmmc_mmc_command(sc, &cmd) != 0) {
208 SET(sf->flags, SFF_ERROR);
209 continue;
210 }
211
212 if (sdmmc_decode_csd(sc, cmd.c_resp, sf) != 0 ||
213 sdmmc_decode_cid(sc, sf->raw_cid, sf) != 0) {
214 SET(sf->flags, SFF_ERROR);
215 continue;
216 }
217
218 #ifdef SDMMC_DEBUG
219 printf("%s: CID: ", SDMMCDEVNAME(sc));
220 sdmmc_print_cid(&sf->cid);
221 #endif
222 }
223 }
224
225 int
sdmmc_decode_csd(struct sdmmc_softc * sc,sdmmc_response resp,struct sdmmc_function * sf)226 sdmmc_decode_csd(struct sdmmc_softc *sc, sdmmc_response resp,
227 struct sdmmc_function *sf)
228 {
229 struct sdmmc_csd *csd = &sf->csd;
230
231 if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
232 /*
233 * CSD version 1.0 corresponds to SD system
234 * specification version 1.0 - 1.10. (SanDisk, 3.5.3)
235 */
236 csd->csdver = SD_CSD_CSDVER(resp);
237 switch (csd->csdver) {
238 case SD_CSD_CSDVER_2_0:
239 sf->flags |= SFF_SDHC;
240 csd->capacity = SD_CSD_V2_CAPACITY(resp);
241 csd->read_bl_len = SD_CSD_V2_BL_LEN;
242 break;
243 case SD_CSD_CSDVER_1_0:
244 csd->capacity = SD_CSD_CAPACITY(resp);
245 csd->read_bl_len = SD_CSD_READ_BL_LEN(resp);
246 break;
247 default:
248 printf("%s: unknown SD CSD structure version 0x%x\n",
249 SDMMCDEVNAME(sc), csd->csdver);
250 return 1;
251 break;
252 }
253
254 } else {
255 csd->csdver = MMC_CSD_CSDVER(resp);
256 if (csd->csdver != MMC_CSD_CSDVER_1_0 &&
257 csd->csdver != MMC_CSD_CSDVER_2_0) {
258 printf("%s: unknown MMC CSD structure version 0x%x\n",
259 SDMMCDEVNAME(sc), csd->csdver);
260 return 1;
261 }
262
263 csd->mmcver = MMC_CSD_MMCVER(resp);
264 csd->capacity = MMC_CSD_CAPACITY(resp);
265 csd->read_bl_len = MMC_CSD_READ_BL_LEN(resp);
266 }
267 csd->sector_size = MIN(1 << csd->read_bl_len,
268 sdmmc_chip_host_maxblklen(sc->sct, sc->sch));
269 if (csd->sector_size < (1<<csd->read_bl_len))
270 csd->capacity *= (1<<csd->read_bl_len) /
271 csd->sector_size;
272
273 return 0;
274 }
275
276 int
sdmmc_decode_cid(struct sdmmc_softc * sc,sdmmc_response resp,struct sdmmc_function * sf)277 sdmmc_decode_cid(struct sdmmc_softc *sc, sdmmc_response resp,
278 struct sdmmc_function *sf)
279 {
280 struct sdmmc_cid *cid = &sf->cid;
281
282 if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
283 cid->mid = SD_CID_MID(resp);
284 cid->oid = SD_CID_OID(resp);
285 SD_CID_PNM_CPY(resp, cid->pnm);
286 cid->rev = SD_CID_REV(resp);
287 cid->psn = SD_CID_PSN(resp);
288 cid->mdt = SD_CID_MDT(resp);
289 } else {
290 switch(sf->csd.mmcver) {
291 case MMC_CSD_MMCVER_1_0:
292 case MMC_CSD_MMCVER_1_4:
293 cid->mid = MMC_CID_MID_V1(resp);
294 MMC_CID_PNM_V1_CPY(resp, cid->pnm);
295 cid->rev = MMC_CID_REV_V1(resp);
296 cid->psn = MMC_CID_PSN_V1(resp);
297 cid->mdt = MMC_CID_MDT_V1(resp);
298 break;
299 case MMC_CSD_MMCVER_2_0:
300 case MMC_CSD_MMCVER_3_1:
301 case MMC_CSD_MMCVER_4_0:
302 cid->mid = MMC_CID_MID_V2(resp);
303 cid->oid = MMC_CID_OID_V2(resp);
304 MMC_CID_PNM_V2_CPY(resp, cid->pnm);
305 cid->psn = MMC_CID_PSN_V2(resp);
306 break;
307 default:
308 printf("%s: unknown MMC version %d\n",
309 SDMMCDEVNAME(sc), sf->csd.mmcver);
310 return 1;
311 }
312 }
313 return 0;
314 }
315
316 #ifdef SDMMC_DEBUG
317 void
sdmmc_print_cid(struct sdmmc_cid * cid)318 sdmmc_print_cid(struct sdmmc_cid *cid)
319 {
320 printf("mid=0x%02x oid=0x%04x pnm=\"%s\" rev=0x%02x psn=0x%08x"
321 " mdt=%03x\n", cid->mid, cid->oid, cid->pnm, cid->rev, cid->psn,
322 cid->mdt);
323 }
324 #endif
325
326 /*
327 * Initialize a SD/MMC memory card.
328 */
329 int
sdmmc_mem_init(struct sdmmc_softc * sc,struct sdmmc_function * sf)330 sdmmc_mem_init(struct sdmmc_softc *sc, struct sdmmc_function *sf)
331 {
332 int error = 0;
333
334 SDMMC_ASSERT_LOCKED(sc);
335
336 if (sdmmc_select_card(sc, sf) != 0 ||
337 sdmmc_mem_set_blocklen(sc, sf) != 0)
338 error = 1;
339 return error;
340 }
341
342 /*
343 * Get or set the card's memory OCR value (SD or MMC).
344 */
345 int
sdmmc_mem_send_op_cond(struct sdmmc_softc * sc,u_int32_t ocr,u_int32_t * ocrp)346 sdmmc_mem_send_op_cond(struct sdmmc_softc *sc, u_int32_t ocr,
347 u_int32_t *ocrp)
348 {
349 struct sdmmc_command cmd;
350 int error;
351 int i;
352
353 SDMMC_ASSERT_LOCKED(sc);
354
355 /*
356 * If we change the OCR value, retry the command until the OCR
357 * we receive in response has the "CARD BUSY" bit set, meaning
358 * that all cards are ready for identification.
359 */
360 for (i = 0; i < 100; i++) {
361 bzero(&cmd, sizeof cmd);
362 cmd.c_arg = ocr;
363 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R3;
364
365 if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
366 cmd.c_opcode = SD_APP_OP_COND;
367 error = sdmmc_app_command(sc, &cmd);
368 } else {
369 cmd.c_opcode = MMC_SEND_OP_COND;
370 error = sdmmc_mmc_command(sc, &cmd);
371 }
372 if (error != 0)
373 break;
374 if (ISSET(MMC_R3(cmd.c_resp), MMC_OCR_MEM_READY) ||
375 ocr == 0)
376 break;
377 error = ETIMEDOUT;
378 sdmmc_delay(10000);
379 }
380 if (error == 0 && ocrp != NULL)
381 *ocrp = MMC_R3(cmd.c_resp);
382
383 return error;
384 }
385
386 /*
387 * Set the read block length appropriately for this card, according to
388 * the card CSD register value.
389 */
390 int
sdmmc_mem_set_blocklen(struct sdmmc_softc * sc,struct sdmmc_function * sf)391 sdmmc_mem_set_blocklen(struct sdmmc_softc *sc, struct sdmmc_function *sf)
392 {
393 struct sdmmc_command cmd;
394
395 SDMMC_ASSERT_LOCKED(sc);
396
397 bzero(&cmd, sizeof cmd);
398 cmd.c_opcode = MMC_SET_BLOCKLEN;
399 cmd.c_arg = sf->csd.sector_size;
400 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
401 DPRINTF(("%s: read_bl_len=%d sector_size=%d\n", SDMMCDEVNAME(sc),
402 1 << sf->csd.read_bl_len, sf->csd.sector_size));
403
404 return sdmmc_mmc_command(sc, &cmd);
405 }
406
407 int
sdmmc_mem_read_block(struct sdmmc_function * sf,int blkno,u_char * data,size_t datalen)408 sdmmc_mem_read_block(struct sdmmc_function *sf, int blkno, u_char *data,
409 size_t datalen)
410 {
411 struct sdmmc_softc *sc = sf->sc;
412 struct sdmmc_command cmd;
413 int error;
414
415 SDMMC_LOCK(sc);
416
417 if ((error = sdmmc_select_card(sc, sf)) != 0)
418 goto err;
419
420 bzero(&cmd, sizeof cmd);
421 cmd.c_data = data;
422 cmd.c_datalen = datalen;
423 cmd.c_blklen = sf->csd.sector_size;
424 cmd.c_opcode = (datalen / cmd.c_blklen) > 1 ?
425 MMC_READ_BLOCK_MULTIPLE : MMC_READ_BLOCK_SINGLE;
426 if (sf->flags & SFF_SDHC)
427 cmd.c_arg = blkno;
428 else
429 cmd.c_arg = blkno << 9;
430 cmd.c_flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1;
431
432 error = sdmmc_mmc_command(sc, &cmd);
433 if (error != 0)
434 goto err;
435
436 if (ISSET(sc->sc_flags, SMF_STOP_AFTER_MULTIPLE) &&
437 cmd.c_opcode == MMC_READ_BLOCK_MULTIPLE) {
438 bzero(&cmd, sizeof cmd);
439 cmd.c_opcode = MMC_STOP_TRANSMISSION;
440 cmd.c_arg = MMC_ARG_RCA(sf->rca);
441 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1B;
442 error = sdmmc_mmc_command(sc, &cmd);
443 if (error != 0)
444 goto err;
445 }
446
447 do {
448 bzero(&cmd, sizeof cmd);
449 cmd.c_opcode = MMC_SEND_STATUS;
450 cmd.c_arg = MMC_ARG_RCA(sf->rca);
451 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
452 error = sdmmc_mmc_command(sc, &cmd);
453 if (error != 0)
454 break;
455 /* XXX time out */
456 } while (!ISSET(MMC_R1(cmd.c_resp), MMC_R1_READY_FOR_DATA));
457
458 err:
459 SDMMC_UNLOCK(sc);
460 return error;
461 }
462
463 int
sdmmc_mem_write_block(struct sdmmc_function * sf,int blkno,u_char * data,size_t datalen)464 sdmmc_mem_write_block(struct sdmmc_function *sf, int blkno, u_char *data,
465 size_t datalen)
466 {
467 struct sdmmc_softc *sc = sf->sc;
468 struct sdmmc_command cmd;
469 int error;
470
471 SDMMC_LOCK(sc);
472
473 if ((error = sdmmc_select_card(sc, sf)) != 0)
474 goto err;
475
476 bzero(&cmd, sizeof cmd);
477 cmd.c_data = data;
478 cmd.c_datalen = datalen;
479 cmd.c_blklen = sf->csd.sector_size;
480 cmd.c_opcode = (datalen / cmd.c_blklen) > 1 ?
481 MMC_WRITE_BLOCK_MULTIPLE : MMC_WRITE_BLOCK_SINGLE;
482 if (sf->flags & SFF_SDHC)
483 cmd.c_arg = blkno;
484 else
485 cmd.c_arg = blkno << 9;
486 cmd.c_flags = SCF_CMD_ADTC | SCF_RSP_R1;
487
488 error = sdmmc_mmc_command(sc, &cmd);
489 if (error != 0)
490 goto err;
491
492 if (ISSET(sc->sc_flags, SMF_STOP_AFTER_MULTIPLE) &&
493 cmd.c_opcode == MMC_WRITE_BLOCK_MULTIPLE) {
494 bzero(&cmd, sizeof cmd);
495 cmd.c_opcode = MMC_STOP_TRANSMISSION;
496 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1B;
497 error = sdmmc_mmc_command(sc, &cmd);
498 if (error != 0)
499 goto err;
500 }
501
502 do {
503 bzero(&cmd, sizeof cmd);
504 cmd.c_opcode = MMC_SEND_STATUS;
505 cmd.c_arg = MMC_ARG_RCA(sf->rca);
506 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
507 error = sdmmc_mmc_command(sc, &cmd);
508 if (error != 0)
509 break;
510 /* XXX time out */
511 } while (!ISSET(MMC_R1(cmd.c_resp), MMC_R1_READY_FOR_DATA));
512
513 err:
514 SDMMC_UNLOCK(sc);
515 return error;
516 }
517