mips/generic/yamon-dt.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Copyright (C) 2016 Imagination Technologies
0004  * Author: Paul Burton <paul.burton@mips.com>
0005  */
0006
0007 #define pr_fmt(fmt) "yamon-dt: " fmt
0008
0009 #include <linux/bug.h>
0010 #include <linux/errno.h>
0011 #include <linux/kernel.h>
0012 #include <linux/libfdt.h>
0013 #include <linux/printk.h>
0014
0015 #include <asm/fw/fw.h>
0016 #include <asm/yamon-dt.h>
0017
0018 #define MAX_MEM_ARRAY_ENTRIES   2
0019
0020 __init int yamon_dt_append_cmdline(void *fdt)
0021 {
0022     int err, chosen_off;
0023
0024     /* find or add chosen node */
0025     chosen_off = fdt_path_offset(fdt, "/chosen");
0026     if (chosen_off == -FDT_ERR_NOTFOUND)
0027         chosen_off = fdt_add_subnode(fdt, 0, "chosen");
0028     if (chosen_off < 0) {
0029         pr_err("Unable to find or add DT chosen node: %d\n",
0030                chosen_off);
0031         return chosen_off;
0032     }
0033
0034     err = fdt_setprop_string(fdt, chosen_off, "bootargs", fw_getcmdline());
0035     if (err) {
0036         pr_err("Unable to set bootargs property: %d\n", err);
0037         return err;
0038     }
0039
0040     return 0;
0041 }
0042
0043 static unsigned int __init gen_fdt_mem_array(
0044                     const struct yamon_mem_region *regions,
0045                     __be32 *mem_array,
0046                     unsigned int max_entries,
0047                     unsigned long memsize)
0048 {
0049     const struct yamon_mem_region *mr;
0050     unsigned long size;
0051     unsigned int entries = 0;
0052
0053     for (mr = regions; mr->size && memsize; ++mr) {
0054         if (entries >= max_entries) {
0055             pr_warn("Number of regions exceeds max %u\n",
0056                 max_entries);
0057             break;
0058         }
0059
0060         /* How much of the remaining RAM fits in the next region? */
0061         size = min_t(unsigned long, memsize, mr->size);
0062         memsize -= size;
0063
0064         /* Emit a memory region */
0065         *(mem_array++) = cpu_to_be32(mr->start);
0066         *(mem_array++) = cpu_to_be32(size);
0067         ++entries;
0068
0069         /* Discard the next mr->discard bytes */
0070         memsize -= min_t(unsigned long, memsize, mr->discard);
0071     }
0072     return entries;
0073 }
0074
0075 __init int yamon_dt_append_memory(void *fdt,
0076                   const struct yamon_mem_region *regions)
0077 {
0078     unsigned long phys_memsize = 0, memsize;
0079     __be32 mem_array[2 * MAX_MEM_ARRAY_ENTRIES];
0080     unsigned int mem_entries;
0081     int i, err, mem_off;
0082     char *var, param_name[10], *var_names[] = {
0083         "ememsize", "memsize",
0084     };
0085
0086     /* find memory size from the bootloader environment */
0087     for (i = 0; i < ARRAY_SIZE(var_names); i++) {
0088         var = fw_getenv(var_names[i]);
0089         if (!var)
0090             continue;
0091
0092         err = kstrtoul(var, 0, &phys_memsize);
0093         if (!err)
0094             break;
0095
0096         pr_warn("Failed to read the '%s' env variable '%s'\n",
0097             var_names[i], var);
0098     }
0099
0100     if (!phys_memsize) {
0101         pr_warn("The bootloader didn't provide memsize: defaulting to 32MB\n");
0102         phys_memsize = 32 << 20;
0103     }
0104
0105     /* default to using all available RAM */
0106     memsize = phys_memsize;
0107
0108     /* allow the user to override the usable memory */
0109     for (i = 0; i < ARRAY_SIZE(var_names); i++) {
0110         snprintf(param_name, sizeof(param_name), "%s=", var_names[i]);
0111         var = strstr(arcs_cmdline, param_name);
0112         if (!var)
0113             continue;
0114
0115         memsize = memparse(var + strlen(param_name), NULL);
0116     }
0117
0118     /* if the user says there's more RAM than we thought, believe them */
0119     phys_memsize = max_t(unsigned long, phys_memsize, memsize);
0120
0121     /* find or add a memory node */
0122     mem_off = fdt_path_offset(fdt, "/memory");
0123     if (mem_off == -FDT_ERR_NOTFOUND)
0124         mem_off = fdt_add_subnode(fdt, 0, "memory");
0125     if (mem_off < 0) {
0126         pr_err("Unable to find or add memory DT node: %d\n", mem_off);
0127         return mem_off;
0128     }
0129
0130     err = fdt_setprop_string(fdt, mem_off, "device_type", "memory");
0131     if (err) {
0132         pr_err("Unable to set memory node device_type: %d\n", err);
0133         return err;
0134     }
0135
0136     mem_entries = gen_fdt_mem_array(regions, mem_array,
0137                     MAX_MEM_ARRAY_ENTRIES, phys_memsize);
0138     err = fdt_setprop(fdt, mem_off, "reg",
0139               mem_array, mem_entries * 2 * sizeof(mem_array[0]));
0140     if (err) {
0141         pr_err("Unable to set memory regs property: %d\n", err);
0142         return err;
0143     }
0144
0145     mem_entries = gen_fdt_mem_array(regions, mem_array,
0146                     MAX_MEM_ARRAY_ENTRIES, memsize);
0147     err = fdt_setprop(fdt, mem_off, "linux,usable-memory",
0148               mem_array, mem_entries * 2 * sizeof(mem_array[0]));
0149     if (err) {
0150         pr_err("Unable to set linux,usable-memory property: %d\n", err);
0151         return err;
0152     }
0153
0154     return 0;
0155 }
0156
0157 __init int yamon_dt_serial_config(void *fdt)
0158 {
0159     const char *yamontty, *mode_var;
0160     char mode_var_name[9], path[20], parity;
0161     unsigned int uart, baud, stop_bits;
0162     bool hw_flow;
0163     int chosen_off, err;
0164
0165     yamontty = fw_getenv("yamontty");
0166     if (!yamontty || !strcmp(yamontty, "tty0")) {
0167         uart = 0;
0168     } else if (!strcmp(yamontty, "tty1")) {
0169         uart = 1;
0170     } else {
0171         pr_warn("yamontty environment variable '%s' invalid\n",
0172             yamontty);
0173         uart = 0;
0174     }
0175
0176     baud = stop_bits = 0;
0177     parity = 0;
0178     hw_flow = false;
0179
0180     snprintf(mode_var_name, sizeof(mode_var_name), "modetty%u", uart);
0181     mode_var = fw_getenv(mode_var_name);
0182     if (mode_var) {
0183         while (mode_var[0] >= '0' && mode_var[0] <= '9') {
0184             baud *= 10;
0185             baud += mode_var[0] - '0';
0186             mode_var++;
0187         }
0188         if (mode_var[0] == ',')
0189             mode_var++;
0190         if (mode_var[0])
0191             parity = mode_var[0];
0192         if (mode_var[0] == ',')
0193             mode_var++;
0194         if (mode_var[0])
0195             stop_bits = mode_var[0] - '0';
0196         if (mode_var[0] == ',')
0197             mode_var++;
0198         if (!strcmp(mode_var, "hw"))
0199             hw_flow = true;
0200     }
0201
0202     if (!baud)
0203         baud = 38400;
0204
0205     if (parity != 'e' && parity != 'n' && parity != 'o')
0206         parity = 'n';
0207
0208     if (stop_bits != 7 && stop_bits != 8)
0209         stop_bits = 8;
0210
0211     WARN_ON(snprintf(path, sizeof(path), "serial%u:%u%c%u%s",
0212              uart, baud, parity, stop_bits,
0213              hw_flow ? "r" : "") >= sizeof(path));
0214
0215     /* find or add chosen node */
0216     chosen_off = fdt_path_offset(fdt, "/chosen");
0217     if (chosen_off == -FDT_ERR_NOTFOUND)
0218         chosen_off = fdt_add_subnode(fdt, 0, "chosen");
0219     if (chosen_off < 0) {
0220         pr_err("Unable to find or add DT chosen node: %d\n",
0221                chosen_off);
0222         return chosen_off;
0223     }
0224
0225     err = fdt_setprop_string(fdt, chosen_off, "stdout-path", path);
0226     if (err) {
0227         pr_err("Unable to set stdout-path property: %d\n", err);
0228         return err;
0229     }
0230
0231     return 0;
0232 }