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