1 /*-
2 * Copyright (c) 2012 The NetBSD Foundation, Inc.
3 * All rights reserved.
4 *
5 * This code is derived from software contributed to The NetBSD Foundation
6 * by Paul Fleischer <paul@xpg.dk>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 * All SD/MMC code is taken from various files in sys/dev/sdmmc
32 */
33 /*
34 * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
35 *
36 * Permission to use, copy, modify, and distribute this software for any
37 * purpose with or without fee is hereby granted, provided that the above
38 * copyright notice and this permission notice appear in all copies.
39 *
40 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
41 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
42 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
43 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
44 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
45 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
46 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
47 */
48
49 /*-
50 * Copyright (c) 2007-2010 NONAKA Kimihiro <nonaka@netbsd.org>
51 * All rights reserved.
52 *
53 * Redistribution and use in source and binary forms, with or without
54 * modification, are permitted provided that the following conditions
55 * are met:
56 * 1. Redistributions of source code must retain the above copyright
57 * notice, this list of conditions and the following disclaimer.
58 * 2. Redistributions in binary form must reproduce the above copyright
59 * notice, this list of conditions and the following disclaimer in the
60 * documentation and/or other materials provided with the distribution.
61 *
62 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
63 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
64 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
65 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
66 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
67 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
68 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
69 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
70 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
71 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
72 * SUCH DAMAGE.
73 */
74
75 #include <machine/limits.h>
76
77 #include <sys/param.h>
78 #include <sys/types.h>
79 #include <sys/disklabel.h>
80
81 #include <netinet/in.h>
82
83 #include <lib/libsa/stand.h>
84
85 #include <lib/libkern/libkern.h>
86 #include <lib/libsa/stand.h>
87 #include <lib/libsa/iodesc.h>
88
89 #include <dev/sdmmc/sdmmcreg.h>
90 #include "dev_sdmmc.h"
91 #include "s3csdi.h"
92
93 //#define SDMMC_DEBUG
94 #ifdef SDMMC_DEBUG
95 #define DPRINTF(s) do {printf s; } while (/*CONSTCOND*/0)
96 #else
97 #define DPRINTF(s) do {} while (/*CONSTCOND*/0)
98 #endif
99
100 /* SD/MMC device driver structure */
101 struct sdifdv {
102 char* name;
103 int (*match)(unsigned);
104 void* (*init)(unsigned, uint32_t*);
105 int (*host_ocr)(void*);
106 int (*bus_clock)(void*, int);
107 int (*bus_power)(void*, int);
108 int (*bus_width)(void*, int);
109 void (*exec_cmd)(void*, struct sdmmc_command*);
110 int (*get_max_bus_clock)(void*);
111 void* priv;
112 };
113
114 struct sdmmc_softc;
115
116 /* Structure used for of->f_devdata */
117 struct sdmmc_part {
118 struct sdmmc_softc *sc;
119 struct partition *part;
120 };
121
122 /* SD/MMC driver structure */
123 struct sdmmc_softc {
124 uint32_t flags;
125 uint32_t caps;
126 uint16_t rca; /* relative card address */
127 sdmmc_response raw_cid; /* temp. storage for decoding */
128 uint32_t raw_scr[2];
129 struct sdmmc_csd csd; /* decoded CSD value */
130 struct sdmmc_cid cid; /* decoded CID value */
131 struct sdmmc_scr scr;
132 int busclk;
133 struct sdifdv *sdifdv;
134 struct disklabel sc_label;
135 int npartitions;
136 struct sdmmc_part partitions[MAXPARTITIONS];
137 };
138
139 static struct sdifdv vnifdv[] = {
140 {"S3C SD/MMC", s3csd_match, s3csd_init, s3csd_host_ocr,
141 s3csd_bus_clock, s3csd_bus_power, s3csd_bus_width, s3csd_exec_cmd,
142 s3csd_get_max_bus_clock}
143 };
144 static int nnifdv = sizeof(vnifdv)/sizeof(vnifdv[0]);
145
146 static struct sdmmc_softc sdmmc_softc;
147 static uint8_t sdmmc_initialized = FALSE;
148
149 extern time_t getsecs();
150 extern time_t getusecs();
151 extern void usleep(int);
152
153 /* Local functions */
154 static int sdmmc_getdisklabel(struct sdmmc_softc *sc);
155 static int sdmmc_init(unsigned int tag);
156 static int sdmmc_enable(struct sdmmc_softc*);
157
158 static int sdmmc_mem_send_if_cond(struct sdmmc_softc*, uint32_t, uint32_t*);
159 static int sdmmc_mmc_command(struct sdmmc_softc*, struct sdmmc_command*);
160 static void sdmmc_go_idle_state(struct sdmmc_softc*);
161 static int sdmmc_mem_send_op_cond(struct sdmmc_softc*, uint32_t, uint32_t *);
162 static int sdmmc_set_bus_power(struct sdmmc_softc*, uint32_t, uint32_t);
163 static int sdmmc_app_command(struct sdmmc_softc*, uint16_t,
164 struct sdmmc_command*);
165 static int sdmmc_mmc_command(struct sdmmc_softc*, struct sdmmc_command*);
166 static int sdmmc_scan(struct sdmmc_softc*);
167 static void sdmmc_mem_scan(struct sdmmc_softc*);
168 static int sdmmc_set_relative_addr(struct sdmmc_softc*);
169 static int sdmmc_mem_send_cid(struct sdmmc_softc*, sdmmc_response*);
170
171 static int sdmmc_mem_send_csd(struct sdmmc_softc*, sdmmc_response*);
172 static int sdmmc_decode_csd(struct sdmmc_softc*, sdmmc_response);
173 static int sdmmc_decode_cid(struct sdmmc_softc*, sdmmc_response);
174
175 static int sdmmc_mem_read_block(struct sdmmc_softc*, uint32_t, u_char*, size_t);
176 static int sdmmc_select_card(struct sdmmc_softc*);
177 static int sdmmc_mem_set_blocklen(struct sdmmc_softc*);
178
179 static int sdmmc_mem_send_scr(struct sdmmc_softc*, uint32_t[2]);
180 static int sdmmc_mem_decode_scr(struct sdmmc_softc*);
181 static int sdmmc_set_bus_width(struct sdmmc_softc*, int);
182 static int sdmmc_mem_sd_switch(struct sdmmc_softc *, int, int, int, void*);
183
184 #ifdef SDMMC_DEBUG
185 static void sdmmc_dump_data(const char*, void*, size_t);
186 static void sdmmc_print_cid(struct sdmmc_cid*);
187 static void sdmmc_dump_command(struct sdmmc_softc*, struct sdmmc_command*);
188 #endif
189
190 int
sdmmc_open(struct open_file * of,...)191 sdmmc_open(struct open_file *of, ...)
192 {
193 va_list ap;
194 int unit __unused, part;
195
196 va_start(ap, of);
197 unit = va_arg(ap, u_int); /* Not used for now */
198 part = va_arg(ap, u_int);
199 va_end(ap);
200
201 /* Simply try to initialize SD mem sub system. */
202 if( !sdmmc_init(0) ) {
203 return 1;
204 }
205
206 of->f_devdata = (void*)&sdmmc_softc.partitions[part];
207
208 return 0;
209 }
210
211 int
sdmmc_close(struct open_file * f)212 sdmmc_close(struct open_file *f)
213 {
214 return (0);
215 }
216
217 int
sdmmc_get_fstype(void * p)218 sdmmc_get_fstype(void *p) {
219 struct sdmmc_part *part = (struct sdmmc_part*)p;
220
221 return part->part->p_fstype;
222 }
223
224
225 int
sdmmc_strategy(void * d,int f,daddr_t b,size_t s,void * buf,size_t * r)226 sdmmc_strategy(void *d, int f, daddr_t b, size_t s, void *buf, size_t *r)
227 {
228 struct sdmmc_part *part = (struct sdmmc_part*)d;
229 unsigned int offset;
230 switch(f) {
231 case F_READ:
232 offset = part->part->p_offset + b;
233 *r = s;
234 if(sdmmc_mem_read_block(part->sc, offset, buf, s) == 0)
235 return 0;
236 else
237 return EIO;
238 default:
239 printf("Unsupported operation\n");
240 break;
241 }
242 return (EIO);
243 }
244
245 int
sdmmc_getdisklabel(struct sdmmc_softc * sc)246 sdmmc_getdisklabel(struct sdmmc_softc *sc)
247 {
248 char *msg;
249 int sector, i, n;
250 size_t rsize;
251 struct mbr_partition *dp, *bsdp;
252 struct disklabel *lp;
253 /*uint8_t *buf = wd->sc_buf;*/
254 uint8_t buf[DEV_BSIZE];
255
256 lp = &sc->sc_label;
257 memset(lp, 0, sizeof(struct disklabel));
258
259 sector = 0;
260 if (sdmmc_strategy(&sc->partitions[0], F_READ, MBR_BBSECTOR, DEV_BSIZE,
261 buf, &rsize))
262 return EOFFSET;
263
264 dp = (struct mbr_partition *)(buf + MBR_PART_OFFSET);
265 bsdp = NULL;
266 for (i = 0; i < MBR_PART_COUNT; i++, dp++) {
267 if (dp->mbrp_type == MBR_PTYPE_NETBSD) {
268 bsdp = dp;
269 break;
270 }
271 }
272 if (!bsdp) {
273 /* generate fake disklabel */
274 lp->d_secsize = DEV_BSIZE;
275 /*lp->d_ntracks = wd->sc_params.atap_heads;
276 lp->d_nsectors = wd->sc_params.atap_sectors;
277 lp->d_ncylinders = wd->sc_params.atap_cylinders;*/
278 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
279 lp->d_type = DKTYPE_FLASH;
280 /*strncpy(lp->d_typename, (char *)wd->sc_params.atap_model, 16);*/
281 strncpy(lp->d_packname, "fictitious", 16);
282 /*if (wd->sc_capacity > UINT32_MAX)
283 lp->d_secperunit = UINT32_MAX;
284 else
285 lp->d_secperunit = wd->sc_capacity;*/
286 lp->d_rpm = 3600;
287 lp->d_interleave = 1;
288 lp->d_flags = 0;
289 lp->d_partitions[RAW_PART].p_offset = 0;
290 lp->d_partitions[RAW_PART].p_size =
291 lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
292 lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
293 lp->d_magic = DISKMAGIC;
294 lp->d_magic2 = DISKMAGIC;
295 lp->d_checksum = dkcksum(lp);
296
297 dp = (struct mbr_partition *)(buf + MBR_PART_OFFSET);
298 n = 'e' - 'a';
299 for (i = 0; i < MBR_PART_COUNT; i++, dp++) {
300 if (dp->mbrp_type == MBR_PTYPE_UNUSED)
301 continue;
302 lp->d_partitions[n].p_offset = bswap32(dp->mbrp_start);
303 lp->d_partitions[n].p_size = bswap32(dp->mbrp_size);
304 switch (dp->mbrp_type) {
305 case MBR_PTYPE_FAT12:
306 case MBR_PTYPE_FAT16S:
307 case MBR_PTYPE_FAT16B:
308 case MBR_PTYPE_FAT32:
309 case MBR_PTYPE_FAT32L:
310 case MBR_PTYPE_FAT16L:
311 lp->d_partitions[n].p_fstype = FS_MSDOS;
312 break;
313 case MBR_PTYPE_LNXEXT2:
314 lp->d_partitions[n].p_fstype = FS_EX2FS;
315 break;
316 default:
317 lp->d_partitions[n].p_fstype = FS_OTHER;
318 break;
319 }
320 n += 1;
321 }
322 lp->d_npartitions = n;
323 }
324 else {
325 sector = bsdp->mbrp_start;
326 if (sdmmc_strategy(&sc->partitions[0], F_READ,
327 sector + LABELSECTOR, DEV_BSIZE,
328 buf, &rsize))
329 return EOFFSET;
330 msg = getdisklabel((char *)buf + LABELOFFSET, &sc->sc_label);
331 if (msg != NULL)
332 printf("getdisklabel: %s\n", msg);
333 }
334 /*DPRINTF(("label info: d_secsize %d, d_nsectors %d, d_ncylinders %d,"
335 "d_ntracks %d, d_secpercyl %d\n",
336 wd->sc_label.d_secsize,
337 wd->sc_label.d_nsectors,
338 wd->sc_label.d_ncylinders,
339 wd->sc_label.d_ntracks,
340 wd->sc_label.d_secpercyl));*/
341
342 return 0;
343 }
344
345 void
sdmmc_delay(int us)346 sdmmc_delay(int us) {
347 usleep(us);
348 }
349
350 /* Initialize the SD/MMC subsystem. Return 1 on success, and 0 on error.
351 In case of error, errno will be set to a sane value.
352 */
353 int
sdmmc_init(unsigned int tag)354 sdmmc_init(unsigned int tag)
355 {
356 struct sdifdv *dv;
357 int n;
358 int error;
359 struct sdmmc_softc *sc = &sdmmc_softc;
360 char status[64];
361
362 if (sdmmc_initialized) {
363 printf("SD/MMC already initialized\n");
364 return 1;
365 }
366
367 for (n = 0; n < nnifdv; n++) {
368 dv = &vnifdv[n];
369 if ((*dv->match)(tag) > 0)
370 goto found;
371 }
372 errno = ENODEV;
373 return 0;
374 found:
375 sc->caps = 0;
376 /* Init should return NULL if no card is present. */
377 sc->sdifdv->priv = (*dv->init)(tag, &sc->caps);
378 if (sc->sdifdv->priv == NULL) {
379 /* We expect that the device initialization sets
380 errno properly */
381 return 0;
382 }
383
384 sc->flags = 0;
385 sc->sdifdv = dv;
386
387 /* Perform SD-card initialization. */
388 if( sdmmc_enable(sc) ) {
389 printf("Failed to enable SD interface\n");
390 errno = EIO;
391 return 0;
392 }
393 sc->busclk = sc->sdifdv->get_max_bus_clock(sc->sdifdv->priv);
394
395 if (sdmmc_scan(sc)) {
396 printf("No functions\n");
397 errno = EIO;
398 return 0;
399 }
400
401 if (sdmmc_select_card(sc)) {
402 printf("Failed to select card\n");
403 errno = EIO;
404 return 0;
405 }
406
407 if (!ISSET(sc->flags, SMF_CARD_SDHC)) {
408 sdmmc_mem_set_blocklen(sc);
409 }
410
411 /* change bus width if supported */
412 if (ISSET(sc->flags, SMF_SD_MODE) ) {
413 error = sdmmc_mem_send_scr(sc, sc->raw_scr);
414 if (error) {
415 DPRINTF(("SD_SEND_SCR send failed.\n"));
416 errno = EIO;
417 return 0;
418 }
419 error = sdmmc_mem_decode_scr(sc);
420 if (error) {
421 errno = EIO;
422 return 0;
423 }
424
425 if (ISSET(sc->caps, SMC_CAPS_4BIT_MODE) &&
426 ISSET(sc->scr.bus_width, SCR_SD_BUS_WIDTHS_4BIT)) {
427 error = sdmmc_set_bus_width(sc, 4);
428 if (error) {
429 DPRINTF(("can't change bus width"
430 " (%d bit)\n", 4));
431 errno = EIO;
432 return 0;
433 }
434 }
435
436 #if 1
437 if (sc->scr.sd_spec >= SCR_SD_SPEC_VER_1_10 &&
438 ISSET(sc->csd.ccc, SD_CSD_CCC_SWITCH)) {
439 DPRINTF(("switch func mode 0\n"));
440 error = sdmmc_mem_sd_switch(sc, 0, 1, 0, status);
441 if (error) {
442 printf("switch func mode 0 failed\n");
443 errno = error;
444 return 0;
445 }
446 }
447 #endif
448 sc->sdifdv->bus_clock(sc->sdifdv->priv, sc->busclk);
449 }
450
451 /* Prepare dummy partition[0] entry used by sdmmc_getdisklabel() */
452 sc->partitions[0].sc = sc;
453 sc->partitions[0].part->p_offset = 0;
454
455 if(sdmmc_getdisklabel(sc)) {
456 errno = EOFFSET;
457 return 0;
458 }
459
460 sc->npartitions = sc->sc_label.d_npartitions;
461 for(n=0; n<sc->sc_label.d_npartitions; n++) {
462 sc->partitions[n].part = &sc->sc_label.d_partitions[n];
463 sc->partitions[n].sc = sc;
464 }
465
466 sdmmc_initialized = TRUE;
467
468 return 1;
469 }
470
471 int
sdmmc_enable(struct sdmmc_softc * sc)472 sdmmc_enable(struct sdmmc_softc *sc)
473 {
474 uint32_t card_ocr;
475 uint32_t ocr = 0;
476 uint32_t host_ocr;
477 int error;
478
479 /* 1. Set the maximum power supported by bus */
480 /* For now, we expect the init function to set the maximum
481 voltage. And if that is not supported by the SD-card we
482 just cannot work with it.
483 */
484
485 sc->busclk = 400;
486 /* 2. Clock bus at minimum frequency */
487 sc->sdifdv->bus_clock(sc->sdifdv->priv, 400);
488
489 /* We expect that the above call has performed any waiting needed.*/
490
491 /* Initialize SD/MMC memory card(s), which is the only thing
492 we support.
493 */
494
495 /* Set host mode to SD "combo" card or SD memory-only. */
496 SET(sc->flags, SMF_SD_MODE|SMF_MEM_MODE);
497
498 sdmmc_go_idle_state(sc);
499
500 error = sdmmc_mem_send_if_cond(sc, 0x1aa, &card_ocr);
501 if (error == 0 && card_ocr == 0x1aa)
502 SET(ocr, MMC_OCR_HCS);
503
504 /*
505 * Read the SD/MMC memory OCR value by issuing CMD55 followed
506 * by ACMD41 to read the OCR value from memory-only SD cards.
507 * MMC cards will not respond to CMD55 or ACMD41 and this is
508 * how we distinguish them from SD cards.
509 */
510 mmc_mode:
511 error = sdmmc_mem_send_op_cond(sc,
512 ISSET(sc->caps, SMC_CAPS_SPI_MODE) ? ocr : 0, &card_ocr);
513 if (error) {
514 if (ISSET(sc->flags, SMF_SD_MODE) &&
515 !ISSET(sc->flags, SMF_IO_MODE)) {
516 /* Not a SD card, switch to MMC mode. */
517 DPRINTF(("Switch to MMC mode\n"));
518 CLR(sc->flags, SMF_SD_MODE);
519 goto mmc_mode;
520 }
521 if (!ISSET(sc->flags, SMF_SD_MODE)) {
522 DPRINTF(("couldn't read memory OCR\n"));
523 goto out;
524 } else {
525 /* Not a "combo" card. */
526 CLR(sc->flags, SMF_MEM_MODE);
527 error = 0;
528 goto out;
529 }
530 }
531 #if 0 /* SPI NOT SUPPORTED */
532 if (ISSET(ssc->caps, SMC_CAPS_SPI_MODE)) {
533 /* get card OCR */
534 error = sdmmc_mem_spi_read_ocr(sc, ocr, &card_ocr);
535 if (error) {
536 DPRINTF(("%s: couldn't read SPI memory OCR\n",
537 SDMMCDEVNAME(sc)));
538 goto out;
539 }
540 }
541 #endif
542
543 /* Set the lowest voltage supported by the card and host. */
544 host_ocr = sc->sdifdv->host_ocr(sc->sdifdv->priv);
545 error = sdmmc_set_bus_power(sc, host_ocr, card_ocr);
546 if (error) {
547 DPRINTF(("Couldn't supply voltage requested by card\n"));
548 goto out;
549 }
550 host_ocr &= card_ocr;
551 host_ocr |= ocr;
552
553 /* Send the new OCR value until all cards are ready. */
554 error = sdmmc_mem_send_op_cond(sc, host_ocr, NULL);
555 if (error) {
556 DPRINTF(("Couldn't send memory OCR\n"));
557 goto out;
558 }
559
560 out:
561 return error;
562 }
563
564 int
sdmmc_mem_send_if_cond(struct sdmmc_softc * sc,uint32_t ocr,uint32_t * ocrp)565 sdmmc_mem_send_if_cond(struct sdmmc_softc *sc, uint32_t ocr, uint32_t *ocrp)
566 {
567 struct sdmmc_command cmd;
568 int error;
569
570 memset(&cmd, 0, sizeof(cmd));
571 cmd.c_arg = ocr;
572 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R7 | SCF_RSP_SPI_R7;
573 cmd.c_opcode = SD_SEND_IF_COND;
574
575 error = sdmmc_mmc_command(sc, &cmd);
576 if (error == 0 && ocrp != NULL) {
577 *ocrp = MMC_R7(cmd.c_resp);
578 }
579
580 return error;
581 }
582
583 void
sdmmc_go_idle_state(struct sdmmc_softc * sc)584 sdmmc_go_idle_state(struct sdmmc_softc *sc)
585 {
586 struct sdmmc_command cmd;
587
588 memset(&cmd, 0, sizeof(cmd));
589 cmd.c_opcode = MMC_GO_IDLE_STATE;
590 cmd.c_flags = SCF_CMD_BC | SCF_RSP_R0 | SCF_RSP_SPI_R1;
591
592 (void)sdmmc_mmc_command(sc, &cmd);
593 }
594 int
sdmmc_mem_send_op_cond(struct sdmmc_softc * sc,uint32_t ocr,uint32_t * ocrp)595 sdmmc_mem_send_op_cond(struct sdmmc_softc *sc, uint32_t ocr, uint32_t *ocrp)
596 {
597 struct sdmmc_command cmd;
598 int error;
599 int retry;
600
601
602 /*
603 * If we change the OCR value, retry the command until the OCR
604 * we receive in response has the "CARD BUSY" bit set, meaning
605 * that all cards are ready for identification.
606 */
607 for (retry = 0; retry < 100; retry++) {
608 memset(&cmd, 0, sizeof(cmd));
609 cmd.c_arg = !ISSET(sc->caps, SMC_CAPS_SPI_MODE) ?
610 ocr : (ocr & MMC_OCR_HCS);
611 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R3 | SCF_RSP_SPI_R1;
612
613 if (ISSET(sc->flags, SMF_SD_MODE)) {
614 cmd.c_opcode = SD_APP_OP_COND;
615 error = sdmmc_app_command(sc, 0, &cmd);
616 } else {
617 cmd.c_opcode = MMC_SEND_OP_COND;
618 error = sdmmc_mmc_command(sc, &cmd);
619 }
620 if (error)
621 break;
622
623 if (ISSET(sc->caps, SMC_CAPS_SPI_MODE)) {
624 if (!ISSET(MMC_SPI_R1(cmd.c_resp), R1_SPI_IDLE))
625 break;
626 } else {
627 if (ISSET(MMC_R3(cmd.c_resp), MMC_OCR_MEM_READY) ||
628 ocr == 0)
629 break;
630 }
631
632 error = ETIMEDOUT;
633 sdmmc_delay(10000);
634 }
635 if (error == 0 &&
636 ocrp != NULL &&
637 !ISSET(sc->caps, SMC_CAPS_SPI_MODE))
638 *ocrp = MMC_R3(cmd.c_resp);
639 DPRINTF(("sdmmc_mem_send_op_cond: error=%d, ocr=%x\n",
640 error, MMC_R3(cmd.c_resp)));
641 return error;
642 }
643
644 /*
645 * Set the lowest bus voltage supported by the card and the host.
646 */
647 int
sdmmc_set_bus_power(struct sdmmc_softc * sc,uint32_t host_ocr,uint32_t card_ocr)648 sdmmc_set_bus_power(struct sdmmc_softc *sc, uint32_t host_ocr,
649 uint32_t card_ocr)
650 {
651 uint32_t bit;
652
653 /* Mask off unsupported voltage levels and select the lowest. */
654 DPRINTF(("host_ocr=%x ", host_ocr));
655 host_ocr &= card_ocr;
656 for (bit = 4; bit < 23; bit++) {
657 if (ISSET(host_ocr, (1 << bit))) {
658 host_ocr &= (3 << bit);
659 break;
660 }
661 }
662 DPRINTF(("card_ocr=%x new_ocr=%x\n", card_ocr, host_ocr));
663
664 if (host_ocr == 0 ||
665 sc->sdifdv->bus_power(sc->sdifdv->priv, host_ocr) != 0)
666 return 1;
667 return 0;
668 }
669
670 int
sdmmc_app_command(struct sdmmc_softc * sc,uint16_t rca,struct sdmmc_command * cmd)671 sdmmc_app_command(struct sdmmc_softc *sc, uint16_t rca,
672 struct sdmmc_command *cmd)
673 {
674 struct sdmmc_command acmd;
675 int error;
676
677 memset(&acmd, 0, sizeof(acmd));
678 acmd.c_opcode = MMC_APP_CMD;
679 if (rca != 0) {
680 acmd.c_arg = rca << 16;
681 acmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R1;
682 } else {
683 acmd.c_arg = 0;
684 acmd.c_flags = SCF_CMD_BCR | SCF_RSP_R1 | SCF_RSP_SPI_R1;
685 }
686
687 error = sdmmc_mmc_command(sc, &acmd);
688 if (error == 0) {
689 if (!ISSET(sc->caps, SMC_CAPS_SPI_MODE) &&
690 !ISSET(MMC_R1(acmd.c_resp), MMC_R1_APP_CMD)) {
691 /* Card does not support application commands. */
692 error = ENODEV;
693 } else {
694 error = sdmmc_mmc_command(sc, cmd);
695 }
696 }
697 DPRINTF(("sdmmc_app_command: done (error=%d)\n", error));
698 return error;
699 }
700
701 void
sdmmc_dump_command(struct sdmmc_softc * sc,struct sdmmc_command * cmd)702 sdmmc_dump_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
703 {
704 int i;
705
706 printf("cmd %u arg=%x data=%p dlen=%d flags=%x (error %d)\n",
707 cmd->c_opcode, cmd->c_arg, cmd->c_data,
708 cmd->c_datalen, cmd->c_flags, cmd->c_error);
709
710 if (cmd->c_error )
711 return;
712
713 printf("resp=");
714 if (ISSET(cmd->c_flags, SCF_RSP_136))
715 for (i = 0; i < sizeof cmd->c_resp; i++)
716 printf("%02x ", ((uint8_t *)cmd->c_resp)[i]);
717 else if (ISSET(cmd->c_flags, SCF_RSP_PRESENT))
718 for (i = 0; i < 4; i++)
719 printf("%02x ", ((uint8_t *)cmd->c_resp)[i]);
720 else
721 printf("none");
722 printf("\n");
723 }
724
725 int
sdmmc_mmc_command(struct sdmmc_softc * sc,struct sdmmc_command * cmd)726 sdmmc_mmc_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
727 {
728 int error;
729
730 DPRINTF(("sdmmc_mmc_command: cmd=%d, arg=%x, flags=%x\n",
731 cmd->c_opcode, cmd->c_arg, cmd->c_flags));
732
733 #if 0
734 #if defined(DIAGNOSTIC) || defined(SDMMC_DEBUG)
735 if (cmd->c_data && !ISSET(sc->caps, SMC_CAPS_SPI_MODE)) {
736 if (sc->sc_card == NULL)
737 panic("%s: deselected card\n", DEVNAME(sc));
738 }
739 #endif
740 #endif
741
742 sc->sdifdv->exec_cmd(sc->sdifdv->priv, cmd);
743
744 #ifdef SDMMC_DEBUG
745
746 sdmmc_dump_command(sc, cmd);
747
748 #endif
749
750 error = cmd->c_error;
751
752 DPRINTF(("sdmmc_mmc_command: error=%d\n", error));
753
754 return error;
755 }
756
757 /*
758 * Scan for I/O functions and memory cards on the bus, allocating a
759 * sdmmc_function structure for each.
760 */
761 int
sdmmc_scan(struct sdmmc_softc * sc)762 sdmmc_scan(struct sdmmc_softc *sc)
763 {
764
765 #if 0 /* SPI NOT SUPPORTED */
766 if (!ISSET(sc->caps, SMC_CAPS_SPI_MODE)) {
767 /* Scan for I/O functions. */
768 if (ISSET(sc->sc_flags, SMF_IO_MODE))
769 sdmmc_io_scan(sc);
770 }
771 #endif
772
773 /* Scan for memory cards on the bus. */
774 if (ISSET(sc->flags, SMF_MEM_MODE))
775 sdmmc_mem_scan(sc);
776
777 DPRINTF(("Bus clock speed: %d\n", sc->busclk));
778 return sc->sdifdv->bus_clock(sc->sdifdv->priv, sc->busclk);
779 }
780
781 /*
782 * Read the CSD and CID from all cards and assign each card a unique
783 * relative card address (RCA). CMD2 is ignored by SDIO-only cards.
784 */
785 void
sdmmc_mem_scan(struct sdmmc_softc * sc)786 sdmmc_mem_scan(struct sdmmc_softc *sc)
787 {
788 sdmmc_response resp;
789 //struct sdmmc_function *sf;
790 // uint16_t next_rca;
791 int error;
792 int retry;
793
794 /*
795 * CMD2 is a broadcast command understood by SD cards and MMC
796 * cards. All cards begin to respond to the command, but back
797 * off if another card drives the CMD line to a different level.
798 * Only one card will get its entire response through. That
799 * card remains silent once it has been assigned a RCA.
800 */
801 for (retry = 0; retry < 100; retry++) {
802 error = sdmmc_mem_send_cid(sc, &resp);
803 if (error) {
804 if (!ISSET(sc->caps, SMC_CAPS_SPI_MODE) &&
805 error == ETIMEDOUT) {
806 /* No more cards there. */
807 break;
808 }
809 DPRINTF(("Couldn't read CID\n"));
810 break;
811 }
812
813 /* In MMC mode, find the next available RCA. */
814 /*next_rca = 1;
815 if (!ISSET(dv->flags, SMF_SD_MODE)) {
816 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list)
817 next_rca++;
818 }*/
819
820 /* Allocate a sdmmc_function structure. */
821 /*sf = sdmmc_function_alloc(sc);
822 sf->rca = next_rca;*/
823
824 /*
825 * Remember the CID returned in the CMD2 response for
826 * later decoding.
827 */
828 memcpy(sc->raw_cid, resp, sizeof(sc->raw_cid));
829
830 /*
831 * Silence the card by assigning it a unique RCA, or
832 * querying it for its RCA in the case of SD.
833 */
834 if (!ISSET(sc->caps, SMC_CAPS_SPI_MODE)) {
835 if (sdmmc_set_relative_addr(sc) != 0) {
836 DPRINTF(("couldn't set mem RCA\n"));
837 break;
838 }
839 }
840
841 /*
842 * If this is a memory-only card, the card responding
843 * first becomes an alias for SDIO function 0.
844 */
845 /*if (sc->sc_fn0 == NULL)
846 sc->sc_fn0 = sf;
847
848 SIMPLEQ_INSERT_TAIL(&sc->sf_head, sf, sf_list);*/
849
850 /* only one function in SPI mode */
851 /*if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
852 break;*/
853 }
854
855 /*
856 * All cards are either inactive or awaiting further commands.
857 * Read the CSDs and decode the raw CID for each card.
858 */
859 /* SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {*/
860 error = sdmmc_mem_send_csd(sc, &resp);
861 if (error) {
862 /*SET(sf->flags, SFF_ERROR);
863 continue;*/
864 }
865
866 if (sdmmc_decode_csd(sc, resp) != 0 ||
867 sdmmc_decode_cid(sc, sc->raw_cid) != 0) {
868 /*SET(sf->flags, SFF_ERROR);
869 continue;*/
870 }
871
872 #ifdef SDMMC_DEBUG
873 printf("CID: ");
874 sdmmc_print_cid(&sc->cid);
875 #endif
876 /* }*/
877 }
878
879 /*
880 * Retrieve (SD) or set (MMC) the relative card address (RCA).
881 */
882 int
sdmmc_set_relative_addr(struct sdmmc_softc * sc)883 sdmmc_set_relative_addr(struct sdmmc_softc *sc)
884 {
885 struct sdmmc_command cmd;
886 int error;
887
888 /* Don't lock */
889
890 if (ISSET(sc->caps, SMC_CAPS_SPI_MODE))
891 return EIO;
892
893 memset(&cmd, 0, sizeof(cmd));
894 if (ISSET(sc->flags, SMF_SD_MODE)) {
895 cmd.c_opcode = SD_SEND_RELATIVE_ADDR;
896 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R6;
897 } else {
898 cmd.c_opcode = MMC_SET_RELATIVE_ADDR;
899 cmd.c_arg = MMC_ARG_RCA(sc->rca);
900 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
901 }
902 error = sdmmc_mmc_command(sc, &cmd);
903 if (error)
904 return error;
905
906 if (ISSET(sc->flags, SMF_SD_MODE))
907 sc->rca = SD_R6_RCA(cmd.c_resp);
908
909 return 0;
910 }
911
912 int
sdmmc_mem_send_cid(struct sdmmc_softc * sc,sdmmc_response * resp)913 sdmmc_mem_send_cid(struct sdmmc_softc *sc, sdmmc_response *resp)
914 {
915 struct sdmmc_command cmd;
916 int error;
917
918
919 memset(&cmd, 0, sizeof cmd);
920 cmd.c_opcode = MMC_ALL_SEND_CID;
921 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R2;
922
923 error = sdmmc_mmc_command(sc, &cmd);
924
925 #ifdef SDMMC_DEBUG
926 sdmmc_dump_data("CID", cmd.c_resp, sizeof(cmd.c_resp));
927 #endif
928 if (error == 0 && resp != NULL)
929 memcpy(resp, &cmd.c_resp, sizeof(*resp));
930 return error;
931 }
932
933 void
sdmmc_dump_data(const char * title,void * ptr,size_t size)934 sdmmc_dump_data(const char *title, void *ptr, size_t size)
935 {
936 char buf[16];
937 uint8_t *p = ptr;
938 int i, j;
939
940 printf("sdmmc_dump_data: %s\n", title ? title : "");
941 printf("--------+--------------------------------------------------+------------------+\n");
942 printf("offset | +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +a +b +c +d +e +f | data |\n");
943 printf("--------+--------------------------------------------------+------------------+\n");
944 for (i = 0; i < (int)size; i++) {
945 if ((i % 16) == 0) {
946 printf("%08x| ", i);
947 } else if ((i % 16) == 8) {
948 printf(" ");
949 }
950
951 printf("%02x ", p[i]);
952 buf[i % 16] = p[i];
953
954 if ((i % 16) == 15) {
955 printf("| ");
956 for (j = 0; j < 16; j++) {
957 if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
958 printf("%c", buf[j]);
959 } else {
960 printf(".");
961 }
962 }
963 printf(" |\n");
964 }
965 }
966 if ((i % 16) != 0) {
967 j = (i % 16);
968 for (; j < 16; j++) {
969 printf(" ");
970 if ((j % 16) == 8) {
971 printf(" ");
972 }
973 }
974
975 printf("| ");
976 for (j = 0; j < (i % 16); j++) {
977 if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
978 printf("%c", buf[j]);
979 } else {
980 printf(".");
981 }
982 }
983 for (; j < 16; j++) {
984 printf(" ");
985 }
986 printf(" |\n");
987 }
988 printf("--------+--------------------------------------------------+------------------+\n");
989 }
990
991 int
sdmmc_mem_send_csd(struct sdmmc_softc * sc,sdmmc_response * resp)992 sdmmc_mem_send_csd(struct sdmmc_softc *sc, sdmmc_response *resp)
993 {
994 struct sdmmc_command cmd;
995 int error;
996
997 memset(&cmd, 0, sizeof cmd);
998 cmd.c_opcode = MMC_SEND_CSD;
999 cmd.c_arg = MMC_ARG_RCA(sc->rca);
1000 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R2;
1001
1002 error = sdmmc_mmc_command(sc, &cmd);
1003
1004 #ifdef SDMMC_DEBUG
1005 sdmmc_dump_data("CSD", cmd.c_resp, sizeof(cmd.c_resp));
1006 #endif
1007 if (error == 0 && resp != NULL)
1008 memcpy(resp, &cmd.c_resp, sizeof(*resp));
1009 return error;
1010 }
1011
1012 int
sdmmc_decode_csd(struct sdmmc_softc * sc,sdmmc_response resp)1013 sdmmc_decode_csd(struct sdmmc_softc *sc, sdmmc_response resp)
1014 {
1015 /* TRAN_SPEED(2:0): transfer rate exponent */
1016 static const int speed_exponent[8] = {
1017 100 * 1, /* 100 Kbits/s */
1018 1 * 1000, /* 1 Mbits/s */
1019 10 * 1000, /* 10 Mbits/s */
1020 100 * 1000, /* 100 Mbits/s */
1021 0,
1022 0,
1023 0,
1024 0,
1025 };
1026 /* TRAN_SPEED(6:3): time mantissa */
1027 static const int speed_mantissa[16] = {
1028 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80,
1029 };
1030 struct sdmmc_csd *csd = &sc->csd;
1031 int e, m;
1032
1033 if (ISSET(sc->flags, SMF_SD_MODE)) {
1034 /*
1035 * CSD version 1.0 corresponds to SD system
1036 * specification version 1.0 - 1.10. (SanDisk, 3.5.3)
1037 */
1038 csd->csdver = SD_CSD_CSDVER(resp);
1039 switch (csd->csdver) {
1040 case SD_CSD_CSDVER_2_0:
1041 DPRINTF(("SD Ver.2.0\n"));
1042 SET(sc->flags, SMF_CARD_SDHC);
1043 csd->capacity = SD_CSD_V2_CAPACITY(resp);
1044 csd->read_bl_len = SD_CSD_V2_BL_LEN;
1045 csd->ccc = SD_CSD_CCC(resp);
1046 break;
1047
1048 case SD_CSD_CSDVER_1_0:
1049 DPRINTF(("SD Ver.1.0\n"));
1050 csd->capacity = SD_CSD_CAPACITY(resp);
1051 csd->read_bl_len = SD_CSD_READ_BL_LEN(resp);
1052 break;
1053
1054 default:
1055 printf("unknown SD CSD structure version 0x%x\n",
1056 csd->csdver);
1057 return 1;
1058 }
1059
1060 csd->mmcver = SD_CSD_MMCVER(resp);
1061 csd->write_bl_len = SD_CSD_WRITE_BL_LEN(resp);
1062 csd->r2w_factor = SD_CSD_R2W_FACTOR(resp);
1063 e = SD_CSD_SPEED_EXP(resp);
1064 m = SD_CSD_SPEED_MANT(resp);
1065 csd->tran_speed = speed_exponent[e] * speed_mantissa[m] / 10;
1066 } else {
1067 csd->csdver = MMC_CSD_CSDVER(resp);
1068 if (csd->csdver == MMC_CSD_CSDVER_1_0 ) {
1069 printf("unknown MMC CSD structure version 0x%x\n",
1070 csd->csdver);
1071 return 1;
1072 }
1073
1074 csd->mmcver = MMC_CSD_MMCVER(resp);
1075 csd->capacity = MMC_CSD_CAPACITY(resp);
1076 csd->read_bl_len = MMC_CSD_READ_BL_LEN(resp);
1077 csd->write_bl_len = MMC_CSD_WRITE_BL_LEN(resp);
1078 csd->r2w_factor = MMC_CSD_R2W_FACTOR(resp);
1079 e = MMC_CSD_TRAN_SPEED_EXP(resp);
1080 m = MMC_CSD_TRAN_SPEED_MANT(resp);
1081 csd->tran_speed = speed_exponent[e] * speed_mantissa[m] / 10;
1082 }
1083 if ((1 << csd->read_bl_len) > SDMMC_SECTOR_SIZE)
1084 csd->capacity *= (1 << csd->read_bl_len) / SDMMC_SECTOR_SIZE;
1085
1086
1087 if (sc->busclk > csd->tran_speed)
1088 sc->busclk = csd->tran_speed;
1089
1090 #ifdef SDMMC_DUMP_CSD
1091 sdmmc_print_csd(resp, csd);
1092 #endif
1093
1094 return 0;
1095 }
1096
1097 int
sdmmc_decode_cid(struct sdmmc_softc * sc,sdmmc_response resp)1098 sdmmc_decode_cid(struct sdmmc_softc *sc, sdmmc_response resp)
1099 {
1100 struct sdmmc_cid *cid = &sc->cid;
1101
1102 if (ISSET(sc->flags, SMF_SD_MODE)) {
1103 cid->mid = SD_CID_MID(resp);
1104 cid->oid = SD_CID_OID(resp);
1105 SD_CID_PNM_CPY(resp, cid->pnm);
1106 cid->rev = SD_CID_REV(resp);
1107 cid->psn = SD_CID_PSN(resp);
1108 cid->mdt = SD_CID_MDT(resp);
1109 } else {
1110 switch(sc->csd.mmcver) {
1111 case MMC_CSD_MMCVER_1_0:
1112 case MMC_CSD_MMCVER_1_4:
1113 cid->mid = MMC_CID_MID_V1(resp);
1114 MMC_CID_PNM_V1_CPY(resp, cid->pnm);
1115 cid->rev = MMC_CID_REV_V1(resp);
1116 cid->psn = MMC_CID_PSN_V1(resp);
1117 cid->mdt = MMC_CID_MDT_V1(resp);
1118 break;
1119 case MMC_CSD_MMCVER_2_0:
1120 case MMC_CSD_MMCVER_3_1:
1121 case MMC_CSD_MMCVER_4_0:
1122 cid->mid = MMC_CID_MID_V2(resp);
1123 cid->oid = MMC_CID_OID_V2(resp);
1124 MMC_CID_PNM_V2_CPY(resp, cid->pnm);
1125 cid->psn = MMC_CID_PSN_V2(resp);
1126 break;
1127 default:
1128 printf("unknown MMC version %d\n",
1129 sc->csd.mmcver);
1130 return 1;
1131 }
1132 }
1133 return 0;
1134 }
1135
1136 void
sdmmc_print_cid(struct sdmmc_cid * cid)1137 sdmmc_print_cid(struct sdmmc_cid *cid)
1138 {
1139
1140 printf("mid=0x%02x oid=0x%04x pnm=\"%s\" rev=0x%02x psn=0x%08x"
1141 " mdt=%03x\n", cid->mid, cid->oid, cid->pnm, cid->rev, cid->psn,
1142 cid->mdt);
1143 }
1144
1145 int
sdmmc_mem_read_block(struct sdmmc_softc * sc,uint32_t blkno,u_char * data,size_t datalen)1146 sdmmc_mem_read_block(struct sdmmc_softc *sc, uint32_t blkno,
1147 u_char *data, size_t datalen)
1148 {
1149 struct sdmmc_command cmd;
1150 int error;
1151
1152 memset(&cmd, 0, sizeof(cmd));
1153 cmd.c_data = data;
1154 cmd.c_datalen = datalen;
1155 cmd.c_blklen = SDMMC_SECTOR_SIZE;
1156 cmd.c_opcode = (cmd.c_datalen / cmd.c_blklen) > 1 ?
1157 MMC_READ_BLOCK_MULTIPLE : MMC_READ_BLOCK_SINGLE;
1158 cmd.c_arg = blkno;
1159 if (!ISSET(sc->flags, SMF_CARD_SDHC))
1160 cmd.c_arg <<= SDMMC_SECTOR_SIZE_SB;
1161 DPRINTF(("Reading block %d (%d)\n", blkno, cmd.c_arg));
1162 cmd.c_flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1 | SCF_RSP_SPI_R1;
1163
1164 error = sdmmc_mmc_command(sc, &cmd);
1165 if (error)
1166 goto out;
1167
1168 if (!ISSET(sc->caps, SMC_CAPS_AUTO_STOP)) {
1169 if (cmd.c_opcode == MMC_READ_BLOCK_MULTIPLE) {
1170 memset(&cmd, 0, sizeof cmd);
1171 cmd.c_opcode = MMC_STOP_TRANSMISSION;
1172 cmd.c_arg = MMC_ARG_RCA(sc->rca);
1173 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1B | SCF_RSP_SPI_R1B;
1174 error = sdmmc_mmc_command(sc, &cmd);
1175 if (error)
1176 goto out;
1177 }
1178 }
1179
1180 /*if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {*/
1181 do {
1182 memset(&cmd, 0, sizeof(cmd));
1183 cmd.c_opcode = MMC_SEND_STATUS;
1184 cmd.c_arg = MMC_ARG_RCA(sc->rca);
1185 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R2;
1186 error = sdmmc_mmc_command(sc, &cmd);
1187 if (error)
1188 break;
1189 /* XXX time out */
1190 } while (!ISSET(MMC_R1(cmd.c_resp), MMC_R1_READY_FOR_DATA));
1191 /*}*/
1192
1193 out:
1194 return error;
1195 }
1196
1197 int
sdmmc_select_card(struct sdmmc_softc * sc)1198 sdmmc_select_card(struct sdmmc_softc *sc)
1199 {
1200 struct sdmmc_command cmd;
1201 int error;
1202
1203 /* Don't lock */
1204
1205 /* if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
1206 return EIO;*/
1207
1208 /*if (sc->sc_card == sf
1209 || (sf && sc->sc_card && sc->sc_card->rca == sf->rca)) {
1210 sc->sc_card = sf;
1211 return 0;
1212 }*/
1213
1214 memset(&cmd, 0, sizeof(cmd));
1215 cmd.c_opcode = MMC_SELECT_CARD;
1216 cmd.c_arg = (sc == NULL) ? 0 : MMC_ARG_RCA(sc->rca);
1217 cmd.c_flags = SCF_CMD_AC | ((sc == NULL) ? SCF_RSP_R0 : SCF_RSP_R1);
1218 error = sdmmc_mmc_command(sc, &cmd);
1219 /*if (error == 0 || sf == NULL)
1220 sc->sc_card = sf;*/
1221
1222 return error;
1223 }
1224
1225 /*
1226 * Set the read block length appropriately for this card, according to
1227 * the card CSD register value.
1228 */
1229 int
sdmmc_mem_set_blocklen(struct sdmmc_softc * sc)1230 sdmmc_mem_set_blocklen(struct sdmmc_softc *sc)
1231 {
1232 struct sdmmc_command cmd;
1233 int error;
1234
1235 /* Don't lock */
1236
1237 memset(&cmd, 0, sizeof(cmd));
1238 cmd.c_opcode = MMC_SET_BLOCKLEN;
1239 cmd.c_arg = SDMMC_SECTOR_SIZE;
1240 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R1;
1241
1242 error = sdmmc_mmc_command(sc, &cmd);
1243
1244 DPRINTF(("sdmmc_mem_set_blocklen: read_bl_len=%d sector_size=%d\n",
1245 1 << sc->csd.read_bl_len, SDMMC_SECTOR_SIZE));
1246
1247 return error;
1248 }
1249
1250 int
sdmmc_mem_send_scr(struct sdmmc_softc * sc,uint32_t scr[2])1251 sdmmc_mem_send_scr(struct sdmmc_softc *sc, uint32_t scr[2])
1252 {
1253 struct sdmmc_command cmd;
1254 void *ptr = NULL;
1255 int datalen = 8;
1256 int error = 0;
1257
1258 ptr = alloc(datalen); //malloc(datalen, M_DEVBUF, M_NOWAIT | M_ZERO);
1259 if (ptr == NULL)
1260 goto out;
1261
1262 memset(&cmd, 0, sizeof(cmd));
1263 cmd.c_data = ptr;
1264 cmd.c_datalen = datalen;
1265 cmd.c_blklen = datalen;
1266 cmd.c_arg = 0;
1267 cmd.c_flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1 | SCF_RSP_SPI_R1;
1268 cmd.c_opcode = SD_APP_SEND_SCR;
1269
1270 error = sdmmc_app_command(sc, sc->rca, &cmd);
1271 if (error == 0) {
1272 memcpy(scr, ptr, datalen);
1273 }
1274
1275 out:
1276 if (ptr != NULL) {
1277 dealloc(ptr, datalen);
1278 }
1279 DPRINTF(("sdmem_mem_send_scr: error = %d\n",
1280 error));
1281 if (error)
1282 return error;
1283 #ifdef SDMMC_DEBUG
1284 sdmmc_dump_data("SCR", scr, 8);
1285 #endif
1286 return error;
1287 }
1288
1289 int
sdmmc_mem_decode_scr(struct sdmmc_softc * sc)1290 sdmmc_mem_decode_scr(struct sdmmc_softc *sc)
1291 {
1292 sdmmc_response resp;
1293 int ver;
1294
1295 memset(resp, 0, sizeof(resp));
1296 /*resp[0] = sc->raw_scr[1];
1297 resp[1] = sc->raw_scr[0];*/
1298 /*
1299 * Change the raw-scr received from the DMA stream to resp.
1300 */
1301 resp[0] = be32toh(sc->raw_scr[1]) >> 8; // LSW
1302 resp[1] = be32toh(sc->raw_scr[0]); // MSW
1303 resp[0] |= (resp[1] & 0xff) << 24;
1304 resp[1] >>= 8;
1305 resp[0] = htole32(resp[0]);
1306 resp[1] = htole32(resp[1]);
1307
1308 ver = SCR_STRUCTURE(resp);
1309 sc->scr.sd_spec = SCR_SD_SPEC(resp);
1310 sc->scr.bus_width = SCR_SD_BUS_WIDTHS(resp);
1311
1312 DPRINTF(("sdmmc_mem_decode_scr: spec=%d, bus width=%d\n",
1313 sc->scr.sd_spec, sc->scr.bus_width));
1314
1315 if (ver != 0) {
1316 DPRINTF(("unknown structure version: %d\n",
1317 ver));
1318 return EINVAL;
1319 }
1320 return 0;
1321 }
1322
1323 int
sdmmc_set_bus_width(struct sdmmc_softc * sc,int width)1324 sdmmc_set_bus_width(struct sdmmc_softc *sc, int width)
1325 {
1326 struct sdmmc_command cmd;
1327 int error;
1328
1329 if (ISSET(sc->caps, SMC_CAPS_SPI_MODE))
1330 return ENODEV;
1331
1332 memset(&cmd, 0, sizeof(cmd));
1333 cmd.c_opcode = SD_APP_SET_BUS_WIDTH;
1334 cmd.c_flags = SCF_RSP_R1 | SCF_CMD_AC;
1335
1336 switch (width) {
1337 case 1:
1338 cmd.c_arg = SD_ARG_BUS_WIDTH_1;
1339 break;
1340
1341 case 4:
1342 cmd.c_arg = SD_ARG_BUS_WIDTH_4;
1343 break;
1344
1345 default:
1346 return EINVAL;
1347 }
1348
1349 error = sdmmc_app_command(sc, sc->rca, &cmd);
1350 if (error == 0)
1351 error = sc->sdifdv->bus_width(sc->sdifdv->priv, width);
1352 return error;
1353 }
1354
1355 #if 1
1356 static int
sdmmc_mem_sd_switch(struct sdmmc_softc * sc,int mode,int group,int function,void * status)1357 sdmmc_mem_sd_switch(struct sdmmc_softc *sc, int mode, int group,
1358 int function, void *status)
1359 {
1360 struct sdmmc_command cmd;
1361 void *ptr = NULL;
1362 int gsft, error = 0;
1363 const int statlen = 64;
1364
1365 if (sc->scr.sd_spec >= SCR_SD_SPEC_VER_1_10 &&
1366 !ISSET(sc->csd.ccc, SD_CSD_CCC_SWITCH))
1367 return EINVAL;
1368
1369 if (group <= 0 || group > 6 ||
1370 function < 0 || function > 16)
1371 return EINVAL;
1372
1373 gsft = (group - 1) << 2;
1374
1375 ptr = alloc(statlen);
1376 if (ptr == NULL)
1377 goto out;
1378
1379 memset(&cmd, 0, sizeof(cmd));
1380 cmd.c_data = ptr;
1381 cmd.c_datalen = statlen;
1382 cmd.c_blklen = statlen;
1383 cmd.c_opcode = SD_SEND_SWITCH_FUNC;
1384 cmd.c_arg =
1385 (!!mode << 31) | (function << gsft) | (0x00ffffff & ~(0xf << gsft));
1386 cmd.c_flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1 | SCF_RSP_SPI_R1;
1387
1388 error = sdmmc_mmc_command(sc, &cmd);
1389 if (error == 0) {
1390 memcpy(status, ptr, statlen);
1391 }
1392
1393 out:
1394 if (ptr != NULL) {
1395 dealloc(ptr, statlen);
1396 }
1397 return error;
1398 }
1399 #endif
1400