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