target/linux/ipq806x/patches/0050-drivers-of-add-initialization-code-for-dynamic-reser.patch

   1 From 968b497e1027ec78e986370976c76e1652aa0459 Mon Sep 17 00:00:00 2001
   2 From: Marek Szyprowski <m.szyprowski@samsung.com>
   3 Date: Fri, 28 Feb 2014 14:42:48 +0100
   4 Subject: [PATCH 050/182] drivers: of: add initialization code for dynamic
   5  reserved memory
   6
   7 This patch adds support for dynamically allocated reserved memory regions
   8 declared in device tree. Such regions are defined by 'size', 'alignment'
   9 and 'alloc-ranges' properties.
  10
  11 Based on previous code provided by Josh Cartwright <joshc@codeaurora.org>
  12
  13 Signed-off-by: Marek Szyprowski <m.szyprowski@samsung.com>
  14 Signed-off-by: Grant Likely <grant.likely@linaro.org>
  15 ---
  16  drivers/of/Kconfig              |    6 ++
  17  drivers/of/Makefile             |    1 +
  18  drivers/of/fdt.c                |   13 ++-
  19  drivers/of/of_reserved_mem.c    |  188 +++++++++++++++++++++++++++++++++++++++
  20  include/linux/of_reserved_mem.h |   21 +++++
  21  5 files changed, 227 insertions(+), 2 deletions(-)
  22  create mode 100644 drivers/of/of_reserved_mem.c
  23  create mode 100644 include/linux/of_reserved_mem.h
  24
  25 --- a/drivers/of/Kconfig
  26 +++ b/drivers/of/Kconfig
  27 @@ -75,4 +75,10 @@ config OF_MTD
  28         depends on MTD
  29         def_bool y
  30
  31 +config OF_RESERVED_MEM
  32 +       depends on OF_EARLY_FLATTREE
  33 +       bool
  34 +       help
  35 +         Helpers to allow for reservation of memory regions
  36 +
  37  endmenu # OF
  38 --- a/drivers/of/Makefile
  39 +++ b/drivers/of/Makefile
  40 @@ -9,3 +9,4 @@ obj-$(CONFIG_OF_MDIO)   += of_mdio.o
  41  obj-$(CONFIG_OF_PCI)   += of_pci.o
  42  obj-$(CONFIG_OF_PCI_IRQ)  += of_pci_irq.o
  43  obj-$(CONFIG_OF_MTD)   += of_mtd.o
  44 +obj-$(CONFIG_OF_RESERVED_MEM) += of_reserved_mem.o
  45 --- a/drivers/of/fdt.c
  46 +++ b/drivers/of/fdt.c
  47 @@ -15,6 +15,7 @@
  48  #include <linux/module.h>
  49  #include <linux/of.h>
  50  #include <linux/of_fdt.h>
  51 +#include <linux/of_reserved_mem.h>
  52  #include <linux/sizes.h>
  53  #include <linux/string.h>
  54  #include <linux/errno.h>
  55 @@ -450,7 +451,7 @@ static int __init __reserved_mem_reserve
  56         phys_addr_t base, size;
  57         unsigned long len;
  58         __be32 *prop;
  59 -       int nomap;
  60 +       int nomap, first = 1;
  61
  62         prop = of_get_flat_dt_prop(node, "reg", &len);
  63         if (!prop)
  64 @@ -477,6 +478,10 @@ static int __init __reserved_mem_reserve
  65                                 uname, &base, (unsigned long)size / SZ_1M);
  66
  67                 len -= t_len;
  68 +               if (first) {
  69 +                       fdt_reserved_mem_save_node(node, uname, base, size);
  70 +                       first = 0;
  71 +               }
  72         }
  73         return 0;
  74  }
  75 @@ -512,6 +517,7 @@ static int __init __fdt_scan_reserved_me
  76  {
  77         static int found;
  78         const char *status;
  79 +       int err;
  80
  81         if (!found && depth == 1 && strcmp(uname, "reserved-memory") == 0) {
  82                 if (__reserved_mem_check_root(node) != 0) {
  83 @@ -534,7 +540,9 @@ static int __init __fdt_scan_reserved_me
  84         if (status && strcmp(status, "okay") != 0 && strcmp(status, "ok") != 0)
  85                 return 0;
  86
  87 -       __reserved_mem_reserve_reg(node, uname);
  88 +       err = __reserved_mem_reserve_reg(node, uname);
  89 +       if (err == -ENOENT && of_get_flat_dt_prop(node, "size", NULL))
  90 +               fdt_reserved_mem_save_node(node, uname, 0, 0);
  91
  92         /* scan next node */
  93         return 0;
  94 @@ -550,6 +558,7 @@ static int __init __fdt_scan_reserved_me
  95  void __init early_init_fdt_scan_reserved_mem(void)
  96  {
  97         of_scan_flat_dt(__fdt_scan_reserved_mem, NULL);
  98 +       fdt_init_reserved_mem();
  99  }
 100
 101  /**
 102 --- /dev/null
 103 +++ b/drivers/of/of_reserved_mem.c
 104 @@ -0,0 +1,188 @@
 105 +/*
 106 + * Device tree based initialization code for reserved memory.
 107 + *
 108 + * Copyright (c) 2013, The Linux Foundation. All Rights Reserved.
 109 + * Copyright (c) 2013,2014 Samsung Electronics Co., Ltd.
 110 + *             http://www.samsung.com
 111 + * Author: Marek Szyprowski <m.szyprowski@samsung.com>
 112 + * Author: Josh Cartwright <joshc@codeaurora.org>
 113 + *
 114 + * This program is free software; you can redistribute it and/or
 115 + * modify it under the terms of the GNU General Public License as
 116 + * published by the Free Software Foundation; either version 2 of the
 117 + * License or (at your optional) any later version of the license.
 118 + */
 119 +
 120 +#include <linux/err.h>
 121 +#include <linux/of.h>
 122 +#include <linux/of_fdt.h>
 123 +#include <linux/of_platform.h>
 124 +#include <linux/mm.h>
 125 +#include <linux/sizes.h>
 126 +#include <linux/of_reserved_mem.h>
 127 +
 128 +#define MAX_RESERVED_REGIONS   16
 129 +static struct reserved_mem reserved_mem[MAX_RESERVED_REGIONS];
 130 +static int reserved_mem_count;
 131 +
 132 +#if defined(CONFIG_HAVE_MEMBLOCK)
 133 +#include <linux/memblock.h>
 134 +int __init __weak early_init_dt_alloc_reserved_memory_arch(phys_addr_t size,
 135 +       phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap,
 136 +       phys_addr_t *res_base)
 137 +{
 138 +       /*
 139 +        * We use __memblock_alloc_base() because memblock_alloc_base()
 140 +        * panic()s on allocation failure.
 141 +        */
 142 +       phys_addr_t base = __memblock_alloc_base(size, align, end);
 143 +       if (!base)
 144 +               return -ENOMEM;
 145 +
 146 +       /*
 147 +        * Check if the allocated region fits in to start..end window
 148 +        */
 149 +       if (base < start) {
 150 +               memblock_free(base, size);
 151 +               return -ENOMEM;
 152 +       }
 153 +
 154 +       *res_base = base;
 155 +       if (nomap)
 156 +               return memblock_remove(base, size);
 157 +       return 0;
 158 +}
 159 +#else
 160 +int __init __weak early_init_dt_alloc_reserved_memory_arch(phys_addr_t size,
 161 +       phys_addr_t align, phys_addr_t start, phys_addr_t end, bool nomap,
 162 +       phys_addr_t *res_base)
 163 +{
 164 +       pr_err("Reserved memory not supported, ignoring region 0x%llx%s\n",
 165 +                 size, nomap ? " (nomap)" : "");
 166 +       return -ENOSYS;
 167 +}
 168 +#endif
 169 +
 170 +/**
 171 + * res_mem_save_node() - save fdt node for second pass initialization
 172 + */
 173 +void __init fdt_reserved_mem_save_node(unsigned long node, const char *uname,
 174 +                                     phys_addr_t base, phys_addr_t size)
 175 +{
 176 +       struct reserved_mem *rmem = &reserved_mem[reserved_mem_count];
 177 +
 178 +       if (reserved_mem_count == ARRAY_SIZE(reserved_mem)) {
 179 +               pr_err("Reserved memory: not enough space all defined regions.\n");
 180 +               return;
 181 +       }
 182 +
 183 +       rmem->fdt_node = node;
 184 +       rmem->name = uname;
 185 +       rmem->base = base;
 186 +       rmem->size = size;
 187 +
 188 +       reserved_mem_count++;
 189 +       return;
 190 +}
 191 +
 192 +/**
 193 + * res_mem_alloc_size() - allocate reserved memory described by 'size', 'align'
 194 + *                       and 'alloc-ranges' properties
 195 + */
 196 +static int __init __reserved_mem_alloc_size(unsigned long node,
 197 +       const char *uname, phys_addr_t *res_base, phys_addr_t *res_size)
 198 +{
 199 +       int t_len = (dt_root_addr_cells + dt_root_size_cells) * sizeof(__be32);
 200 +       phys_addr_t start = 0, end = 0;
 201 +       phys_addr_t base = 0, align = 0, size;
 202 +       unsigned long len;
 203 +       __be32 *prop;
 204 +       int nomap;
 205 +       int ret;
 206 +
 207 +       prop = of_get_flat_dt_prop(node, "size", &len);
 208 +       if (!prop)
 209 +               return -EINVAL;
 210 +
 211 +       if (len != dt_root_size_cells * sizeof(__be32)) {
 212 +               pr_err("Reserved memory: invalid size property in '%s' node.\n",
 213 +                               uname);
 214 +               return -EINVAL;
 215 +       }
 216 +       size = dt_mem_next_cell(dt_root_size_cells, &prop);
 217 +
 218 +       nomap = of_get_flat_dt_prop(node, "no-map", NULL) != NULL;
 219 +
 220 +       prop = of_get_flat_dt_prop(node, "alignment", &len);
 221 +       if (prop) {
 222 +               if (len != dt_root_addr_cells * sizeof(__be32)) {
 223 +                       pr_err("Reserved memory: invalid alignment property in '%s' node.\n",
 224 +                               uname);
 225 +                       return -EINVAL;
 226 +               }
 227 +               align = dt_mem_next_cell(dt_root_addr_cells, &prop);
 228 +       }
 229 +
 230 +       prop = of_get_flat_dt_prop(node, "alloc-ranges", &len);
 231 +       if (prop) {
 232 +
 233 +               if (len % t_len != 0) {
 234 +                       pr_err("Reserved memory: invalid alloc-ranges property in '%s', skipping node.\n",
 235 +                              uname);
 236 +                       return -EINVAL;
 237 +               }
 238 +
 239 +               base = 0;
 240 +
 241 +               while (len > 0) {
 242 +                       start = dt_mem_next_cell(dt_root_addr_cells, &prop);
 243 +                       end = start + dt_mem_next_cell(dt_root_size_cells,
 244 +                                                      &prop);
 245 +
 246 +                       ret = early_init_dt_alloc_reserved_memory_arch(size,
 247 +                                       align, start, end, nomap, &base);
 248 +                       if (ret == 0) {
 249 +                               pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
 250 +                                       uname, &base,
 251 +                                       (unsigned long)size / SZ_1M);
 252 +                               break;
 253 +                       }
 254 +                       len -= t_len;
 255 +               }
 256 +
 257 +       } else {
 258 +               ret = early_init_dt_alloc_reserved_memory_arch(size, align,
 259 +                                                       0, 0, nomap, &base);
 260 +               if (ret == 0)
 261 +                       pr_debug("Reserved memory: allocated memory for '%s' node: base %pa, size %ld MiB\n",
 262 +                               uname, &base, (unsigned long)size / SZ_1M);
 263 +       }
 264 +
 265 +       if (base == 0) {
 266 +               pr_info("Reserved memory: failed to allocate memory for node '%s'\n",
 267 +                       uname);
 268 +               return -ENOMEM;
 269 +       }
 270 +
 271 +       *res_base = base;
 272 +       *res_size = size;
 273 +
 274 +       return 0;
 275 +}
 276 +
 277 +/**
 278 + * fdt_init_reserved_mem - allocate and init all saved reserved memory regions
 279 + */
 280 +void __init fdt_init_reserved_mem(void)
 281 +{
 282 +       int i;
 283 +       for (i = 0; i < reserved_mem_count; i++) {
 284 +               struct reserved_mem *rmem = &reserved_mem[i];
 285 +               unsigned long node = rmem->fdt_node;
 286 +               int err = 0;
 287 +
 288 +               if (rmem->size == 0)
 289 +                       err = __reserved_mem_alloc_size(node, rmem->name,
 290 +                                                &rmem->base, &rmem->size);
 291 +       }
 292 +}
 293 --- /dev/null
 294 +++ b/include/linux/of_reserved_mem.h
 295 @@ -0,0 +1,21 @@
 296 +#ifndef __OF_RESERVED_MEM_H
 297 +#define __OF_RESERVED_MEM_H
 298 +
 299 +struct reserved_mem {
 300 +       const char                      *name;
 301 +       unsigned long                   fdt_node;
 302 +       phys_addr_t                     base;
 303 +       phys_addr_t                     size;
 304 +};
 305 +
 306 +#ifdef CONFIG_OF_RESERVED_MEM
 307 +void fdt_init_reserved_mem(void);
 308 +void fdt_reserved_mem_save_node(unsigned long node, const char *uname,
 309 +                              phys_addr_t base, phys_addr_t size);
 310 +#else
 311 +static inline void fdt_init_reserved_mem(void) { }
 312 +static inline void fdt_reserved_mem_save_node(unsigned long node,
 313 +               const char *uname, phys_addr_t base, phys_addr_t size) { }
 314 +#endif
 315 +
 316 +#endif /* __OF_RESERVED_MEM_H */