1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2020 Alstom Group. 5 * Copyright (c) 2020 Semihalf. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 /* eSDHC controller driver for NXP QorIQ Layerscape SoCs. */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 #include <sys/endian.h> 36 #include <sys/kernel.h> 37 #include <sys/module.h> 38 #include <sys/rman.h> 39 #include <sys/sysctl.h> 40 #include <sys/taskqueue.h> 41 42 #include <machine/bus.h> 43 #include <machine/resource.h> 44 45 #include <dev/extres/clk/clk.h> 46 #include <dev/mmc/bridge.h> 47 #include <dev/mmc/mmcbrvar.h> 48 #include <dev/ofw/ofw_bus.h> 49 #include <dev/ofw/ofw_bus_subr.h> 50 #include <dev/sdhci/sdhci.h> 51 #include <dev/sdhci/sdhci_fdt_gpio.h> 52 53 #include "mmcbr_if.h" 54 #include "sdhci_if.h" 55 56 #define RD4 (sc->read) 57 #define WR4 (sc->write) 58 59 #define SDHCI_FSL_PRES_STATE 0x24 60 #define SDHCI_FSL_PRES_SDSTB (1 << 3) 61 #define SDHCI_FSL_PRES_COMPAT_MASK 0x000f0f07 62 63 #define SDHCI_FSL_PROT_CTRL 0x28 64 #define SDHCI_FSL_PROT_CTRL_WIDTH_1BIT (0 << 1) 65 #define SDHCI_FSL_PROT_CTRL_WIDTH_4BIT (1 << 1) 66 #define SDHCI_FSL_PROT_CTRL_WIDTH_8BIT (2 << 1) 67 #define SDHCI_FSL_PROT_CTRL_WIDTH_MASK (3 << 1) 68 #define SDHCI_FSL_PROT_CTRL_BYTE_SWAP (0 << 4) 69 #define SDHCI_FSL_PROT_CTRL_BYTE_NATIVE (2 << 4) 70 #define SDHCI_FSL_PROT_CTRL_BYTE_MASK (3 << 4) 71 #define SDHCI_FSL_PROT_CTRL_DMA_MASK (3 << 8) 72 73 #define SDHCI_FSL_SYS_CTRL 0x2c 74 #define SDHCI_FSL_CLK_IPGEN (1 << 0) 75 #define SDHCI_FSL_CLK_SDCLKEN (1 << 3) 76 #define SDHCI_FSL_CLK_DIVIDER_MASK 0x000000f0 77 #define SDHCI_FSL_CLK_DIVIDER_SHIFT 4 78 #define SDHCI_FSL_CLK_PRESCALE_MASK 0x0000ff00 79 #define SDHCI_FSL_CLK_PRESCALE_SHIFT 8 80 81 #define SDHCI_FSL_WTMK_LVL 0x44 82 #define SDHCI_FSL_WTMK_RD_512B (0 << 0) 83 #define SDHCI_FSL_WTMK_WR_512B (0 << 15) 84 85 #define SDHCI_FSL_HOST_VERSION 0xfc 86 #define SDHCI_FSL_CAPABILITIES2 0x114 87 88 #define SDHCI_FSL_ESDHC_CTRL 0x40c 89 #define SDHCI_FSL_ESDHC_CTRL_SNOOP (1 << 6) 90 #define SDHCI_FSL_ESDHC_CTRL_CLK_DIV2 (1 << 19) 91 92 struct sdhci_fsl_fdt_softc { 93 device_t dev; 94 const struct sdhci_fsl_fdt_soc_data *soc_data; 95 struct resource *mem_res; 96 struct resource *irq_res; 97 void *irq_cookie; 98 uint32_t baseclk_hz; 99 struct sdhci_fdt_gpio *gpio; 100 struct sdhci_slot slot; 101 bool slot_init_done; 102 uint32_t cmd_and_mode; 103 uint16_t sdclk_bits; 104 105 uint32_t (* read)(struct sdhci_fsl_fdt_softc *, bus_size_t); 106 void (* write)(struct sdhci_fsl_fdt_softc *, bus_size_t, uint32_t); 107 }; 108 109 struct sdhci_fsl_fdt_soc_data { 110 int quirks; 111 }; 112 113 static const struct sdhci_fsl_fdt_soc_data sdhci_fsl_fdt_ls1046a_soc_data = { 114 .quirks = SDHCI_QUIRK_DONT_SET_HISPD_BIT | SDHCI_QUIRK_BROKEN_AUTO_STOP 115 }; 116 117 static const struct sdhci_fsl_fdt_soc_data sdhci_fsl_fdt_gen_data = { 118 .quirks = 0, 119 }; 120 121 static const struct ofw_compat_data sdhci_fsl_fdt_compat_data[] = { 122 {"fsl,ls1046a-esdhc", (uintptr_t)&sdhci_fsl_fdt_ls1046a_soc_data}, 123 {"fsl,esdhc", (uintptr_t)&sdhci_fsl_fdt_gen_data}, 124 {NULL, 0} 125 }; 126 127 static uint32_t 128 read_be(struct sdhci_fsl_fdt_softc *sc, bus_size_t off) 129 { 130 131 return (be32toh(bus_read_4(sc->mem_res, off))); 132 } 133 134 static void 135 write_be(struct sdhci_fsl_fdt_softc *sc, bus_size_t off, uint32_t val) 136 { 137 138 bus_write_4(sc->mem_res, off, htobe32(val)); 139 } 140 141 static uint32_t 142 read_le(struct sdhci_fsl_fdt_softc *sc, bus_size_t off) 143 { 144 145 return (bus_read_4(sc->mem_res, off)); 146 } 147 148 static void 149 write_le(struct sdhci_fsl_fdt_softc *sc, bus_size_t off, uint32_t val) 150 { 151 152 bus_write_4(sc->mem_res, off, val); 153 } 154 155 156 static uint16_t 157 sdhci_fsl_fdt_get_clock(struct sdhci_fsl_fdt_softc *sc) 158 { 159 uint16_t val; 160 161 val = sc->sdclk_bits | SDHCI_CLOCK_INT_EN; 162 if (RD4(sc, SDHCI_FSL_PRES_STATE) & SDHCI_FSL_PRES_SDSTB) 163 val |= SDHCI_CLOCK_INT_STABLE; 164 if (RD4(sc, SDHCI_FSL_SYS_CTRL) & SDHCI_FSL_CLK_SDCLKEN) 165 val |= SDHCI_CLOCK_CARD_EN; 166 167 return (val); 168 } 169 170 static void 171 fsl_sdhc_fdt_set_clock(struct sdhci_fsl_fdt_softc *sc, uint16_t val) 172 { 173 uint32_t div, freq, prescale, val32; 174 175 sc->sdclk_bits = val & SDHCI_DIVIDERS_MASK; 176 val32 = RD4(sc, SDHCI_CLOCK_CONTROL); 177 178 if ((val & SDHCI_CLOCK_CARD_EN) == 0) { 179 WR4(sc, SDHCI_CLOCK_CONTROL, val32 & ~SDHCI_FSL_CLK_SDCLKEN); 180 return; 181 } 182 183 div = ((val >> SDHCI_DIVIDER_SHIFT) & SDHCI_DIVIDER_MASK) | 184 ((val >> SDHCI_DIVIDER_HI_SHIFT) & SDHCI_DIVIDER_HI_MASK) << 185 SDHCI_DIVIDER_MASK_LEN; 186 if (div == 0) 187 freq = sc->baseclk_hz; 188 else 189 freq = sc->baseclk_hz / (2 * div); 190 191 for (prescale = 2; freq < sc->baseclk_hz / (prescale * 16); ) 192 prescale <<= 1; 193 for (div = 1; freq < sc->baseclk_hz / (prescale * div); ) 194 ++div; 195 196 #ifdef DEBUG 197 device_printf(sc->dev, 198 "Desired SD/MMC freq: %d, actual: %d; base %d prescale %d divisor %d\n", 199 freq, sc->baseclk_hz / (prescale * div), 200 sc->baseclk_hz, prescale, div); 201 #endif 202 203 prescale >>= 1; 204 div -= 1; 205 206 val32 &= ~(SDHCI_FSL_CLK_DIVIDER_MASK | SDHCI_FSL_CLK_PRESCALE_MASK); 207 val32 |= div << SDHCI_FSL_CLK_DIVIDER_SHIFT; 208 val32 |= prescale << SDHCI_FSL_CLK_PRESCALE_SHIFT; 209 val32 |= SDHCI_FSL_CLK_IPGEN | SDHCI_FSL_CLK_SDCLKEN; 210 WR4(sc, SDHCI_CLOCK_CONTROL, val32); 211 } 212 213 static uint8_t 214 sdhci_fsl_fdt_read_1(device_t dev, struct sdhci_slot *slot, bus_size_t off) 215 { 216 struct sdhci_fsl_fdt_softc *sc; 217 uint32_t wrk32, val32; 218 219 sc = device_get_softc(dev); 220 221 switch (off) { 222 case SDHCI_HOST_CONTROL: 223 wrk32 = RD4(sc, SDHCI_FSL_PROT_CTRL); 224 val32 = wrk32 & (SDHCI_CTRL_LED | SDHCI_CTRL_CARD_DET | 225 SDHCI_CTRL_FORCE_CARD); 226 if (wrk32 & SDHCI_FSL_PROT_CTRL_WIDTH_4BIT) 227 val32 |= SDHCI_CTRL_4BITBUS; 228 else if (wrk32 & SDHCI_FSL_PROT_CTRL_WIDTH_8BIT) 229 val32 |= SDHCI_CTRL_8BITBUS; 230 return (val32); 231 case SDHCI_POWER_CONTROL: 232 return (SDHCI_POWER_ON | SDHCI_POWER_300); 233 default: 234 break; 235 } 236 237 return ((RD4(sc, off & ~3) >> (off & 3) * 8) & UINT8_MAX); 238 } 239 240 static uint16_t 241 sdhci_fsl_fdt_read_2(device_t dev, struct sdhci_slot *slot, bus_size_t off) 242 { 243 struct sdhci_fsl_fdt_softc *sc; 244 uint32_t val32; 245 246 sc = device_get_softc(dev); 247 248 switch (off) { 249 case SDHCI_CLOCK_CONTROL: 250 return (sdhci_fsl_fdt_get_clock(sc)); 251 case SDHCI_HOST_VERSION: 252 return (RD4(sc, SDHCI_FSL_HOST_VERSION) & UINT16_MAX); 253 case SDHCI_TRANSFER_MODE: 254 return (sc->cmd_and_mode & UINT16_MAX); 255 case SDHCI_COMMAND_FLAGS: 256 return (sc->cmd_and_mode >> 16); 257 case SDHCI_SLOT_INT_STATUS: 258 /* 259 * eSDHC hardware manages only a single slot. 260 * Synthesize a slot interrupt status register for slot 1 below. 261 */ 262 val32 = RD4(sc, SDHCI_INT_STATUS); 263 val32 &= RD4(sc, SDHCI_SIGNAL_ENABLE); 264 return (!!val32); 265 default: 266 return ((RD4(sc, off & ~3) >> (off & 3) * 8) & UINT16_MAX); 267 } 268 } 269 270 static uint32_t 271 sdhci_fsl_fdt_read_4(device_t dev, struct sdhci_slot *slot, bus_size_t off) 272 { 273 struct sdhci_fsl_fdt_softc *sc; 274 uint32_t wrk32, val32; 275 276 sc = device_get_softc(dev); 277 278 if (off == SDHCI_BUFFER) 279 return (bus_read_4(sc->mem_res, off)); 280 if (off == SDHCI_CAPABILITIES2) 281 off = SDHCI_FSL_CAPABILITIES2; 282 283 val32 = RD4(sc, off); 284 285 switch (off) { 286 case SDHCI_CAPABILITIES: 287 val32 &= ~(SDHCI_CAN_DO_SUSPEND | SDHCI_CAN_VDD_180); 288 break; 289 case SDHCI_PRESENT_STATE: 290 wrk32 = val32; 291 val32 &= SDHCI_FSL_PRES_COMPAT_MASK; 292 val32 |= (wrk32 >> 4) & SDHCI_STATE_DAT_MASK; 293 val32 |= (wrk32 << 1) & SDHCI_STATE_CMD; 294 break; 295 default: 296 break; 297 } 298 299 return (val32); 300 } 301 302 static void 303 sdhci_fsl_fdt_read_multi_4(device_t dev, struct sdhci_slot *slot, bus_size_t off, 304 uint32_t *data, bus_size_t count) 305 { 306 struct sdhci_fsl_fdt_softc *sc; 307 308 sc = device_get_softc(dev); 309 bus_read_multi_4(sc->mem_res, off, data, count); 310 } 311 312 static void 313 sdhci_fsl_fdt_write_1(device_t dev, struct sdhci_slot *slot, bus_size_t off, 314 uint8_t val) 315 { 316 struct sdhci_fsl_fdt_softc *sc; 317 uint32_t val32; 318 319 sc = device_get_softc(dev); 320 321 switch (off) { 322 case SDHCI_HOST_CONTROL: 323 val32 = RD4(sc, SDHCI_FSL_PROT_CTRL); 324 val32 &= ~SDHCI_FSL_PROT_CTRL_WIDTH_MASK; 325 val32 |= (val & SDHCI_CTRL_LED); 326 327 if (val & SDHCI_CTRL_8BITBUS) 328 val32 |= SDHCI_FSL_PROT_CTRL_WIDTH_8BIT; 329 else 330 /* Bus width is 1-bit when this flag is not set. */ 331 val32 |= (val & SDHCI_CTRL_4BITBUS); 332 /* Enable SDMA by masking out this field. */ 333 val32 &= ~SDHCI_FSL_PROT_CTRL_DMA_MASK; 334 val32 &= ~(SDHCI_CTRL_CARD_DET | SDHCI_CTRL_FORCE_CARD); 335 val32 |= (val & (SDHCI_CTRL_CARD_DET | 336 SDHCI_CTRL_FORCE_CARD)); 337 WR4(sc, SDHCI_FSL_PROT_CTRL, val32); 338 return; 339 case SDHCI_POWER_CONTROL: 340 return; 341 case SDHCI_SOFTWARE_RESET: 342 val &= ~SDHCI_RESET_ALL; 343 /* FALLTHROUGH. */ 344 default: 345 val32 = RD4(sc, off & ~3); 346 val32 &= ~(UINT8_MAX << (off & 3) * 8); 347 val32 |= (val << (off & 3) * 8); 348 WR4(sc, off & ~3, val32); 349 return; 350 } 351 } 352 353 static void 354 sdhci_fsl_fdt_write_2(device_t dev, struct sdhci_slot *slot, bus_size_t off, 355 uint16_t val) 356 { 357 struct sdhci_fsl_fdt_softc *sc; 358 uint32_t val32; 359 360 sc = device_get_softc(dev); 361 362 switch (off) { 363 case SDHCI_CLOCK_CONTROL: 364 fsl_sdhc_fdt_set_clock(sc, val); 365 return; 366 /* 367 * eSDHC hardware combines command and mode into a single 368 * register. Cache it here, so that command isn't written 369 * until after mode. 370 */ 371 case SDHCI_TRANSFER_MODE: 372 sc->cmd_and_mode = val; 373 return; 374 case SDHCI_COMMAND_FLAGS: 375 sc->cmd_and_mode = 376 (sc->cmd_and_mode & UINT16_MAX) | (val << 16); 377 WR4(sc, SDHCI_TRANSFER_MODE, sc->cmd_and_mode); 378 sc->cmd_and_mode = 0; 379 return; 380 default: 381 val32 = RD4(sc, off & ~3); 382 val32 &= ~(UINT16_MAX << (off & 3) * 8); 383 val32 |= ((val & UINT16_MAX) << (off & 3) * 8); 384 WR4(sc, off & ~3, val32); 385 return; 386 } 387 } 388 389 static void 390 sdhci_fsl_fdt_write_4(device_t dev, struct sdhci_slot *slot, bus_size_t off, 391 uint32_t val) 392 { 393 struct sdhci_fsl_fdt_softc *sc; 394 395 sc = device_get_softc(dev); 396 397 switch (off) { 398 case SDHCI_BUFFER: 399 bus_write_4(sc->mem_res, off, val); 400 return; 401 /* 402 * eSDHC hardware lacks support for the SDMA buffer boundary 403 * feature and instead generates SDHCI_INT_DMA_END interrupts 404 * after each completed DMA data transfer. 405 * Since this duplicates the SDHCI_INT_DATA_END functionality, 406 * mask out the unneeded SDHCI_INT_DMA_END interrupt. 407 */ 408 case SDHCI_INT_ENABLE: 409 case SDHCI_SIGNAL_ENABLE: 410 val &= ~SDHCI_INT_DMA_END; 411 /* FALLTHROUGH. */ 412 default: 413 WR4(sc, off, val); 414 return; 415 } 416 } 417 418 static void 419 sdhci_fsl_fdt_write_multi_4(device_t dev, struct sdhci_slot *slot, 420 bus_size_t off, uint32_t *data, bus_size_t count) 421 { 422 struct sdhci_fsl_fdt_softc *sc; 423 424 sc = device_get_softc(dev); 425 bus_write_multi_4(sc->mem_res, off, data, count); 426 } 427 428 static void 429 sdhci_fsl_fdt_irq(void *arg) 430 { 431 struct sdhci_fsl_fdt_softc *sc; 432 433 sc = arg; 434 sdhci_generic_intr(&sc->slot); 435 return; 436 } 437 438 static int 439 sdhci_fsl_fdt_get_ro(device_t bus, device_t child) 440 { 441 struct sdhci_fsl_fdt_softc *sc; 442 443 sc = device_get_softc(bus); 444 return (sdhci_fdt_gpio_get_readonly(sc->gpio)); 445 } 446 447 static bool 448 sdhci_fsl_fdt_get_card_present(device_t dev, struct sdhci_slot *slot) 449 { 450 struct sdhci_fsl_fdt_softc *sc; 451 452 sc = device_get_softc(dev); 453 return (sdhci_fdt_gpio_get_present(sc->gpio)); 454 } 455 456 static int 457 sdhci_fsl_fdt_attach(device_t dev) 458 { 459 struct sdhci_fsl_fdt_softc *sc; 460 uint32_t val, buf_order; 461 uintptr_t ocd_data; 462 uint64_t clk_hz; 463 phandle_t node; 464 int rid, ret; 465 clk_t clk; 466 467 node = ofw_bus_get_node(dev); 468 sc = device_get_softc(dev); 469 ocd_data = ofw_bus_search_compatible(dev, 470 sdhci_fsl_fdt_compat_data)->ocd_data; 471 sc->soc_data = (struct sdhci_fsl_fdt_soc_data *)ocd_data; 472 sc->dev = dev; 473 sc->slot.quirks = sc->soc_data->quirks; 474 475 rid = 0; 476 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 477 RF_ACTIVE); 478 if (sc->mem_res == NULL) { 479 device_printf(dev, 480 "Could not allocate resources for controller\n"); 481 return (ENOMEM); 482 } 483 484 rid = 0; 485 sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 486 RF_ACTIVE); 487 if (sc->irq_res == NULL) { 488 device_printf(dev, 489 "Could not allocate irq resources for controller\n"); 490 ret = ENOMEM; 491 goto err_free_mem; 492 } 493 494 ret = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_BIO | INTR_MPSAFE, 495 NULL, sdhci_fsl_fdt_irq, sc, &sc->irq_cookie); 496 if (ret != 0) { 497 device_printf(dev, "Could not setup IRQ handler\n"); 498 goto err_free_irq_res; 499 } 500 501 ret = clk_get_by_ofw_index(dev, node, 0, &clk); 502 if (ret != 0) { 503 device_printf(dev, "Parent clock not found\n"); 504 goto err_free_irq; 505 } 506 507 ret = clk_get_freq(clk, &clk_hz); 508 if (ret != 0) { 509 device_printf(dev, 510 "Could not get parent clock frequency\n"); 511 goto err_free_irq; 512 } 513 514 sc->baseclk_hz = clk_hz / 2; 515 516 /* Figure out eSDHC block endianness before we touch any HW regs. */ 517 if (OF_hasprop(node, "little-endian")) { 518 sc->read = read_le; 519 sc->write = write_le; 520 buf_order = SDHCI_FSL_PROT_CTRL_BYTE_NATIVE; 521 } else { 522 sc->read = read_be; 523 sc->write = write_be; 524 buf_order = SDHCI_FSL_PROT_CTRL_BYTE_SWAP; 525 } 526 527 /* 528 * Setting this register affects byte order in SDHCI_BUFFER only. 529 * If the eSDHC block is connected over a big-endian bus, the data 530 * read from/written to the buffer will be already byte swapped. 531 * In such a case, setting SDHCI_FSL_PROT_CTRL_BYTE_SWAP will convert 532 * the byte order again, resulting in a native byte order. 533 * The read/write callbacks accommodate for this behavior. 534 */ 535 val = RD4(sc, SDHCI_FSL_PROT_CTRL); 536 val &= ~SDHCI_FSL_PROT_CTRL_BYTE_MASK; 537 WR4(sc, SDHCI_FSL_PROT_CTRL, val | buf_order); 538 539 /* 540 * Gate the SD clock and set its source to peripheral clock / 2. 541 * The frequency in baseclk_hz is set to match this. 542 */ 543 val = RD4(sc, SDHCI_CLOCK_CONTROL); 544 WR4(sc, SDHCI_CLOCK_CONTROL, val & ~SDHCI_FSL_CLK_SDCLKEN); 545 val = RD4(sc, SDHCI_FSL_ESDHC_CTRL); 546 WR4(sc, SDHCI_FSL_ESDHC_CTRL, val | SDHCI_FSL_ESDHC_CTRL_CLK_DIV2); 547 sc->slot.max_clk = sc->baseclk_hz; 548 sc->gpio = sdhci_fdt_gpio_setup(dev, &sc->slot); 549 550 /* 551 * Set the buffer watermark level to 128 words (512 bytes) for both 552 * read and write. The hardware has a restriction that when the read or 553 * write ready status is asserted, that means you can read exactly the 554 * number of words set in the watermark register before you have to 555 * re-check the status and potentially wait for more data. The main 556 * sdhci driver provides no hook for doing status checking on less than 557 * a full block boundary, so we set the watermark level to be a full 558 * block. Reads and writes where the block size is less than the 559 * watermark size will work correctly too, no need to change the 560 * watermark for different size blocks. However, 128 is the maximum 561 * allowed for the watermark, so PIO is limitted to 512 byte blocks. 562 */ 563 WR4(sc, SDHCI_FSL_WTMK_LVL, SDHCI_FSL_WTMK_WR_512B | 564 SDHCI_FSL_WTMK_RD_512B); 565 566 ret = sdhci_init_slot(dev, &sc->slot, 0); 567 if (ret != 0) 568 goto err_free_gpio; 569 sc->slot_init_done = true; 570 sdhci_start_slot(&sc->slot); 571 572 return (bus_generic_attach(dev)); 573 574 err_free_gpio: 575 sdhci_fdt_gpio_teardown(sc->gpio); 576 err_free_irq: 577 bus_teardown_intr(dev, sc->irq_res, sc->irq_cookie); 578 err_free_irq_res: 579 bus_free_resource(dev, SYS_RES_IRQ, sc->irq_res); 580 err_free_mem: 581 bus_free_resource(dev, SYS_RES_MEMORY, sc->mem_res); 582 return (ret); 583 } 584 585 static int 586 sdhci_fsl_fdt_detach(device_t dev) 587 { 588 struct sdhci_fsl_fdt_softc *sc; 589 590 sc = device_get_softc(dev); 591 if (sc->slot_init_done) 592 sdhci_cleanup_slot(&sc->slot); 593 if (sc->gpio != NULL) 594 sdhci_fdt_gpio_teardown(sc->gpio); 595 if (sc->irq_cookie != NULL) 596 bus_teardown_intr(dev, sc->irq_res, sc->irq_cookie); 597 if (sc->irq_res != NULL) 598 bus_free_resource(dev, SYS_RES_IRQ, sc->irq_res); 599 if (sc->mem_res != NULL) 600 bus_free_resource(dev, SYS_RES_MEMORY, sc->mem_res); 601 return (0); 602 } 603 604 static int 605 sdhci_fsl_fdt_probe(device_t dev) 606 { 607 608 if (!ofw_bus_status_okay(dev)) 609 return (ENXIO); 610 611 if (!ofw_bus_search_compatible(dev, 612 sdhci_fsl_fdt_compat_data)->ocd_data) 613 return (ENXIO); 614 615 device_set_desc(dev, "NXP QorIQ Layerscape eSDHC controller"); 616 return (BUS_PROBE_DEFAULT); 617 } 618 619 static int 620 sdhci_fsl_fdt_read_ivar(device_t bus, device_t child, int which, 621 uintptr_t *result) 622 { 623 struct sdhci_slot *slot = device_get_ivars(child); 624 625 if (which == MMCBR_IVAR_MAX_DATA && (slot->opt & SDHCI_HAVE_DMA)) { 626 /* 627 * In the absence of SDMA buffer boundary functionality, 628 * limit the maximum data length per read/write command 629 * to bounce buffer size. 630 */ 631 *result = howmany(slot->sdma_bbufsz, 512); 632 return (0); 633 } 634 return (sdhci_generic_read_ivar(bus, child, which, result)); 635 } 636 637 static const device_method_t sdhci_fsl_fdt_methods[] = { 638 /* Device interface. */ 639 DEVMETHOD(device_probe, sdhci_fsl_fdt_probe), 640 DEVMETHOD(device_attach, sdhci_fsl_fdt_attach), 641 DEVMETHOD(device_detach, sdhci_fsl_fdt_detach), 642 643 /* Bus interface. */ 644 DEVMETHOD(bus_read_ivar, sdhci_fsl_fdt_read_ivar), 645 DEVMETHOD(bus_write_ivar, sdhci_generic_write_ivar), 646 647 /* MMC bridge interface. */ 648 DEVMETHOD(mmcbr_update_ios, sdhci_generic_update_ios), 649 DEVMETHOD(mmcbr_request, sdhci_generic_request), 650 DEVMETHOD(mmcbr_get_ro, sdhci_fsl_fdt_get_ro), 651 DEVMETHOD(mmcbr_acquire_host, sdhci_generic_acquire_host), 652 DEVMETHOD(mmcbr_release_host, sdhci_generic_release_host), 653 654 /* SDHCI accessors. */ 655 DEVMETHOD(sdhci_read_1, sdhci_fsl_fdt_read_1), 656 DEVMETHOD(sdhci_read_2, sdhci_fsl_fdt_read_2), 657 DEVMETHOD(sdhci_read_4, sdhci_fsl_fdt_read_4), 658 DEVMETHOD(sdhci_read_multi_4, sdhci_fsl_fdt_read_multi_4), 659 DEVMETHOD(sdhci_write_1, sdhci_fsl_fdt_write_1), 660 DEVMETHOD(sdhci_write_2, sdhci_fsl_fdt_write_2), 661 DEVMETHOD(sdhci_write_4, sdhci_fsl_fdt_write_4), 662 DEVMETHOD(sdhci_write_multi_4, sdhci_fsl_fdt_write_multi_4), 663 DEVMETHOD(sdhci_get_card_present, sdhci_fsl_fdt_get_card_present), 664 DEVMETHOD_END 665 }; 666 667 static devclass_t sdhci_fsl_fdt_devclass; 668 static driver_t sdhci_fsl_fdt_driver = { 669 "sdhci_fsl_fdt", 670 sdhci_fsl_fdt_methods, 671 sizeof(struct sdhci_fsl_fdt_softc), 672 }; 673 674 DRIVER_MODULE(sdhci_fsl_fdt, simplebus, sdhci_fsl_fdt_driver, 675 sdhci_fsl_fdt_devclass, NULL, NULL); 676 SDHCI_DEPEND(sdhci_fsl_fdt); 677 678 #ifndef MMCCAM 679 MMC_DECLARE_BRIDGE(sdhci_fsl_fdt); 680 #endif 681