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