arch/mips/generic/yamon-dt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2016 Imagination Technologies
   4  * Author: Paul Burton <paul.burton@mips.com>
   5  */
   6
   7 #define pr_fmt(fmt) "yamon-dt: " fmt
   8
   9 #include <linux/bug.h>
  10 #include <linux/errno.h>
  11 #include <linux/kernel.h>
  12 #include <linux/libfdt.h>
  13 #include <linux/printk.h>
  14
  15 #include <asm/fw/fw.h>
  16 #include <asm/yamon-dt.h>
  17
  18 #define MAX_MEM_ARRAY_ENTRIES   2
  19
  20 __init int yamon_dt_append_cmdline(void *fdt)
  21 {
  22         int err, chosen_off;
  23
  24         /* find or add chosen node */
  25         chosen_off = fdt_path_offset(fdt, "/chosen");
  26         if (chosen_off == -FDT_ERR_NOTFOUND)
  27                 chosen_off = fdt_add_subnode(fdt, 0, "chosen");
  28         if (chosen_off < 0) {
  29                 pr_err("Unable to find or add DT chosen node: %d\n",
  30                        chosen_off);
  31                 return chosen_off;
  32         }
  33
  34         err = fdt_setprop_string(fdt, chosen_off, "bootargs", fw_getcmdline());
  35         if (err) {
  36                 pr_err("Unable to set bootargs property: %d\n", err);
  37                 return err;
  38         }
  39
  40         return 0;
  41 }
  42
  43 static unsigned int __init gen_fdt_mem_array(
  44                                         const struct yamon_mem_region *regions,
  45                                         __be32 *mem_array,
  46                                         unsigned int max_entries,
  47                                         unsigned long memsize)
  48 {
  49         const struct yamon_mem_region *mr;
  50         unsigned long size;
  51         unsigned int entries = 0;
  52
  53         for (mr = regions; mr->size && memsize; ++mr) {
  54                 if (entries >= max_entries) {
  55                         pr_warn("Number of regions exceeds max %u\n",
  56                                 max_entries);
  57                         break;
  58                 }
  59
  60                 /* How much of the remaining RAM fits in the next region? */
  61                 size = min_t(unsigned long, memsize, mr->size);
  62                 memsize -= size;
  63
  64                 /* Emit a memory region */
  65                 *(mem_array++) = cpu_to_be32(mr->start);
  66                 *(mem_array++) = cpu_to_be32(size);
  67                 ++entries;
  68
  69                 /* Discard the next mr->discard bytes */
  70                 memsize -= min_t(unsigned long, memsize, mr->discard);
  71         }
  72         return entries;
  73 }
  74
  75 __init int yamon_dt_append_memory(void *fdt,
  76                                   const struct yamon_mem_region *regions)
  77 {
  78         unsigned long phys_memsize, memsize;
  79         __be32 mem_array[2 * MAX_MEM_ARRAY_ENTRIES];
  80         unsigned int mem_entries;
  81         int i, err, mem_off;
  82         char *var, param_name[10], *var_names[] = {
  83                 "ememsize", "memsize",
  84         };
  85
  86         /* find memory size from the bootloader environment */
  87         for (i = 0; i < ARRAY_SIZE(var_names); i++) {
  88                 var = fw_getenv(var_names[i]);
  89                 if (!var)
  90                         continue;
  91
  92                 err = kstrtoul(var, 0, &phys_memsize);
  93                 if (!err)
  94                         break;
  95
  96                 pr_warn("Failed to read the '%s' env variable '%s'\n",
  97                         var_names[i], var);
  98         }
  99
 100         if (!phys_memsize) {
 101                 pr_warn("The bootloader didn't provide memsize: defaulting to 32MB\n");
 102                 phys_memsize = 32 << 20;
 103         }
 104
 105         /* default to using all available RAM */
 106         memsize = phys_memsize;
 107
 108         /* allow the user to override the usable memory */
 109         for (i = 0; i < ARRAY_SIZE(var_names); i++) {
 110                 snprintf(param_name, sizeof(param_name), "%s=", var_names[i]);
 111                 var = strstr(arcs_cmdline, param_name);
 112                 if (!var)
 113                         continue;
 114
 115                 memsize = memparse(var + strlen(param_name), NULL);
 116         }
 117
 118         /* if the user says there's more RAM than we thought, believe them */
 119         phys_memsize = max_t(unsigned long, phys_memsize, memsize);
 120
 121         /* find or add a memory node */
 122         mem_off = fdt_path_offset(fdt, "/memory");
 123         if (mem_off == -FDT_ERR_NOTFOUND)
 124                 mem_off = fdt_add_subnode(fdt, 0, "memory");
 125         if (mem_off < 0) {
 126                 pr_err("Unable to find or add memory DT node: %d\n", mem_off);
 127                 return mem_off;
 128         }
 129
 130         err = fdt_setprop_string(fdt, mem_off, "device_type", "memory");
 131         if (err) {
 132                 pr_err("Unable to set memory node device_type: %d\n", err);
 133                 return err;
 134         }
 135
 136         mem_entries = gen_fdt_mem_array(regions, mem_array,
 137                                         MAX_MEM_ARRAY_ENTRIES, phys_memsize);
 138         err = fdt_setprop(fdt, mem_off, "reg",
 139                           mem_array, mem_entries * 2 * sizeof(mem_array[0]));
 140         if (err) {
 141                 pr_err("Unable to set memory regs property: %d\n", err);
 142                 return err;
 143         }
 144
 145         mem_entries = gen_fdt_mem_array(regions, mem_array,
 146                                         MAX_MEM_ARRAY_ENTRIES, memsize);
 147         err = fdt_setprop(fdt, mem_off, "linux,usable-memory",
 148                           mem_array, mem_entries * 2 * sizeof(mem_array[0]));
 149         if (err) {
 150                 pr_err("Unable to set linux,usable-memory property: %d\n", err);
 151                 return err;
 152         }
 153
 154         return 0;
 155 }
 156
 157 __init int yamon_dt_serial_config(void *fdt)
 158 {
 159         const char *yamontty, *mode_var;
 160         char mode_var_name[9], path[20], parity;
 161         unsigned int uart, baud, stop_bits;
 162         bool hw_flow;
 163         int chosen_off, err;
 164
 165         yamontty = fw_getenv("yamontty");
 166         if (!yamontty || !strcmp(yamontty, "tty0")) {
 167                 uart = 0;
 168         } else if (!strcmp(yamontty, "tty1")) {
 169                 uart = 1;
 170         } else {
 171                 pr_warn("yamontty environment variable '%s' invalid\n",
 172                         yamontty);
 173                 uart = 0;
 174         }
 175
 176         baud = stop_bits = 0;
 177         parity = 0;
 178         hw_flow = false;
 179
 180         snprintf(mode_var_name, sizeof(mode_var_name), "modetty%u", uart);
 181         mode_var = fw_getenv(mode_var_name);
 182         if (mode_var) {
 183                 while (mode_var[0] >= '0' && mode_var[0] <= '9') {
 184                         baud *= 10;
 185                         baud += mode_var[0] - '0';
 186                         mode_var++;
 187                 }
 188                 if (mode_var[0] == ',')
 189                         mode_var++;
 190                 if (mode_var[0])
 191                         parity = mode_var[0];
 192                 if (mode_var[0] == ',')
 193                         mode_var++;
 194                 if (mode_var[0])
 195                         stop_bits = mode_var[0] - '0';
 196                 if (mode_var[0] == ',')
 197                         mode_var++;
 198                 if (!strcmp(mode_var, "hw"))
 199                         hw_flow = true;
 200         }
 201
 202         if (!baud)
 203                 baud = 38400;
 204
 205         if (parity != 'e' && parity != 'n' && parity != 'o')
 206                 parity = 'n';
 207
 208         if (stop_bits != 7 && stop_bits != 8)
 209                 stop_bits = 8;
 210
 211         WARN_ON(snprintf(path, sizeof(path), "serial%u:%u%c%u%s",
 212                          uart, baud, parity, stop_bits,
 213                          hw_flow ? "r" : "") >= sizeof(path));
 214
 215         /* find or add chosen node */
 216         chosen_off = fdt_path_offset(fdt, "/chosen");
 217         if (chosen_off == -FDT_ERR_NOTFOUND)
 218                 chosen_off = fdt_add_subnode(fdt, 0, "chosen");
 219         if (chosen_off < 0) {
 220                 pr_err("Unable to find or add DT chosen node: %d\n",
 221                        chosen_off);
 222                 return chosen_off;
 223         }
 224
 225         err = fdt_setprop_string(fdt, chosen_off, "stdout-path", path);
 226         if (err) {
 227                 pr_err("Unable to set stdout-path property: %d\n", err);
 228                 return err;
 229         }
 230
 231         return 0;
 232 }