tree 41d71e2e3ef6f3faaa9e3c746852944898c585ad
parent 298ad4d60c860379f2c9b0fe3ff070e8aaf31465
author Lokesh Vutla <lokeshvutla@ti.com> 1568020236 +0530
committer Peng Fan <peng.fan@nxp.com> 1570676388 +0800

spl: dm_mmc: Initialize only the required mmc device

In SPL, all the available mmc devices gets initialized during boot.
This might not work in cases where clocks are not available for
certain mmc devices(other than boot device) and the support for
enabling device might not be ready.

Texas Instruments' K3 J721E device having a central system controller
(dmsc) is one such example falling in this category. Below is the
sequence for the failing scenario:
- ROM comes up in SD mode and loads SPL by just initialing SD card.
- SPL loads dmsc firmware from SD Card.
Since ROM has enabled SD, SPL need not enable the SD, just need
to re initialize the card. But SPL is trying to initialize other MMC
instances which are in disabled state. Since dmsc firmware is not yet
available, devices cannot be enabled. So in SPL, initialize only the
mmc device that is needed.

Signed-off-by: Lokesh Vutla <lokeshvutla@ti.com>
Reviewed-by: Peng Fan <peng.fan@nxp.com>
