LXR uboot/arch/arm/mach-rockchip/spl-boot-order.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * (C) Copyright 2017 Theobroma Systems Design und Consulting GmbH
   4 */
   5
   6#include <common.h>
   7#include <dm.h>
   8#include <mmc.h>
   9#include <spl.h>
  10
  11#if CONFIG_IS_ENABLED(OF_CONTROL)
  12/**
  13 * spl_node_to_boot_device() - maps from a DT-node to a SPL boot device
  14 * @node:       of_offset of the node
  15 *
  16 * The SPL framework uses BOOT_DEVICE_... constants to identify its boot
  17 * sources.  These may take on a device-specific meaning, depending on
  18 * what nodes are enabled in a DTS (e.g. BOOT_DEVICE_MMC1 may refer to
  19 * different controllers/block-devices, depending on which SD/MMC controllers
  20 * are enabled in any given DTS).  This function maps from a DT-node back
  21 * onto a BOOT_DEVICE_... constant, considering the currently active devices.
  22 *
  23 * Returns
  24 *   -ENOENT, if no device matching the node could be found
  25 *   -ENOSYS, if the device matching the node can not be mapped onto a
  26 *            SPL boot device (e.g. the third MMC device)
  27 *   -1, for unspecified failures
  28 *   a positive integer (from the BOOT_DEVICE_... family) on succes.
  29 */
  30
  31static int spl_node_to_boot_device(int node)
  32{
  33        struct udevice *parent;
  34
  35        /*
  36         * This should eventually move into the SPL code, once SPL becomes
  37         * aware of the block-device layer.  Until then (and to avoid unneeded
  38         * delays in getting this feature out, it lives at the board-level).
  39         */
  40        if (!uclass_get_device_by_of_offset(UCLASS_MMC, node, &parent)) {
  41                struct udevice *dev;
  42                struct blk_desc *desc = NULL;
  43
  44                for (device_find_first_child(parent, &dev);
  45                     dev;
  46                     device_find_next_child(&dev)) {
  47                        if (device_get_uclass_id(dev) == UCLASS_BLK) {
  48                                desc = dev_get_uclass_platdata(dev);
  49                                break;
  50                        }
  51                }
  52
  53                if (!desc)
  54                        return -ENOENT;
  55
  56                switch (desc->devnum) {
  57                case 0:
  58                        return BOOT_DEVICE_MMC1;
  59                case 1:
  60                        return BOOT_DEVICE_MMC2;
  61                default:
  62                        return -ENOSYS;
  63                }
  64        }
  65
  66        /*
  67         * SPL doesn't differentiate SPI flashes, so we keep the detection
  68         * brief and inaccurate... hopefully, the common SPL layer can be
  69         * extended with awareness of the BLK layer (and matching OF_CONTROL)
  70         * soon.
  71         */
  72        if (!uclass_get_device_by_of_offset(UCLASS_SPI_FLASH, node, &parent))
  73                return BOOT_DEVICE_SPI;
  74
  75        return -1;
  76}
  77
  78/**
  79 * board_spl_was_booted_from() - retrieves the of-path the SPL was loaded from
  80 *
  81 * To support a 'same-as-spl' specification in the search-order for the next
  82 * stage, we need a SoC- or board-specific way to handshake with what 'came
  83 * before us' (either a BROM or TPL stage) and map the info retrieved onto
  84 * a OF path.
  85 *
  86 * Returns
  87 *   NULL, on failure or if the device could not be identified
  88 *   a of_path (a string), on success
  89 */
  90__weak const char *board_spl_was_booted_from(void)
  91{
  92        debug("%s: no support for 'same-as-spl' for this board\n", __func__);
  93        return NULL;
  94}
  95
  96void board_boot_order(u32 *spl_boot_list)
  97{
  98        const void *blob = gd->fdt_blob;
  99        int chosen_node = fdt_path_offset(blob, "/chosen");
 100        int idx = 0;
 101        int elem;
 102        int boot_device;
 103        int node;
 104        const char *conf;
 105
 106        if (chosen_node < 0) {
 107                debug("%s: /chosen not found, using spl_boot_device()\n",
 108                      __func__);
 109                spl_boot_list[0] = spl_boot_device();
 110                return;
 111        }
 112
 113        for (elem = 0;
 114             (conf = fdt_stringlist_get(blob, chosen_node,
 115                                        "u-boot,spl-boot-order", elem, NULL));
 116             elem++) {
 117                const char *alias;
 118
 119                /* Handle the case of 'same device the SPL was loaded from' */
 120                if (strncmp(conf, "same-as-spl", 11) == 0) {
 121                        conf = board_spl_was_booted_from();
 122                        if (!conf)
 123                                continue;
 124                }
 125
 126                /* First check if the list element is an alias */
 127                alias = fdt_get_alias(blob, conf);
 128                if (alias)
 129                        conf = alias;
 130
 131                /* Try to resolve the config item (or alias) as a path */
 132                node = fdt_path_offset(blob, conf);
 133                if (node < 0) {
 134                        debug("%s: could not find %s in FDT", __func__, conf);
 135                        continue;
 136                }
 137
 138                /* Try to map this back onto SPL boot devices */
 139                boot_device = spl_node_to_boot_device(node);
 140                if (boot_device < 0) {
 141                        debug("%s: could not map node @%x to a boot-device\n",
 142                              __func__, node);
 143                        continue;
 144                }
 145
 146                spl_boot_list[idx++] = boot_device;
 147        }
 148
 149        /* If we had no matches, fall back to spl_boot_device */
 150        if (idx == 0)
 151                spl_boot_list[0] = spl_boot_device();
 152}
 153#endif
 154