sdmmc.c revision 1.30
1 /* $NetBSD: sdmmc.c,v 1.30 2015/08/09 13:14:11 mlelstv 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.30 2015/08/09 13:14:11 mlelstv 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 = 0; 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 SIMPLEQ_INIT(&sc->sf_head); 145 TAILQ_INIT(&sc->sc_tskq); 146 TAILQ_INIT(&sc->sc_intrq); 147 148 sdmmc_init_task(&sc->sc_discover_task, sdmmc_discover_task, sc); 149 sdmmc_init_task(&sc->sc_intr_task, sdmmc_intr_task, sc); 150 151 mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE); 152 mutex_init(&sc->sc_tskq_mtx, MUTEX_DEFAULT, IPL_SDMMC); 153 mutex_init(&sc->sc_discover_task_mtx, MUTEX_DEFAULT, IPL_SDMMC); 154 mutex_init(&sc->sc_intr_task_mtx, MUTEX_DEFAULT, IPL_SDMMC); 155 cv_init(&sc->sc_tskq_cv, "mmctaskq"); 156 157 if (ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) { 158 callout_init(&sc->sc_card_detect_ch, 0); 159 callout_reset(&sc->sc_card_detect_ch, hz, 160 sdmmc_polling_card, sc); 161 } 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(self); 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 if (ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) { 202 callout_halt(&sc->sc_card_detect_ch, NULL); 203 callout_destroy(&sc->sc_card_detect_ch); 204 } 205 206 cv_destroy(&sc->sc_tskq_cv); 207 mutex_destroy(&sc->sc_intr_task_mtx); 208 mutex_destroy(&sc->sc_discover_task_mtx); 209 mutex_destroy(&sc->sc_tskq_mtx); 210 mutex_destroy(&sc->sc_mtx); 211 212 return 0; 213 } 214 215 static void 216 sdmmc_doattach(device_t dev) 217 { 218 struct sdmmc_softc *sc = device_private(dev); 219 220 if (kthread_create(PRI_BIO, 0, NULL, 221 sdmmc_task_thread, sc, &sc->sc_tskq_lwp, "%s", device_xname(dev))) { 222 aprint_error_dev(dev, "couldn't create task thread\n"); 223 } 224 } 225 226 void 227 sdmmc_add_task(struct sdmmc_softc *sc, struct sdmmc_task *task) 228 { 229 230 mutex_enter(&sc->sc_tskq_mtx); 231 task->onqueue = 1; 232 task->sc = sc; 233 TAILQ_INSERT_TAIL(&sc->sc_tskq, task, next); 234 cv_broadcast(&sc->sc_tskq_cv); 235 mutex_exit(&sc->sc_tskq_mtx); 236 } 237 238 static inline void 239 sdmmc_del_task1(struct sdmmc_softc *sc, struct sdmmc_task *task) 240 { 241 242 TAILQ_REMOVE(&sc->sc_tskq, task, next); 243 task->sc = NULL; 244 task->onqueue = 0; 245 } 246 247 void 248 sdmmc_del_task(struct sdmmc_task *task) 249 { 250 struct sdmmc_softc *sc = (struct sdmmc_softc *)task->sc; 251 252 if (sc != NULL) { 253 mutex_enter(&sc->sc_tskq_mtx); 254 sdmmc_del_task1(sc, task); 255 mutex_exit(&sc->sc_tskq_mtx); 256 } 257 } 258 259 static void 260 sdmmc_task_thread(void *arg) 261 { 262 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg; 263 struct sdmmc_task *task; 264 265 sdmmc_discover_task(sc); 266 config_pending_decr(sc->sc_dev); 267 268 mutex_enter(&sc->sc_tskq_mtx); 269 for (;;) { 270 task = TAILQ_FIRST(&sc->sc_tskq); 271 if (task != NULL) { 272 sdmmc_del_task1(sc, task); 273 mutex_exit(&sc->sc_tskq_mtx); 274 (*task->func)(task->arg); 275 mutex_enter(&sc->sc_tskq_mtx); 276 } else { 277 /* Check for the exit condition. */ 278 if (sc->sc_dying) 279 break; 280 cv_wait(&sc->sc_tskq_cv, &sc->sc_tskq_mtx); 281 } 282 } 283 /* time to die. */ 284 sc->sc_dying = 0; 285 if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) { 286 /* 287 * sdmmc_card_detach() may issue commands, 288 * so temporarily drop the interrupt-blocking lock. 289 */ 290 mutex_exit(&sc->sc_tskq_mtx); 291 sdmmc_card_detach(sc, DETACH_FORCE); 292 mutex_enter(&sc->sc_tskq_mtx); 293 } 294 sc->sc_tskq_lwp = NULL; 295 cv_broadcast(&sc->sc_tskq_cv); 296 mutex_exit(&sc->sc_tskq_mtx); 297 kthread_exit(0); 298 } 299 300 void 301 sdmmc_needs_discover(device_t dev) 302 { 303 struct sdmmc_softc *sc = device_private(dev); 304 305 if (!ISSET(sc->sc_flags, SMF_INITED)) 306 return; 307 308 mutex_enter(&sc->sc_discover_task_mtx); 309 if (!sdmmc_task_pending(&sc->sc_discover_task)) 310 sdmmc_add_task(sc, &sc->sc_discover_task); 311 mutex_exit(&sc->sc_discover_task_mtx); 312 } 313 314 static void 315 sdmmc_discover_task(void *arg) 316 { 317 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg; 318 int card_detect, card_present; 319 320 mutex_enter(&sc->sc_discover_task_mtx); 321 card_detect = sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch); 322 card_present = ISSET(sc->sc_flags, SMF_CARD_PRESENT); 323 if (card_detect) 324 SET(sc->sc_flags, SMF_CARD_PRESENT); 325 else 326 CLR(sc->sc_flags, SMF_CARD_PRESENT); 327 mutex_exit(&sc->sc_discover_task_mtx); 328 329 if (card_detect) { 330 if (!card_present) { 331 sdmmc_card_attach(sc); 332 mutex_enter(&sc->sc_discover_task_mtx); 333 if (!ISSET(sc->sc_flags, SMF_CARD_ATTACHED)) 334 CLR(sc->sc_flags, SMF_CARD_PRESENT); 335 mutex_exit(&sc->sc_discover_task_mtx); 336 } 337 } else { 338 if (card_present) 339 sdmmc_card_detach(sc, DETACH_FORCE); 340 } 341 } 342 343 static void 344 sdmmc_polling_card(void *arg) 345 { 346 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg; 347 int card_detect, card_present; 348 349 mutex_enter(&sc->sc_discover_task_mtx); 350 card_detect = sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch); 351 card_present = ISSET(sc->sc_flags, SMF_CARD_PRESENT); 352 mutex_exit(&sc->sc_discover_task_mtx); 353 354 if (card_detect != card_present) 355 sdmmc_needs_discover(sc->sc_dev); 356 357 callout_schedule(&sc->sc_card_detect_ch, hz); 358 } 359 360 /* 361 * Called from process context when a card is present. 362 */ 363 static void 364 sdmmc_card_attach(struct sdmmc_softc *sc) 365 { 366 struct sdmmc_function *sf; 367 struct sdmmc_attach_args saa; 368 int error; 369 370 DPRINTF(1,("%s: attach card\n", DEVNAME(sc))); 371 372 CLR(sc->sc_flags, SMF_CARD_ATTACHED); 373 374 /* 375 * Power up the card (or card stack). 376 */ 377 error = sdmmc_enable(sc); 378 if (error) { 379 if (!ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) { 380 aprint_error_dev(sc->sc_dev, "couldn't enable card: %d\n", error); 381 } 382 goto err; 383 } 384 385 /* 386 * Scan for I/O functions and memory cards on the bus, 387 * allocating a sdmmc_function structure for each. 388 */ 389 error = sdmmc_scan(sc); 390 if (error) { 391 aprint_error_dev(sc->sc_dev, "no functions\n"); 392 goto err; 393 } 394 395 /* 396 * Initialize the I/O functions and memory cards. 397 */ 398 error = sdmmc_init(sc); 399 if (error) { 400 aprint_error_dev(sc->sc_dev, "init failed\n"); 401 goto err; 402 } 403 404 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) { 405 if (ISSET(sc->sc_flags, SMF_IO_MODE) && sf->number < 1) 406 continue; 407 408 memset(&saa, 0, sizeof saa); 409 saa.manufacturer = sf->cis.manufacturer; 410 saa.product = sf->cis.product; 411 saa.interface = sf->interface; 412 saa.sf = sf; 413 414 sf->child = 415 config_found_ia(sc->sc_dev, "sdmmc", &saa, sdmmc_print); 416 } 417 418 SET(sc->sc_flags, SMF_CARD_ATTACHED); 419 return; 420 421 err: 422 sdmmc_card_detach(sc, DETACH_FORCE); 423 } 424 425 /* 426 * Called from process context with DETACH_* flags from <sys/device.h> 427 * when cards are gone. 428 */ 429 static void 430 sdmmc_card_detach(struct sdmmc_softc *sc, int flags) 431 { 432 struct sdmmc_function *sf, *sfnext; 433 434 DPRINTF(1,("%s: detach card\n", DEVNAME(sc))); 435 436 if (ISSET(sc->sc_flags, SMF_CARD_ATTACHED)) { 437 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) { 438 if (sf->child != NULL) { 439 config_detach(sf->child, DETACH_FORCE); 440 sf->child = NULL; 441 } 442 } 443 444 KASSERT(TAILQ_EMPTY(&sc->sc_intrq)); 445 446 CLR(sc->sc_flags, SMF_CARD_ATTACHED); 447 } 448 449 /* Power down. */ 450 sdmmc_disable(sc); 451 452 /* Free all sdmmc_function structures. */ 453 for (sf = SIMPLEQ_FIRST(&sc->sf_head); sf != NULL; sf = sfnext) { 454 sfnext = SIMPLEQ_NEXT(sf, sf_list); 455 sdmmc_function_free(sf); 456 } 457 SIMPLEQ_INIT(&sc->sf_head); 458 sc->sc_function_count = 0; 459 sc->sc_fn0 = NULL; 460 } 461 462 static int 463 sdmmc_print(void *aux, const char *pnp) 464 { 465 struct sdmmc_attach_args *sa = aux; 466 struct sdmmc_function *sf = sa->sf; 467 struct sdmmc_cis *cis = &sf->sc->sc_fn0->cis; 468 int i, x; 469 470 if (pnp) { 471 if (sf->number == 0) 472 return QUIET; 473 474 for (i = 0; i < 4 && cis->cis1_info[i]; i++) 475 printf("%s%s", i ? ", " : "\"", cis->cis1_info[i]); 476 if (i != 0) 477 printf("\""); 478 479 if ((cis->manufacturer != SDMMC_VENDOR_INVALID && 480 cis->product != SDMMC_PRODUCT_INVALID) || 481 sa->interface != SD_IO_SFIC_NO_STANDARD) { 482 x = !!(cis->manufacturer != SDMMC_VENDOR_INVALID); 483 x += !!(cis->product != SDMMC_PRODUCT_INVALID); 484 x += !!(sa->interface != SD_IO_SFIC_NO_STANDARD); 485 printf("%s(", i ? " " : ""); 486 if (cis->manufacturer != SDMMC_VENDOR_INVALID) 487 printf("manufacturer 0x%x%s", 488 cis->manufacturer, (--x == 0) ? "" : ", "); 489 if (cis->product != SDMMC_PRODUCT_INVALID) 490 printf("product 0x%x%s", 491 cis->product, (--x == 0) ? "" : ", "); 492 if (sa->interface != SD_IO_SFIC_NO_STANDARD) 493 printf("standard function interface code 0x%x", 494 sf->interface); 495 printf(")"); 496 } 497 printf("%sat %s", i ? " " : "", pnp); 498 } 499 if (sf->number > 0) 500 printf(" function %d", sf->number); 501 502 if (!pnp) { 503 for (i = 0; i < 3 && cis->cis1_info[i]; i++) 504 printf("%s%s", i ? ", " : " \"", cis->cis1_info[i]); 505 if (i != 0) 506 printf("\""); 507 } 508 return UNCONF; 509 } 510 511 static int 512 sdmmc_enable(struct sdmmc_softc *sc) 513 { 514 int error; 515 516 /* 517 * Calculate the equivalent of the card OCR from the host 518 * capabilities and select the maximum supported bus voltage. 519 */ 520 error = sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, 521 sdmmc_chip_host_ocr(sc->sc_sct, sc->sc_sch)); 522 if (error) { 523 aprint_error_dev(sc->sc_dev, "couldn't supply bus power\n"); 524 goto out; 525 } 526 527 /* 528 * Select the minimum clock frequency. 529 */ 530 error = sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_400K, 531 false); 532 if (error) { 533 aprint_error_dev(sc->sc_dev, "couldn't supply clock\n"); 534 goto out; 535 } 536 537 /* XXX wait for card to power up */ 538 sdmmc_delay(100000); 539 540 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 541 /* Initialize SD I/O card function(s). */ 542 error = sdmmc_io_enable(sc); 543 if (error) { 544 DPRINTF(1, ("%s: sdmmc_io_enable failed %d\n", DEVNAME(sc), error)); 545 goto out; 546 } 547 } 548 549 /* Initialize SD/MMC memory card(s). */ 550 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) || 551 ISSET(sc->sc_flags, SMF_MEM_MODE)) { 552 error = sdmmc_mem_enable(sc); 553 if (error) { 554 DPRINTF(1, ("%s: sdmmc_mem_enable failed %d\n", DEVNAME(sc), error)); 555 goto out; 556 } 557 } 558 559 out: 560 if (error) 561 sdmmc_disable(sc); 562 return error; 563 } 564 565 static void 566 sdmmc_disable(struct sdmmc_softc *sc) 567 { 568 /* XXX complete commands if card is still present. */ 569 570 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 571 /* Make sure no card is still selected. */ 572 (void)sdmmc_select_card(sc, NULL); 573 } 574 575 /* Turn off bus power and clock. */ 576 (void)sdmmc_chip_bus_width(sc->sc_sct, sc->sc_sch, 1); 577 (void)sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_OFF, 578 false); 579 (void)sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, 0); 580 sc->sc_busclk = sc->sc_clkmax; 581 } 582 583 /* 584 * Set the lowest bus voltage supported by the card and the host. 585 */ 586 int 587 sdmmc_set_bus_power(struct sdmmc_softc *sc, uint32_t host_ocr, 588 uint32_t card_ocr) 589 { 590 uint32_t bit; 591 592 /* Mask off unsupported voltage levels and select the lowest. */ 593 DPRINTF(1,("%s: host_ocr=%x ", DEVNAME(sc), host_ocr)); 594 host_ocr &= card_ocr; 595 for (bit = 4; bit < 23; bit++) { 596 if (ISSET(host_ocr, (1 << bit))) { 597 host_ocr &= (3 << bit); 598 break; 599 } 600 } 601 DPRINTF(1,("card_ocr=%x new_ocr=%x\n", card_ocr, host_ocr)); 602 603 if (host_ocr == 0 || 604 sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, host_ocr) != 0) 605 return 1; 606 return 0; 607 } 608 609 struct sdmmc_function * 610 sdmmc_function_alloc(struct sdmmc_softc *sc) 611 { 612 struct sdmmc_function *sf; 613 614 sf = malloc(sizeof *sf, M_DEVBUF, M_WAITOK|M_ZERO); 615 if (sf == NULL) { 616 aprint_error_dev(sc->sc_dev, 617 "couldn't alloc memory (sdmmc function)\n"); 618 return NULL; 619 } 620 621 sf->sc = sc; 622 sf->number = -1; 623 sf->cis.manufacturer = SDMMC_VENDOR_INVALID; 624 sf->cis.product = SDMMC_PRODUCT_INVALID; 625 sf->cis.function = SDMMC_FUNCTION_INVALID; 626 sf->width = 1; 627 628 if (ISSET(sc->sc_flags, SMF_MEM_MODE) && 629 ISSET(sc->sc_caps, SMC_CAPS_DMA) && 630 !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) { 631 bus_dma_segment_t ds; 632 int rseg, error; 633 634 error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, 1, 635 MAXPHYS, 0, BUS_DMA_WAITOK, &sf->bbuf_dmap); 636 if (error) 637 goto fail1; 638 error = bus_dmamem_alloc(sc->sc_dmat, MAXPHYS, 639 PAGE_SIZE, 0, &ds, 1, &rseg, BUS_DMA_WAITOK); 640 if (error) 641 goto fail2; 642 error = bus_dmamem_map(sc->sc_dmat, &ds, 1, MAXPHYS, 643 &sf->bbuf, BUS_DMA_WAITOK); 644 if (error) 645 goto fail3; 646 error = bus_dmamap_load(sc->sc_dmat, sf->bbuf_dmap, 647 sf->bbuf, MAXPHYS, NULL, 648 BUS_DMA_WAITOK|BUS_DMA_READ|BUS_DMA_WRITE); 649 if (error) 650 goto fail4; 651 error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, 1, 652 MAXPHYS, 0, BUS_DMA_WAITOK, &sf->sseg_dmap); 653 if (!error) 654 goto out; 655 656 bus_dmamap_unload(sc->sc_dmat, sf->bbuf_dmap); 657 fail4: 658 bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, MAXPHYS); 659 fail3: 660 bus_dmamem_free(sc->sc_dmat, &ds, 1); 661 fail2: 662 bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap); 663 fail1: 664 free(sf, M_DEVBUF); 665 sf = NULL; 666 } 667 out: 668 669 return sf; 670 } 671 672 void 673 sdmmc_function_free(struct sdmmc_function *sf) 674 { 675 struct sdmmc_softc *sc = sf->sc; 676 677 if (ISSET(sc->sc_flags, SMF_MEM_MODE) && 678 ISSET(sc->sc_caps, SMC_CAPS_DMA) && 679 !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) { 680 bus_dmamap_destroy(sc->sc_dmat, sf->sseg_dmap); 681 bus_dmamap_unload(sc->sc_dmat, sf->bbuf_dmap); 682 bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, MAXPHYS); 683 bus_dmamem_free(sc->sc_dmat, 684 sf->bbuf_dmap->dm_segs, sf->bbuf_dmap->dm_nsegs); 685 bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap); 686 } 687 688 free(sf, M_DEVBUF); 689 } 690 691 /* 692 * Scan for I/O functions and memory cards on the bus, allocating a 693 * sdmmc_function structure for each. 694 */ 695 static int 696 sdmmc_scan(struct sdmmc_softc *sc) 697 { 698 699 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 700 /* Scan for I/O functions. */ 701 if (ISSET(sc->sc_flags, SMF_IO_MODE)) 702 sdmmc_io_scan(sc); 703 } 704 705 /* Scan for memory cards on the bus. */ 706 if (ISSET(sc->sc_flags, SMF_MEM_MODE)) 707 sdmmc_mem_scan(sc); 708 709 /* There should be at least one function now. */ 710 if (SIMPLEQ_EMPTY(&sc->sf_head)) { 711 aprint_error_dev(sc->sc_dev, "couldn't identify card\n"); 712 return 1; 713 } 714 return 0; 715 } 716 717 /* 718 * Initialize all the distinguished functions of the card, be it I/O 719 * or memory functions. 720 */ 721 static int 722 sdmmc_init(struct sdmmc_softc *sc) 723 { 724 struct sdmmc_function *sf; 725 726 /* Initialize all identified card functions. */ 727 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) { 728 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 729 if (ISSET(sc->sc_flags, SMF_IO_MODE) && 730 sdmmc_io_init(sc, sf) != 0) { 731 aprint_error_dev(sc->sc_dev, 732 "i/o init failed\n"); 733 } 734 } 735 736 if (ISSET(sc->sc_flags, SMF_MEM_MODE) && 737 sdmmc_mem_init(sc, sf) != 0) { 738 aprint_error_dev(sc->sc_dev, "mem init failed\n"); 739 } 740 } 741 742 /* Any good functions left after initialization? */ 743 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) { 744 if (!ISSET(sf->flags, SFF_ERROR)) 745 return 0; 746 } 747 748 /* No, we should probably power down the card. */ 749 return 1; 750 } 751 752 void 753 sdmmc_delay(u_int usecs) 754 { 755 756 delay(usecs); 757 } 758 759 int 760 sdmmc_app_command(struct sdmmc_softc *sc, struct sdmmc_function *sf, struct sdmmc_command *cmd) 761 { 762 struct sdmmc_command acmd; 763 int error; 764 765 DPRINTF(1,("sdmmc_app_command: start\n")); 766 767 /* Don't lock */ 768 769 memset(&acmd, 0, sizeof(acmd)); 770 acmd.c_opcode = MMC_APP_CMD; 771 acmd.c_arg = (sf != NULL) ? (sf->rca << 16) : 0; 772 acmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R1; 773 774 error = sdmmc_mmc_command(sc, &acmd); 775 if (error == 0) { 776 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) && 777 !ISSET(MMC_R1(acmd.c_resp), MMC_R1_APP_CMD)) { 778 /* Card does not support application commands. */ 779 error = ENODEV; 780 } else { 781 error = sdmmc_mmc_command(sc, cmd); 782 } 783 } 784 DPRINTF(1,("sdmmc_app_command: done (error=%d)\n", error)); 785 return error; 786 } 787 788 /* 789 * Execute MMC command and data transfers. All interactions with the 790 * host controller to complete the command happen in the context of 791 * the current process. 792 */ 793 int 794 sdmmc_mmc_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd) 795 { 796 int error; 797 798 DPRINTF(1,("sdmmc_mmc_command: cmd=%d, arg=%#x, flags=%#x\n", 799 cmd->c_opcode, cmd->c_arg, cmd->c_flags)); 800 801 /* Don't lock */ 802 803 #if defined(DIAGNOSTIC) || defined(SDMMC_DEBUG) 804 if (cmd->c_data && !ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 805 if (sc->sc_card == NULL) 806 panic("%s: deselected card\n", DEVNAME(sc)); 807 } 808 #endif 809 810 sdmmc_chip_exec_command(sc->sc_sct, sc->sc_sch, cmd); 811 812 #ifdef SDMMC_DEBUG 813 sdmmc_dump_command(sc, cmd); 814 #endif 815 816 error = cmd->c_error; 817 818 DPRINTF(1,("sdmmc_mmc_command: error=%d\n", error)); 819 820 return error; 821 } 822 823 /* 824 * Send the "GO IDLE STATE" command. 825 */ 826 void 827 sdmmc_go_idle_state(struct sdmmc_softc *sc) 828 { 829 struct sdmmc_command cmd; 830 831 DPRINTF(1,("sdmmc_go_idle_state\n")); 832 833 /* Don't lock */ 834 835 memset(&cmd, 0, sizeof(cmd)); 836 cmd.c_opcode = MMC_GO_IDLE_STATE; 837 cmd.c_flags = SCF_CMD_BC | SCF_RSP_R0 | SCF_RSP_SPI_R1; 838 839 (void)sdmmc_mmc_command(sc, &cmd); 840 } 841 842 /* 843 * Retrieve (SD) or set (MMC) the relative card address (RCA). 844 */ 845 int 846 sdmmc_set_relative_addr(struct sdmmc_softc *sc, struct sdmmc_function *sf) 847 { 848 struct sdmmc_command cmd; 849 int error; 850 851 /* Don't lock */ 852 853 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 854 aprint_error_dev(sc->sc_dev, 855 "sdmmc_set_relative_addr: SMC_CAPS_SPI_MODE set"); 856 return EIO; 857 } 858 859 memset(&cmd, 0, sizeof(cmd)); 860 if (ISSET(sc->sc_flags, SMF_SD_MODE)) { 861 cmd.c_opcode = SD_SEND_RELATIVE_ADDR; 862 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R6; 863 } else { 864 cmd.c_opcode = MMC_SET_RELATIVE_ADDR; 865 cmd.c_arg = MMC_ARG_RCA(sf->rca); 866 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1; 867 } 868 error = sdmmc_mmc_command(sc, &cmd); 869 if (error) 870 return error; 871 872 if (ISSET(sc->sc_flags, SMF_SD_MODE)) 873 sf->rca = SD_R6_RCA(cmd.c_resp); 874 875 return 0; 876 } 877 878 int 879 sdmmc_select_card(struct sdmmc_softc *sc, struct sdmmc_function *sf) 880 { 881 struct sdmmc_command cmd; 882 int error; 883 884 /* Don't lock */ 885 886 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) { 887 aprint_error_dev(sc->sc_dev, 888 "sdmmc_select_card: SMC_CAPS_SPI_MODE set"); 889 return EIO; 890 } 891 892 if (sc->sc_card == sf 893 || (sf && sc->sc_card && sc->sc_card->rca == sf->rca)) { 894 sc->sc_card = sf; 895 return 0; 896 } 897 898 memset(&cmd, 0, sizeof(cmd)); 899 cmd.c_opcode = MMC_SELECT_CARD; 900 cmd.c_arg = (sf == NULL) ? 0 : MMC_ARG_RCA(sf->rca); 901 cmd.c_flags = SCF_CMD_AC | ((sf == NULL) ? SCF_RSP_R0 : SCF_RSP_R1); 902 error = sdmmc_mmc_command(sc, &cmd); 903 if (error == 0 || sf == NULL) 904 sc->sc_card = sf; 905 906 return error; 907 } 908 909 #ifdef SDMMC_DEBUG 910 static void 911 sdmmc_dump_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd) 912 { 913 int i; 914 915 DPRINTF(1,("%s: cmd %u arg=%#x data=%p dlen=%d flags=%#x (error %d)\n", 916 DEVNAME(sc), cmd->c_opcode, cmd->c_arg, cmd->c_data, 917 cmd->c_datalen, cmd->c_flags, cmd->c_error)); 918 919 if (cmd->c_error || sdmmcdebug < 1) 920 return; 921 922 aprint_normal_dev(sc->sc_dev, "resp="); 923 if (ISSET(cmd->c_flags, SCF_RSP_136)) 924 for (i = 0; i < sizeof cmd->c_resp; i++) 925 aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]); 926 else if (ISSET(cmd->c_flags, SCF_RSP_PRESENT)) 927 for (i = 0; i < 4; i++) 928 aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]); 929 else 930 aprint_normal("none"); 931 aprint_normal("\n"); 932 } 933 934 void 935 sdmmc_dump_data(const char *title, void *ptr, size_t size) 936 { 937 char buf[16]; 938 uint8_t *p = ptr; 939 int i, j; 940 941 printf("sdmmc_dump_data: %s\n", title ? title : ""); 942 printf("--------+--------------------------------------------------+------------------+\n"); 943 printf("offset | +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +a +b +c +d +e +f | data |\n"); 944 printf("--------+--------------------------------------------------+------------------+\n"); 945 for (i = 0; i < (int)size; i++) { 946 if ((i % 16) == 0) { 947 printf("%08x| ", i); 948 } else if ((i % 16) == 8) { 949 printf(" "); 950 } 951 952 printf("%02x ", p[i]); 953 buf[i % 16] = p[i]; 954 955 if ((i % 16) == 15) { 956 printf("| "); 957 for (j = 0; j < 16; j++) { 958 if (buf[j] >= 0x20 && buf[j] <= 0x7e) { 959 printf("%c", buf[j]); 960 } else { 961 printf("."); 962 } 963 } 964 printf(" |\n"); 965 } 966 } 967 if ((i % 16) != 0) { 968 j = (i % 16); 969 for (; j < 16; j++) { 970 printf(" "); 971 if ((j % 16) == 8) { 972 printf(" "); 973 } 974 } 975 976 printf("| "); 977 for (j = 0; j < (i % 16); j++) { 978 if (buf[j] >= 0x20 && buf[j] <= 0x7e) { 979 printf("%c", buf[j]); 980 } else { 981 printf("."); 982 } 983 } 984 for (; j < 16; j++) { 985 printf(" "); 986 } 987 printf(" |\n"); 988 } 989 printf("--------+--------------------------------------------------+------------------+\n"); 990 } 991 #endif 992
Indexes created Mon Sep 22 10:09:38 GMT 2025