Home | History | Annotate | Line # | Download | only in sdmmc
sdmmc.c revision 1.15.2.1
      1 /*	$NetBSD: sdmmc.c,v 1.15.2.1 2013/02/25 00:29:31 tls Exp $	*/
      2 /*	$OpenBSD: sdmmc.c,v 1.18 2009/01/09 10:58:38 jsg Exp $	*/
      3 
      4 /*
      5  * Copyright (c) 2006 Uwe Stuehler <uwe (at) openbsd.org>
      6  *
      7  * Permission to use, copy, modify, and distribute this software for any
      8  * purpose with or without fee is hereby granted, provided that the above
      9  * copyright notice and this permission notice appear in all copies.
     10  *
     11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
     12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
     13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
     14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
     15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
     16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
     17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     18  */
     19 
     20 /*-
     21  * Copyright (C) 2007, 2008, 2009 NONAKA Kimihiro <nonaka (at) netbsd.org>
     22  * All rights reserved.
     23  *
     24  * Redistribution and use in source and binary forms, with or without
     25  * modification, are permitted provided that the following conditions
     26  * are met:
     27  * 1. Redistributions of source code must retain the above copyright
     28  *    notice, this list of conditions and the following disclaimer.
     29  * 2. Redistributions in binary form must reproduce the above copyright
     30  *    notice, this list of conditions and the following disclaimer in the
     31  *    documentation and/or other materials provided with the distribution.
     32  *
     33  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     34  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     35  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     36  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     37  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     38  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     39  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     40  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     41  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     42  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     43  */
     44 
     45 /*
     46  * Host controller independent SD/MMC bus driver based on information
     47  * from SanDisk SD Card Product Manual Revision 2.2 (SanDisk), SDIO
     48  * Simple Specification Version 1.0 (SDIO) and the Linux "mmc" driver.
     49  */
     50 
     51 #include <sys/cdefs.h>
     52 __KERNEL_RCSID(0, "$NetBSD: sdmmc.c,v 1.15.2.1 2013/02/25 00:29:31 tls Exp $");
     53 
     54 #ifdef _KERNEL_OPT
     55 #include "opt_sdmmc.h"
     56 #endif
     57 
     58 #include <sys/param.h>
     59 #include <sys/device.h>
     60 #include <sys/kernel.h>
     61 #include <sys/kthread.h>
     62 #include <sys/malloc.h>
     63 #include <sys/proc.h>
     64 #include <sys/systm.h>
     65 #include <sys/callout.h>
     66 
     67 #include <machine/vmparam.h>
     68 
     69 #include <dev/sdmmc/sdmmc_ioreg.h>
     70 #include <dev/sdmmc/sdmmcchip.h>
     71 #include <dev/sdmmc/sdmmcreg.h>
     72 #include <dev/sdmmc/sdmmcvar.h>
     73 
     74 #ifdef SDMMC_DEBUG
     75 int sdmmcdebug = 1;
     76 static void sdmmc_dump_command(struct sdmmc_softc *, struct sdmmc_command *);
     77 #define DPRINTF(n,s)	do { if ((n) <= sdmmcdebug) printf s; } while (0)
     78 #else
     79 #define	DPRINTF(n,s)	do {} while (0)
     80 #endif
     81 
     82 #define	DEVNAME(sc)	SDMMCDEVNAME(sc)
     83 
     84 static int sdmmc_match(device_t, cfdata_t, void *);
     85 static void sdmmc_attach(device_t, device_t, void *);
     86 static int sdmmc_detach(device_t, int);
     87 
     88 CFATTACH_DECL_NEW(sdmmc, sizeof(struct sdmmc_softc),
     89     sdmmc_match, sdmmc_attach, sdmmc_detach, NULL);
     90 
     91 static void sdmmc_doattach(device_t);
     92 static void sdmmc_task_thread(void *);
     93 static void sdmmc_discover_task(void *);
     94 static void sdmmc_polling_card(void *);
     95 static void sdmmc_card_attach(struct sdmmc_softc *);
     96 static void sdmmc_card_detach(struct sdmmc_softc *, int);
     97 static int sdmmc_print(void *, const char *);
     98 static int sdmmc_enable(struct sdmmc_softc *);
     99 static void sdmmc_disable(struct sdmmc_softc *);
    100 static int sdmmc_scan(struct sdmmc_softc *);
    101 static int sdmmc_init(struct sdmmc_softc *);
    102 
    103 static int
    104 sdmmc_match(device_t parent, cfdata_t cf, void *aux)
    105 {
    106 	struct sdmmcbus_attach_args *saa = (struct sdmmcbus_attach_args *)aux;
    107 
    108 	if (strcmp(saa->saa_busname, cf->cf_name) == 0)
    109 		return 1;
    110 	return 0;
    111 }
    112 
    113 static void
    114 sdmmc_attach(device_t parent, device_t self, void *aux)
    115 {
    116 	struct sdmmc_softc *sc = device_private(self);
    117 	struct sdmmcbus_attach_args *saa = (struct sdmmcbus_attach_args *)aux;
    118 	int error;
    119 
    120 	aprint_normal("\n");
    121 	aprint_naive("\n");
    122 
    123 	sc->sc_dev = self;
    124 	sc->sc_sct = saa->saa_sct;
    125 	sc->sc_spi_sct = saa->saa_spi_sct;
    126 	sc->sc_sch = saa->saa_sch;
    127 	sc->sc_dmat = saa->saa_dmat;
    128 	sc->sc_clkmin = saa->saa_clkmin;
    129 	sc->sc_clkmax = saa->saa_clkmax;
    130 	sc->sc_busclk = sc->sc_clkmax;
    131 	sc->sc_buswidth = 1;
    132 	sc->sc_caps = saa->saa_caps;
    133 
    134 	if (ISSET(sc->sc_caps, SMC_CAPS_DMA)) {
    135 		error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, SDMMC_MAXNSEGS,
    136 		    MAXPHYS, 0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &sc->sc_dmap);
    137 		if (error) {
    138 			aprint_error_dev(sc->sc_dev,
    139 			    "couldn't create dma map. (error=%d)\n", error);
    140 			return;
    141 		}
    142 	}
    143 
    144 	if (ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) {
    145 		callout_init(&sc->sc_card_detect_ch, 0);
    146 		callout_reset(&sc->sc_card_detect_ch, hz,
    147 		    sdmmc_polling_card, sc);
    148 	}
    149 
    150 	SIMPLEQ_INIT(&sc->sf_head);
    151 	TAILQ_INIT(&sc->sc_tskq);
    152 	TAILQ_INIT(&sc->sc_intrq);
    153 
    154 	sdmmc_init_task(&sc->sc_discover_task, sdmmc_discover_task, sc);
    155 	sdmmc_init_task(&sc->sc_intr_task, sdmmc_intr_task, sc);
    156 
    157 	mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_SDMMC);
    158 	mutex_init(&sc->sc_tskq_mtx, MUTEX_DEFAULT, IPL_SDMMC);
    159 	mutex_init(&sc->sc_discover_task_mtx, MUTEX_DEFAULT, IPL_SDMMC);
    160 	mutex_init(&sc->sc_intr_task_mtx, MUTEX_DEFAULT, IPL_SDMMC);
    161 	cv_init(&sc->sc_tskq_cv, "mmctaskq");
    162 
    163 	if (!pmf_device_register(self, NULL, NULL)) {
    164 		aprint_error_dev(self, "couldn't establish power handler\n");
    165 	}
    166 
    167 	SET(sc->sc_flags, SMF_INITED);
    168 
    169 	/*
    170 	 * Create the event thread that will attach and detach cards
    171 	 * and perform other lengthy operations.
    172 	 */
    173 	config_pending_incr();
    174 	config_interrupts(self, sdmmc_doattach);
    175 }
    176 
    177 static int
    178 sdmmc_detach(device_t self, int flags)
    179 {
    180 	struct sdmmc_softc *sc = device_private(self);
    181 	int error;
    182 
    183 	mutex_enter(&sc->sc_tskq_mtx);
    184 	sc->sc_dying = 1;
    185 	cv_signal(&sc->sc_tskq_cv);
    186 	while (sc->sc_tskq_lwp != NULL)
    187 		cv_wait(&sc->sc_tskq_cv, &sc->sc_tskq_mtx);
    188 	mutex_exit(&sc->sc_tskq_mtx);
    189 
    190 	pmf_device_deregister(self);
    191 
    192 	error = config_detach_children(self, flags);
    193 	if (error)
    194 		return error;
    195 
    196 	if (ISSET(sc->sc_caps, SMC_CAPS_DMA)) {
    197 		bus_dmamap_unload(sc->sc_dmat, sc->sc_dmap);
    198 		bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmap);
    199 	}
    200 
    201 	return 0;
    202 }
    203 
    204 static void
    205 sdmmc_doattach(device_t dev)
    206 {
    207 	struct sdmmc_softc *sc = device_private(dev);
    208 
    209 	if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
    210 	    sdmmc_task_thread, sc, &sc->sc_tskq_lwp, "%s", device_xname(dev))) {
    211 		aprint_error_dev(dev, "couldn't create task thread\n");
    212 	}
    213 }
    214 
    215 void
    216 sdmmc_add_task(struct sdmmc_softc *sc, struct sdmmc_task *task)
    217 {
    218 
    219 	mutex_enter(&sc->sc_tskq_mtx);
    220 	task->onqueue = 1;
    221 	task->sc = sc;
    222 	TAILQ_INSERT_TAIL(&sc->sc_tskq, task, next);
    223 	cv_broadcast(&sc->sc_tskq_cv);
    224 	mutex_exit(&sc->sc_tskq_mtx);
    225 }
    226 
    227 static inline void
    228 sdmmc_del_task1(struct sdmmc_softc *sc, struct sdmmc_task *task)
    229 {
    230 
    231 	TAILQ_REMOVE(&sc->sc_tskq, task, next);
    232 	task->sc = NULL;
    233 	task->onqueue = 0;
    234 }
    235 
    236 void
    237 sdmmc_del_task(struct sdmmc_task *task)
    238 {
    239 	struct sdmmc_softc *sc = (struct sdmmc_softc *)task->sc;
    240 
    241 	if (sc != NULL) {
    242 		mutex_enter(&sc->sc_tskq_mtx);
    243 		sdmmc_del_task1(sc, task);
    244 		mutex_exit(&sc->sc_tskq_mtx);
    245 	}
    246 }
    247 
    248 static void
    249 sdmmc_task_thread(void *arg)
    250 {
    251 	struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
    252 	struct sdmmc_task *task;
    253 
    254 	sdmmc_discover_task(sc);
    255 	config_pending_decr();
    256 
    257 	mutex_enter(&sc->sc_tskq_mtx);
    258 	for (;;) {
    259 		task = TAILQ_FIRST(&sc->sc_tskq);
    260 		if (task != NULL) {
    261 			sdmmc_del_task1(sc, task);
    262 			mutex_exit(&sc->sc_tskq_mtx);
    263 			(*task->func)(task->arg);
    264 			mutex_enter(&sc->sc_tskq_mtx);
    265 		} else {
    266 			/* Check for the exit condition. */
    267 			if (sc->sc_dying)
    268 				break;
    269 			cv_wait(&sc->sc_tskq_cv, &sc->sc_tskq_mtx);
    270 		}
    271 	}
    272 	/* time to die. */
    273 	sc->sc_dying = 0;
    274 	if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
    275 		/*
    276 		 * sdmmc_card_detach() may issue commands,
    277 		 * so temporarily drop the interrupt-blocking lock.
    278 		 */
    279 		mutex_exit(&sc->sc_tskq_mtx);
    280 		sdmmc_card_detach(sc, DETACH_FORCE);
    281 		mutex_enter(&sc->sc_tskq_mtx);
    282 	}
    283 	sc->sc_tskq_lwp = NULL;
    284 	cv_broadcast(&sc->sc_tskq_cv);
    285 	mutex_exit(&sc->sc_tskq_mtx);
    286 	kthread_exit(0);
    287 }
    288 
    289 void
    290 sdmmc_needs_discover(device_t dev)
    291 {
    292 	struct sdmmc_softc *sc = device_private(dev);
    293 
    294 	if (!ISSET(sc->sc_flags, SMF_INITED))
    295 		return;
    296 
    297 	mutex_enter(&sc->sc_discover_task_mtx);
    298 	if (!sdmmc_task_pending(&sc->sc_discover_task))
    299 		sdmmc_add_task(sc, &sc->sc_discover_task);
    300 	mutex_exit(&sc->sc_discover_task_mtx);
    301 }
    302 
    303 static void
    304 sdmmc_discover_task(void *arg)
    305 {
    306 	struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
    307 
    308 	if (sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch)) {
    309 		if (!ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
    310 			SET(sc->sc_flags, SMF_CARD_PRESENT);
    311 			sdmmc_card_attach(sc);
    312 			if (!ISSET(sc->sc_flags, SMF_CARD_ATTACHED))
    313 				CLR(sc->sc_flags, SMF_CARD_PRESENT);
    314 		}
    315 	} else {
    316 		if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
    317 			CLR(sc->sc_flags, SMF_CARD_PRESENT);
    318 			sdmmc_card_detach(sc, DETACH_FORCE);
    319 		}
    320 	}
    321 }
    322 
    323 static void
    324 sdmmc_polling_card(void *arg)
    325 {
    326 	struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
    327 	int card_detect;
    328 	int s;
    329 
    330 	s = splsdmmc();
    331 	card_detect = sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch);
    332 	if (card_detect) {
    333 		if (!ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
    334 			sdmmc_needs_discover(sc->sc_dev);
    335 		}
    336 	} else {
    337 		if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
    338 			sdmmc_needs_discover(sc->sc_dev);
    339 		}
    340 	}
    341 	splx(s);
    342 
    343 	callout_schedule(&sc->sc_card_detect_ch, hz);
    344 }
    345 
    346 /*
    347  * Called from process context when a card is present.
    348  */
    349 static void
    350 sdmmc_card_attach(struct sdmmc_softc *sc)
    351 {
    352 	struct sdmmc_function *sf;
    353 	struct sdmmc_attach_args saa;
    354 	int error;
    355 
    356 	DPRINTF(1,("%s: attach card\n", DEVNAME(sc)));
    357 
    358 	CLR(sc->sc_flags, SMF_CARD_ATTACHED);
    359 
    360 	/*
    361 	 * Power up the card (or card stack).
    362 	 */
    363 	error = sdmmc_enable(sc);
    364 	if (error) {
    365 		if (!ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) {
    366 			aprint_error_dev(sc->sc_dev, "couldn't enable card: %d\n", error);
    367 		}
    368 		goto err;
    369 	}
    370 
    371 	/*
    372 	 * Scan for I/O functions and memory cards on the bus,
    373 	 * allocating a sdmmc_function structure for each.
    374 	 */
    375 	error = sdmmc_scan(sc);
    376 	if (error) {
    377 		aprint_error_dev(sc->sc_dev, "no functions\n");
    378 		goto err;
    379 	}
    380 
    381 	/*
    382 	 * Initialize the I/O functions and memory cards.
    383 	 */
    384 	error = sdmmc_init(sc);
    385 	if (error) {
    386 		aprint_error_dev(sc->sc_dev, "init failed\n");
    387 		goto err;
    388 	}
    389 
    390 	SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
    391 		if (ISSET(sc->sc_flags, SMF_IO_MODE) && sf->number < 1)
    392 			continue;
    393 
    394 		memset(&saa, 0, sizeof saa);
    395 		saa.manufacturer = sf->cis.manufacturer;
    396 		saa.product = sf->cis.product;
    397 		saa.interface = sf->interface;
    398 		saa.sf = sf;
    399 
    400 		sf->child =
    401 		    config_found_ia(sc->sc_dev, "sdmmc", &saa, sdmmc_print);
    402 	}
    403 
    404 	SET(sc->sc_flags, SMF_CARD_ATTACHED);
    405 	return;
    406 
    407 err:
    408 	sdmmc_card_detach(sc, DETACH_FORCE);
    409 }
    410 
    411 /*
    412  * Called from process context with DETACH_* flags from <sys/device.h>
    413  * when cards are gone.
    414  */
    415 static void
    416 sdmmc_card_detach(struct sdmmc_softc *sc, int flags)
    417 {
    418 	struct sdmmc_function *sf, *sfnext;
    419 
    420 	DPRINTF(1,("%s: detach card\n", DEVNAME(sc)));
    421 
    422 	if (ISSET(sc->sc_flags, SMF_CARD_ATTACHED)) {
    423 		SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
    424 			if (sf->child != NULL) {
    425 				config_detach(sf->child, DETACH_FORCE);
    426 				sf->child = NULL;
    427 			}
    428 		}
    429 
    430 		KASSERT(TAILQ_EMPTY(&sc->sc_intrq));
    431 
    432 		CLR(sc->sc_flags, SMF_CARD_ATTACHED);
    433 	}
    434 
    435 	/* Power down. */
    436 	sdmmc_disable(sc);
    437 
    438 	/* Free all sdmmc_function structures. */
    439 	for (sf = SIMPLEQ_FIRST(&sc->sf_head); sf != NULL; sf = sfnext) {
    440 		sfnext = SIMPLEQ_NEXT(sf, sf_list);
    441 		sdmmc_function_free(sf);
    442 	}
    443 	SIMPLEQ_INIT(&sc->sf_head);
    444 	sc->sc_function_count = 0;
    445 	sc->sc_fn0 = NULL;
    446 }
    447 
    448 static int
    449 sdmmc_print(void *aux, const char *pnp)
    450 {
    451 	struct sdmmc_attach_args *sa = aux;
    452 	struct sdmmc_function *sf = sa->sf;
    453 	struct sdmmc_cis *cis = &sf->sc->sc_fn0->cis;
    454 	int i, x;
    455 
    456 	if (pnp) {
    457 		if (sf->number == 0)
    458 			return QUIET;
    459 
    460 		for (i = 0; i < 4 && cis->cis1_info[i]; i++)
    461 			printf("%s%s", i ? ", " : "\"", cis->cis1_info[i]);
    462 		if (i != 0)
    463 			printf("\"");
    464 
    465 		if ((cis->manufacturer != SDMMC_VENDOR_INVALID &&
    466 		    cis->product != SDMMC_PRODUCT_INVALID) ||
    467 		    sa->interface != SD_IO_SFIC_NO_STANDARD) {
    468 			x = !!(cis->manufacturer != SDMMC_VENDOR_INVALID);
    469 			x += !!(cis->product != SDMMC_PRODUCT_INVALID);
    470 			x += !!(sa->interface != SD_IO_SFIC_NO_STANDARD);
    471 			printf("%s(", i ? " " : "");
    472 			if (cis->manufacturer != SDMMC_VENDOR_INVALID)
    473 				printf("manufacturer 0x%x%s",
    474 				    cis->manufacturer, (--x == 0) ?  "" : ", ");
    475 			if (cis->product != SDMMC_PRODUCT_INVALID)
    476 				printf("product 0x%x%s",
    477 				    cis->product, (--x == 0) ?  "" : ", ");
    478 			if (sa->interface != SD_IO_SFIC_NO_STANDARD)
    479 				printf("standard function interface code 0x%x",
    480 				    sf->interface);
    481 			printf(")");
    482 		}
    483 		printf("%sat %s", i ? " " : "", pnp);
    484 	}
    485 	if (sf->number > 0)
    486 		printf(" function %d", sf->number);
    487 
    488 	if (!pnp) {
    489 		for (i = 0; i < 3 && cis->cis1_info[i]; i++)
    490 			printf("%s%s", i ? ", " : " \"", cis->cis1_info[i]);
    491 		if (i != 0)
    492 			printf("\"");
    493 	}
    494 	return UNCONF;
    495 }
    496 
    497 static int
    498 sdmmc_enable(struct sdmmc_softc *sc)
    499 {
    500 	int error;
    501 
    502 	/*
    503 	 * Calculate the equivalent of the card OCR from the host
    504 	 * capabilities and select the maximum supported bus voltage.
    505 	 */
    506 	error = sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch,
    507 	    sdmmc_chip_host_ocr(sc->sc_sct, sc->sc_sch));
    508 	if (error) {
    509 		aprint_error_dev(sc->sc_dev, "couldn't supply bus power\n");
    510 		goto out;
    511 	}
    512 
    513 	/*
    514 	 * Select the minimum clock frequency.
    515 	 */
    516 	error = sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_400K);
    517 	if (error) {
    518 		aprint_error_dev(sc->sc_dev, "couldn't supply clock\n");
    519 		goto out;
    520 	}
    521 
    522 	/* XXX wait for card to power up */
    523 	sdmmc_delay(100000);
    524 
    525 	if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
    526 		/* Initialize SD I/O card function(s). */
    527 		error = sdmmc_io_enable(sc);
    528 		if (error) {
    529 			DPRINTF(1, ("%s: sdmmc_io_enable failed %d\n", DEVNAME(sc), error));
    530 			goto out;
    531 		}
    532 	}
    533 
    534 	/* Initialize SD/MMC memory card(s). */
    535 	if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) ||
    536 	    ISSET(sc->sc_flags, SMF_MEM_MODE)) {
    537 		error = sdmmc_mem_enable(sc);
    538 		if (error) {
    539 			DPRINTF(1, ("%s: sdmmc_mem_enable failed %d\n", DEVNAME(sc), error));
    540 			goto out;
    541 		}
    542 	}
    543 
    544 out:
    545 	if (error)
    546 		sdmmc_disable(sc);
    547 	return error;
    548 }
    549 
    550 static void
    551 sdmmc_disable(struct sdmmc_softc *sc)
    552 {
    553 	/* XXX complete commands if card is still present. */
    554 
    555 	if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
    556 		/* Make sure no card is still selected. */
    557 		(void)sdmmc_select_card(sc, NULL);
    558 	}
    559 
    560 	/* Turn off bus power and clock. */
    561 	(void)sdmmc_chip_bus_width(sc->sc_sct, sc->sc_sch, 1);
    562 	(void)sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_OFF);
    563 	(void)sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, 0);
    564 	sc->sc_busclk = sc->sc_clkmax;
    565 }
    566 
    567 /*
    568  * Set the lowest bus voltage supported by the card and the host.
    569  */
    570 int
    571 sdmmc_set_bus_power(struct sdmmc_softc *sc, uint32_t host_ocr,
    572     uint32_t card_ocr)
    573 {
    574 	uint32_t bit;
    575 
    576 	/* Mask off unsupported voltage levels and select the lowest. */
    577 	DPRINTF(1,("%s: host_ocr=%x ", DEVNAME(sc), host_ocr));
    578 	host_ocr &= card_ocr;
    579 	for (bit = 4; bit < 23; bit++) {
    580 		if (ISSET(host_ocr, (1 << bit))) {
    581 			host_ocr &= (3 << bit);
    582 			break;
    583 		}
    584 	}
    585 	DPRINTF(1,("card_ocr=%x new_ocr=%x\n", card_ocr, host_ocr));
    586 
    587 	if (host_ocr == 0 ||
    588 	    sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, host_ocr) != 0)
    589 		return 1;
    590 	return 0;
    591 }
    592 
    593 struct sdmmc_function *
    594 sdmmc_function_alloc(struct sdmmc_softc *sc)
    595 {
    596 	struct sdmmc_function *sf;
    597 
    598 	sf = malloc(sizeof *sf, M_DEVBUF, M_WAITOK|M_ZERO);
    599 	if (sf == NULL) {
    600 		aprint_error_dev(sc->sc_dev,
    601 		    "couldn't alloc memory (sdmmc function)\n");
    602 		return NULL;
    603 	}
    604 
    605 	sf->sc = sc;
    606 	sf->number = -1;
    607 	sf->cis.manufacturer = SDMMC_VENDOR_INVALID;
    608 	sf->cis.product = SDMMC_PRODUCT_INVALID;
    609 	sf->cis.function = SDMMC_FUNCTION_INVALID;
    610 	sf->width = 1;
    611 
    612 	if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
    613 	    ISSET(sc->sc_caps, SMC_CAPS_DMA) &&
    614 	    !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) {
    615 		bus_dma_segment_t ds;
    616 		int rseg, error;
    617 
    618 		error = bus_dmamap_create(sc->sc_dmat, SDMMC_SECTOR_SIZE, 1,
    619 		    SDMMC_SECTOR_SIZE, 0, BUS_DMA_WAITOK, &sf->bbuf_dmap);
    620 		if (error)
    621 			goto fail1;
    622 		error = bus_dmamem_alloc(sc->sc_dmat, SDMMC_SECTOR_SIZE,
    623 		    PAGE_SIZE, 0, &ds, 1, &rseg, BUS_DMA_WAITOK);
    624 		if (error)
    625 			goto fail2;
    626 		error = bus_dmamem_map(sc->sc_dmat, &ds, 1, SDMMC_SECTOR_SIZE,
    627 		    &sf->bbuf, BUS_DMA_WAITOK);
    628 		if (error)
    629 			goto fail3;
    630 		error = bus_dmamap_load(sc->sc_dmat, sf->bbuf_dmap,
    631 		    sf->bbuf, SDMMC_SECTOR_SIZE, NULL,
    632 		    BUS_DMA_WAITOK|BUS_DMA_READ|BUS_DMA_WRITE);
    633 		if (!error)
    634 			goto out;
    635 
    636 		bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, SDMMC_SECTOR_SIZE);
    637 fail3:
    638 		bus_dmamem_free(sc->sc_dmat, &ds, 1);
    639 fail2:
    640 		bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap);
    641 fail1:
    642 		free(sf, M_DEVBUF);
    643 		sf = NULL;
    644 	}
    645 out:
    646 
    647 	return sf;
    648 }
    649 
    650 void
    651 sdmmc_function_free(struct sdmmc_function *sf)
    652 {
    653 	struct sdmmc_softc *sc = sf->sc;
    654 
    655 	if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
    656 	    ISSET(sc->sc_caps, SMC_CAPS_DMA) &&
    657 	    !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) {
    658 		bus_dmamap_unload(sc->sc_dmat, sf->bbuf_dmap);
    659 		bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, SDMMC_SECTOR_SIZE);
    660 		bus_dmamem_free(sc->sc_dmat,
    661 		    sf->bbuf_dmap->dm_segs, sf->bbuf_dmap->dm_nsegs);
    662 		bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap);
    663 	}
    664 
    665 	free(sf, M_DEVBUF);
    666 }
    667 
    668 /*
    669  * Scan for I/O functions and memory cards on the bus, allocating a
    670  * sdmmc_function structure for each.
    671  */
    672 static int
    673 sdmmc_scan(struct sdmmc_softc *sc)
    674 {
    675 
    676 	if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
    677 		/* Scan for I/O functions. */
    678 		if (ISSET(sc->sc_flags, SMF_IO_MODE))
    679 			sdmmc_io_scan(sc);
    680 	}
    681 
    682 	/* Scan for memory cards on the bus. */
    683 	if (ISSET(sc->sc_flags, SMF_MEM_MODE))
    684 		sdmmc_mem_scan(sc);
    685 
    686 	/* There should be at least one function now. */
    687 	if (SIMPLEQ_EMPTY(&sc->sf_head)) {
    688 		aprint_error_dev(sc->sc_dev, "couldn't identify card\n");
    689 		return 1;
    690 	}
    691 	return 0;
    692 }
    693 
    694 /*
    695  * Initialize all the distinguished functions of the card, be it I/O
    696  * or memory functions.
    697  */
    698 static int
    699 sdmmc_init(struct sdmmc_softc *sc)
    700 {
    701 	struct sdmmc_function *sf;
    702 
    703 	/* Initialize all identified card functions. */
    704 	SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
    705 		if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
    706 			if (ISSET(sc->sc_flags, SMF_IO_MODE) &&
    707 			    sdmmc_io_init(sc, sf) != 0) {
    708 				aprint_error_dev(sc->sc_dev,
    709 				    "i/o init failed\n");
    710 			}
    711 		}
    712 
    713 		if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
    714 		    sdmmc_mem_init(sc, sf) != 0) {
    715 			aprint_error_dev(sc->sc_dev, "mem init failed\n");
    716 		}
    717 	}
    718 
    719 	/* Any good functions left after initialization? */
    720 	SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
    721 		if (!ISSET(sf->flags, SFF_ERROR))
    722 			return 0;
    723 	}
    724 
    725 	/* No, we should probably power down the card. */
    726 	return 1;
    727 }
    728 
    729 void
    730 sdmmc_delay(u_int usecs)
    731 {
    732 
    733 	delay(usecs);
    734 }
    735 
    736 int
    737 sdmmc_app_command(struct sdmmc_softc *sc, struct sdmmc_function *sf, struct sdmmc_command *cmd)
    738 {
    739 	struct sdmmc_command acmd;
    740 	int error;
    741 
    742 	DPRINTF(1,("sdmmc_app_command: start\n"));
    743 
    744 	/* Don't lock */
    745 
    746 	memset(&acmd, 0, sizeof(acmd));
    747 	acmd.c_opcode = MMC_APP_CMD;
    748 	if (sf != NULL) {
    749 		acmd.c_arg = sf->rca << 16;
    750 		acmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R1;
    751 	} else {
    752 		acmd.c_arg = 0;
    753 		acmd.c_flags = SCF_CMD_BCR | SCF_RSP_R1 | SCF_RSP_SPI_R1;
    754 	}
    755 
    756 	error = sdmmc_mmc_command(sc, &acmd);
    757 	if (error == 0) {
    758 		if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) &&
    759 		    !ISSET(MMC_R1(acmd.c_resp), MMC_R1_APP_CMD)) {
    760 			/* Card does not support application commands. */
    761 			error = ENODEV;
    762 		} else {
    763 			error = sdmmc_mmc_command(sc, cmd);
    764 		}
    765 	}
    766 	DPRINTF(1,("sdmmc_app_command: done (error=%d)\n", error));
    767 	return error;
    768 }
    769 
    770 /*
    771  * Execute MMC command and data transfers.  All interactions with the
    772  * host controller to complete the command happen in the context of
    773  * the current process.
    774  */
    775 int
    776 sdmmc_mmc_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
    777 {
    778 	int error;
    779 
    780 	DPRINTF(1,("sdmmc_mmc_command: cmd=%d, arg=%#x, flags=%#x\n",
    781 	    cmd->c_opcode, cmd->c_arg, cmd->c_flags));
    782 
    783 	/* Don't lock */
    784 
    785 #if defined(DIAGNOSTIC) || defined(SDMMC_DEBUG)
    786 	if (cmd->c_data && !ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
    787 		if (sc->sc_card == NULL)
    788 			panic("%s: deselected card\n", DEVNAME(sc));
    789 	}
    790 #endif
    791 
    792 	sdmmc_chip_exec_command(sc->sc_sct, sc->sc_sch, cmd);
    793 
    794 #ifdef SDMMC_DEBUG
    795 	sdmmc_dump_command(sc, cmd);
    796 #endif
    797 
    798 	error = cmd->c_error;
    799 
    800 	DPRINTF(1,("sdmmc_mmc_command: error=%d\n", error));
    801 
    802 	return error;
    803 }
    804 
    805 /*
    806  * Send the "GO IDLE STATE" command.
    807  */
    808 void
    809 sdmmc_go_idle_state(struct sdmmc_softc *sc)
    810 {
    811 	struct sdmmc_command cmd;
    812 
    813 	DPRINTF(1,("sdmmc_go_idle_state\n"));
    814 
    815 	/* Don't lock */
    816 
    817 	memset(&cmd, 0, sizeof(cmd));
    818 	cmd.c_opcode = MMC_GO_IDLE_STATE;
    819 	cmd.c_flags = SCF_CMD_BC | SCF_RSP_R0 | SCF_RSP_SPI_R1;
    820 
    821 	(void)sdmmc_mmc_command(sc, &cmd);
    822 }
    823 
    824 /*
    825  * Retrieve (SD) or set (MMC) the relative card address (RCA).
    826  */
    827 int
    828 sdmmc_set_relative_addr(struct sdmmc_softc *sc, struct sdmmc_function *sf)
    829 {
    830 	struct sdmmc_command cmd;
    831 	int error;
    832 
    833 	/* Don't lock */
    834 
    835 	if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
    836 		return EIO;
    837 
    838 	memset(&cmd, 0, sizeof(cmd));
    839 	if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
    840 		cmd.c_opcode = SD_SEND_RELATIVE_ADDR;
    841 		cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R6;
    842 	} else {
    843 		cmd.c_opcode = MMC_SET_RELATIVE_ADDR;
    844 		cmd.c_arg = MMC_ARG_RCA(sf->rca);
    845 		cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
    846 	}
    847 	error = sdmmc_mmc_command(sc, &cmd);
    848 	if (error)
    849 		return error;
    850 
    851 	if (ISSET(sc->sc_flags, SMF_SD_MODE))
    852 		sf->rca = SD_R6_RCA(cmd.c_resp);
    853 
    854 	return 0;
    855 }
    856 
    857 int
    858 sdmmc_select_card(struct sdmmc_softc *sc, struct sdmmc_function *sf)
    859 {
    860 	struct sdmmc_command cmd;
    861 	int error;
    862 
    863 	/* Don't lock */
    864 
    865 	if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
    866 		return EIO;
    867 
    868 	if (sc->sc_card == sf
    869 	 || (sf && sc->sc_card && sc->sc_card->rca == sf->rca)) {
    870 		sc->sc_card = sf;
    871 		return 0;
    872 	}
    873 
    874 	memset(&cmd, 0, sizeof(cmd));
    875 	cmd.c_opcode = MMC_SELECT_CARD;
    876 	cmd.c_arg = (sf == NULL) ? 0 : MMC_ARG_RCA(sf->rca);
    877 	cmd.c_flags = SCF_CMD_AC | ((sf == NULL) ? SCF_RSP_R0 : SCF_RSP_R1);
    878 	error = sdmmc_mmc_command(sc, &cmd);
    879 	if (error == 0 || sf == NULL)
    880 		sc->sc_card = sf;
    881 
    882 	return error;
    883 }
    884 
    885 #ifdef SDMMC_DEBUG
    886 static void
    887 sdmmc_dump_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
    888 {
    889 	int i;
    890 
    891 	DPRINTF(1,("%s: cmd %u arg=%#x data=%p dlen=%d flags=%#x (error %d)\n",
    892 	    DEVNAME(sc), cmd->c_opcode, cmd->c_arg, cmd->c_data,
    893 	    cmd->c_datalen, cmd->c_flags, cmd->c_error));
    894 
    895 	if (cmd->c_error || sdmmcdebug < 1)
    896 		return;
    897 
    898 	aprint_normal_dev(sc->sc_dev, "resp=");
    899 	if (ISSET(cmd->c_flags, SCF_RSP_136))
    900 		for (i = 0; i < sizeof cmd->c_resp; i++)
    901 			aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]);
    902 	else if (ISSET(cmd->c_flags, SCF_RSP_PRESENT))
    903 		for (i = 0; i < 4; i++)
    904 			aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]);
    905 	else
    906 		aprint_normal("none");
    907 	aprint_normal("\n");
    908 }
    909 
    910 void
    911 sdmmc_dump_data(const char *title, void *ptr, size_t size)
    912 {
    913 	char buf[16];
    914 	uint8_t *p = ptr;
    915 	int i, j;
    916 
    917 	printf("sdmmc_dump_data: %s\n", title ? title : "");
    918 	printf("--------+--------------------------------------------------+------------------+\n");
    919 	printf("offset  | +0 +1 +2 +3 +4 +5 +6 +7  +8 +9 +a +b +c +d +e +f | data             |\n");
    920 	printf("--------+--------------------------------------------------+------------------+\n");
    921 	for (i = 0; i < (int)size; i++) {
    922 		if ((i % 16) == 0) {
    923 			printf("%08x| ", i);
    924 		} else if ((i % 16) == 8) {
    925 			printf(" ");
    926 		}
    927 
    928 		printf("%02x ", p[i]);
    929 		buf[i % 16] = p[i];
    930 
    931 		if ((i % 16) == 15) {
    932 			printf("| ");
    933 			for (j = 0; j < 16; j++) {
    934 				if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
    935 					printf("%c", buf[j]);
    936 				} else {
    937 					printf(".");
    938 				}
    939 			}
    940 			printf(" |\n");
    941 		}
    942 	}
    943 	if ((i % 16) != 0) {
    944 		j = (i % 16);
    945 		for (; j < 16; j++) {
    946 			printf("   ");
    947 			if ((j % 16) == 8) {
    948 				printf(" ");
    949 			}
    950 		}
    951 
    952 		printf("| ");
    953 		for (j = 0; j < (i % 16); j++) {
    954 			if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
    955 				printf("%c", buf[j]);
    956 			} else {
    957 				printf(".");
    958 			}
    959 		}
    960 		for (; j < 16; j++) {
    961 			printf(" ");
    962 		}
    963 		printf(" |\n");
    964 	}
    965 	printf("--------+--------------------------------------------------+------------------+\n");
    966 }
    967 #endif
    968