git.sur5r.net Git - u-boot/blob - 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
  31 static 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
  96 void 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