cmd/cedit.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * 'cedit' command
   4  *
   5  * Copyright 2023 Google LLC
   6  * Written by Simon Glass <[email protected]>
   7  */
   8
   9 #include <common.h>
  10 #include <abuf.h>
  11 #include <cedit.h>
  12 #include <command.h>
  13 #include <expo.h>
  14 #include <fs.h>
  15 #include <malloc.h>
  16 #include <mapmem.h>
  17 #include <dm/ofnode.h>
  18 #include <linux/sizes.h>
  19
  20 struct expo *cur_exp;
  21
  22 static int check_cur_expo(void)
  23 {
  24         if (!cur_exp) {
  25                 printf("No expo loaded\n");
  26                 return -ENOENT;
  27         }
  28
  29         return 0;
  30 }
  31
  32 static int do_cedit_load(struct cmd_tbl *cmdtp, int flag, int argc,
  33                          char *const argv[])
  34 {
  35         const char *fname;
  36         struct expo *exp;
  37         oftree tree;
  38         ulong size;
  39         void *buf;
  40         int ret;
  41
  42         if (argc < 4)
  43                 return CMD_RET_USAGE;
  44         fname = argv[3];
  45
  46         ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
  47         if (ret) {
  48                 printf("File not found\n");
  49                 return CMD_RET_FAILURE;
  50         }
  51
  52         tree = oftree_from_fdt(buf);
  53         if (!oftree_valid(tree)) {
  54                 printf("Cannot create oftree\n");
  55                 return CMD_RET_FAILURE;
  56         }
  57
  58         ret = expo_build(oftree_root(tree), &exp);
  59         oftree_dispose(tree);
  60         if (ret) {
  61                 printf("Failed to build expo: %dE\n", ret);
  62                 return CMD_RET_FAILURE;
  63         }
  64
  65         cur_exp = exp;
  66
  67         return 0;
  68 }
  69
  70 static int do_cedit_write_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
  71                               char *const argv[])
  72 {
  73         const char *fname;
  74         struct abuf buf;
  75         loff_t bytes;
  76         int ret;
  77
  78         if (argc < 4)
  79                 return CMD_RET_USAGE;
  80         fname = argv[3];
  81
  82         if (check_cur_expo())
  83                 return CMD_RET_FAILURE;
  84
  85         ret = cedit_write_settings(cur_exp, &buf);
  86         if (ret) {
  87                 printf("Failed to write settings: %dE\n", ret);
  88                 return CMD_RET_FAILURE;
  89         }
  90
  91         if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
  92                 return CMD_RET_FAILURE;
  93
  94         ret = fs_write(fname, map_to_sysmem(abuf_data(&buf)), 0,
  95                        abuf_size(&buf), &bytes);
  96         if (ret)
  97                 return CMD_RET_FAILURE;
  98
  99         return 0;
 100 }
 101
 102 static int do_cedit_read_fdt(struct cmd_tbl *cmdtp, int flag, int argc,
 103                              char *const argv[])
 104 {
 105         const char *fname;
 106         void *buf;
 107         oftree tree;
 108         ulong size;
 109         int ret;
 110
 111         if (argc < 4)
 112                 return CMD_RET_USAGE;
 113         fname = argv[3];
 114
 115         ret = fs_load_alloc(argv[1], argv[2], argv[3], SZ_1M, 0, &buf, &size);
 116         if (ret) {
 117                 printf("File not found\n");
 118                 return CMD_RET_FAILURE;
 119         }
 120
 121         tree = oftree_from_fdt(buf);
 122         if (!oftree_valid(tree)) {
 123                 free(buf);
 124                 printf("Cannot create oftree\n");
 125                 return CMD_RET_FAILURE;
 126         }
 127
 128         ret = cedit_read_settings(cur_exp, tree);
 129         oftree_dispose(tree);
 130         free(buf);
 131         if (ret) {
 132                 printf("Failed to read settings: %dE\n", ret);
 133                 return CMD_RET_FAILURE;
 134         }
 135
 136         return 0;
 137 }
 138
 139 static int do_cedit_write_env(struct cmd_tbl *cmdtp, int flag, int argc,
 140                               char *const argv[])
 141 {
 142         bool verbose;
 143         int ret;
 144
 145         if (check_cur_expo())
 146                 return CMD_RET_FAILURE;
 147
 148         verbose = argc > 1 && !strcmp(argv[1], "-v");
 149
 150         ret = cedit_write_settings_env(cur_exp, verbose);
 151         if (ret) {
 152                 printf("Failed to write settings to environment: %dE\n", ret);
 153                 return CMD_RET_FAILURE;
 154         }
 155
 156         return 0;
 157 }
 158
 159 static int do_cedit_run(struct cmd_tbl *cmdtp, int flag, int argc,
 160                         char *const argv[])
 161 {
 162         ofnode node;
 163         int ret;
 164
 165         if (check_cur_expo())
 166                 return CMD_RET_FAILURE;
 167
 168         node = ofnode_path("/bootstd/cedit-theme");
 169         if (ofnode_valid(node)) {
 170                 ret = expo_apply_theme(cur_exp, node);
 171                 if (ret)
 172                         return CMD_RET_FAILURE;
 173         } else {
 174                 log_warning("No theme found\n");
 175         }
 176         ret = cedit_run(cur_exp);
 177         if (ret) {
 178                 log_err("Failed (err=%dE)\n", ret);
 179                 return CMD_RET_FAILURE;
 180         }
 181
 182         return 0;
 183 }
 184
 185 #ifdef CONFIG_SYS_LONGHELP
 186 static char cedit_help_text[] =
 187         "load <interface> <dev[:part]> <filename>   - load config editor\n"
 188         "cedit read_fdt <i/f> <dev[:part]> <filename>     - read settings\n"
 189         "cedit write_fdt <i/f> <dev[:part]> <filename>    - write settings\n"
 190         "cedit write_env [-v]                             - write settings to env vars\n"
 191         "cedit run                                        - run config editor";
 192 #endif /* CONFIG_SYS_LONGHELP */
 193
 194 U_BOOT_CMD_WITH_SUBCMDS(cedit, "Configuration editor", cedit_help_text,
 195         U_BOOT_SUBCMD_MKENT(load, 5, 1, do_cedit_load),
 196         U_BOOT_SUBCMD_MKENT(read_fdt, 5, 1, do_cedit_read_fdt),
 197         U_BOOT_SUBCMD_MKENT(write_fdt, 5, 1, do_cedit_write_fdt),
 198         U_BOOT_SUBCMD_MKENT(write_env, 2, 1, do_cedit_write_env),
 199         U_BOOT_SUBCMD_MKENT(run, 1, 1, do_cedit_run),
 200 );