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