Quelle  fdt_early.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
#include <linux/types.h>
#include <linux/init.h>
#include <linux/libfdt.h>
#include <linux/ctype.h>
#include <asm/csr.h>

#include "pi.h"

u64 get_kaslr_seed(uintptr_t dtb_pa)
{
 int node, len;
 fdt64_t *prop;
 u64 ret;

 node = fdt_path_offset((void *)dtb_pa, "/chosen");
 if (node < 0)
  return 0;

 prop = fdt_getprop_w((void *)dtb_pa, node, "kaslr-seed", &len);
 if (!prop || len != sizeof(u64))
  return 0;

 ret = fdt64_to_cpu(*prop);
 *prop = 0;
 return ret;
}

/**
 *  fdt_device_is_available - check if a device is available for use
 *
 * @fdt: pointer to the device tree blob
 * @node: offset of the node whose property to find
 *
 *  Returns true if the status property is absent or set to "okay" or "ok",
 *  false otherwise
 */
static bool fdt_device_is_available(const void *fdt, int node)
{
 const char *status;
 int statlen;

 status = fdt_getprop(fdt, node, "status", &statlen);
 if (!status)
  return true;

 if (statlen > 0) {
  if (!strcmp(status, "okay") || !strcmp(status, "ok"))
   return true;
 }

 return false;
}

/* Copy of fdt_nodename_eq_ */
static int fdt_node_name_eq(const void *fdt, int offset,
       const char *s)
{
 int olen;
 int len = strlen(s);
 const char *p = fdt_get_name(fdt, offset, &olen);

 if (!p || olen < len)
  /* short match */
  return 0;

 if (memcmp(p, s, len) != 0)
  return 0;

 if (p[len] == '\0')
  return 1;
 else if (!memchr(s, '@', len) && (p[len] == '@'))
  return 1;
 else
  return 0;
}

/**
 *  isa_string_contains - check if isa string contains an extension
 *
 * @isa_str: isa string to search
 * @ext_name: the extension to search for
 *
 *  Returns true if the extension is in the given isa string,
 *  false otherwise
 */
static bool isa_string_contains(const char *isa_str, const char *ext_name)
{
 size_t i, single_end, len = strlen(ext_name);
 char ext_end;

 /* Error must contain rv32/64 */
 if (strlen(isa_str) < 4)
  return false;

 if (len == 1) {
  single_end = strcspn(isa_str, "sSxXzZ");
  /* Search for single chars between rv32/64 and multi-letter extensions */
  for (i = 4; i < single_end; i++) {
   if (tolower(isa_str[i]) == ext_name[0])
    return true;
  }
  return false;
 }

 /* Skip to start of multi-letter extensions */
 isa_str = strpbrk(isa_str, "sSxXzZ");
 while (isa_str) {
  if (strncasecmp(isa_str, ext_name, len) == 0) {
   ext_end = isa_str[len];
   /* Check if matches the whole extension. */
   if (ext_end == '\0' || ext_end == '_')
    return true;
  }
  /* Multi-letter extensions must be split from other multi-letter
   * extensions with an "_", the end of a multi-letter extension will
   * either be the null character or the "_" at the start of the next
   * multi-letter extension.
 */
  isa_str = strchr(isa_str, '_');
  if (isa_str)
   isa_str++;
 }

 return false;
}

/**
 *  early_cpu_isa_ext_available - check if cpu node has an extension
 *
 * @fdt: pointer to the device tree blob
 * @node: offset of the cpu node
 * @ext_name: the extension to search for
 *
 *  Returns true if the cpu node has the extension,
 *  false otherwise
 */
static bool early_cpu_isa_ext_available(const void *fdt, int node, const char *ext_name)
{
 const void *prop;
 int len;

 prop = fdt_getprop(fdt, node, "riscv,isa-extensions", &len);
 if (prop && fdt_stringlist_contains(prop, len, ext_name))
  return true;

 prop = fdt_getprop(fdt, node, "riscv,isa", &len);
 if (prop && isa_string_contains(prop, ext_name))
  return true;

 return false;
}

/**
 *  fdt_early_match_extension_isa - check if all cpu nodes have an extension
 *
 * @fdt: pointer to the device tree blob
 * @ext_name: the extension to search for
 *
 *  Returns true if the all available the cpu nodes have the extension,
 *  false otherwise
 */
bool fdt_early_match_extension_isa(const void *fdt, const char *ext_name)
{
 int node, parent;
 bool ret = false;

 parent = fdt_path_offset(fdt, "/cpus");
 if (parent < 0)
  return false;

 fdt_for_each_subnode(node, fdt, parent) {
  if (!fdt_node_name_eq(fdt, node, "cpu"))
   continue;

  if (!fdt_device_is_available(fdt, node))
   continue;

  if (!early_cpu_isa_ext_available(fdt, node, ext_name))
   return false;

  ret = true;
 }

 return ret;
}

/**
 *  set_satp_mode_from_fdt - determine SATP mode based on the MMU type in fdt
 *
 * @dtb_pa: physical address of the device tree blob
 *
 *  Returns the SATP mode corresponding to the MMU type of the first enabled CPU,
 *  0 otherwise
 */
u64 set_satp_mode_from_fdt(uintptr_t dtb_pa)
{
 const void *fdt = (const void *)dtb_pa;
 const char *mmu_type;
 int node, parent;

 parent = fdt_path_offset(fdt, "/cpus");
 if (parent < 0)
  return 0;

 fdt_for_each_subnode(node, fdt, parent) {
  if (!fdt_node_name_eq(fdt, node, "cpu"))
   continue;

  if (!fdt_device_is_available(fdt, node))
   continue;

  mmu_type = fdt_getprop(fdt, node, "mmu-type", NULL);
  if (!mmu_type)
   break;

  if (!strcmp(mmu_type, "riscv,sv39"))
   return SATP_MODE_39;
  else if (!strcmp(mmu_type, "riscv,sv48"))
   return SATP_MODE_48;
  break;
 }

 return 0;
}