git.sur5r.net Git - u-boot/blob - arch/arm/mach-rockchip/spl-boot-order.c

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