binman: Support compression of sections
[platform/kernel/u-boot.git] / cmd / adtimg.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2018 Linaro Ltd.
4  * Sam Protsenko <semen.protsenko@linaro.org>
5  * Eugeniu Rosca <rosca.eugeniu@gmail.com>
6  */
7
8 #include <command.h>
9 #include <env.h>
10 #include <image-android-dt.h>
11 #include <common.h>
12
13 #define OPT_INDEX       "--index"
14
15 /*
16  * Current/working DTB/DTBO Android image address.
17  * Similar to 'working_fdt' variable in 'fdt' command.
18  */
19 static ulong working_img;
20
21 static int do_adtimg_addr(struct cmd_tbl *cmdtp, int flag, int argc,
22                           char *const argv[])
23 {
24         char *endp;
25         ulong hdr_addr;
26
27         if (argc != 2)
28                 return CMD_RET_USAGE;
29
30         hdr_addr = simple_strtoul(argv[1], &endp, 16);
31         if (*endp != '\0') {
32                 printf("Error: Wrong image address '%s'\n", argv[1]);
33                 return CMD_RET_FAILURE;
34         }
35
36         /*
37          * Allow users to set an address prior to copying the DTB/DTBO
38          * image to that same address, i.e. skip header verification.
39          */
40
41         working_img = hdr_addr;
42         return CMD_RET_SUCCESS;
43 }
44
45 static int adtimg_check_working_img(void)
46 {
47         if (!working_img) {
48                 printf("Error: Please, call 'adtimg addr <addr>'. Aborting!\n");
49                 return CMD_RET_FAILURE;
50         }
51
52         if (!android_dt_check_header(working_img)) {
53                 printf("Error: Invalid image header at 0x%lx\n", working_img);
54                 return CMD_RET_FAILURE;
55         }
56
57         return CMD_RET_SUCCESS;
58 }
59
60 static int do_adtimg_dump(struct cmd_tbl *cmdtp, int flag, int argc,
61                           char *const argv[])
62 {
63         if (argc != 1)
64                 return CMD_RET_USAGE;
65
66         if (adtimg_check_working_img() != CMD_RET_SUCCESS)
67                 return CMD_RET_FAILURE;
68
69         android_dt_print_contents(working_img);
70
71         return CMD_RET_SUCCESS;
72 }
73
74 static int adtimg_getopt_u32(char * const opt, char * const name, u32 *optval)
75 {
76         char *endp, *str;
77         u32 val;
78
79         if (!opt || !name || !optval)
80                 return CMD_RET_FAILURE;
81
82         str = strchr(opt, '=');
83         if (!str) {
84                 printf("Error: Option '%s' not followed by '='\n", name);
85                 return CMD_RET_FAILURE;
86         }
87
88         if (*++str == '\0') {
89                 printf("Error: Option '%s=' not followed by value\n", name);
90                 return CMD_RET_FAILURE;
91         }
92
93         val = simple_strtoul(str, &endp, 0);
94         if (*endp != '\0') {
95                 printf("Error: Wrong integer value '%s=%s'\n", name, str);
96                 return CMD_RET_FAILURE;
97         }
98
99         *optval = val;
100         return CMD_RET_SUCCESS;
101 }
102
103 static int adtimg_getopt_index(int argc, char *const argv[], u32 *index,
104                                char **avar, char **svar)
105 {
106         int ret;
107
108         if (!argv || !avar || !svar)
109                 return CMD_RET_FAILURE;
110
111         if (argc > 3) {
112                 printf("Error: Unexpected argument '%s'\n", argv[3]);
113                 return CMD_RET_FAILURE;
114         }
115
116         ret = adtimg_getopt_u32(argv[0], OPT_INDEX, index);
117         if (ret != CMD_RET_SUCCESS)
118                 return ret;
119
120         if (argc > 1)
121                 *avar = argv[1];
122         if (argc > 2)
123                 *svar = argv[2];
124
125         return CMD_RET_SUCCESS;
126 }
127
128 static int adtimg_get_dt_by_index(int argc, char *const argv[])
129 {
130         ulong addr;
131         u32 index, size;
132         int ret;
133         char *avar = NULL, *svar = NULL;
134
135         ret = adtimg_getopt_index(argc, argv, &index, &avar, &svar);
136         if (ret != CMD_RET_SUCCESS)
137                 return ret;
138
139         if (!android_dt_get_fdt_by_index(working_img, index, &addr, &size))
140                 return CMD_RET_FAILURE;
141
142         if (avar && svar) {
143                 ret = env_set_hex(avar, addr);
144                 if (ret) {
145                         printf("Error: Can't set '%s' to 0x%lx\n", avar, addr);
146                         return CMD_RET_FAILURE;
147                 }
148                 ret = env_set_hex(svar, size);
149                 if (ret) {
150                         printf("Error: Can't set '%s' to 0x%x\n", svar, size);
151                         return CMD_RET_FAILURE;
152                 }
153         } else if (avar) {
154                 ret = env_set_hex(avar, addr);
155                 if (ret) {
156                         printf("Error: Can't set '%s' to 0x%lx\n", avar, addr);
157                         return CMD_RET_FAILURE;
158                 }
159                 printf("0x%x (%d)\n", size, size);
160         } else {
161                 printf("0x%lx, 0x%x (%d)\n", addr, size, size);
162         }
163
164         return CMD_RET_SUCCESS;
165 }
166
167 static int adtimg_get_dt(int argc, char *const argv[])
168 {
169         if (argc < 2) {
170                 printf("Error: No options passed to '%s'\n", argv[0]);
171                 return CMD_RET_FAILURE;
172         }
173
174         /* Strip off leading 'dt' command argument */
175         argc--;
176         argv++;
177
178         if (!strncmp(argv[0], OPT_INDEX, sizeof(OPT_INDEX) - 1))
179                 return adtimg_get_dt_by_index(argc, argv);
180
181         printf("Error: Option '%s' not supported\n", argv[0]);
182         return CMD_RET_FAILURE;
183 }
184
185 static int do_adtimg_get(struct cmd_tbl *cmdtp, int flag, int argc,
186                          char *const argv[])
187 {
188         if (argc < 2) {
189                 printf("Error: No arguments passed to '%s'\n", argv[0]);
190                 return CMD_RET_FAILURE;
191         }
192
193         if (adtimg_check_working_img() != CMD_RET_SUCCESS)
194                 return CMD_RET_FAILURE;
195
196         /* Strip off leading 'get' command argument */
197         argc--;
198         argv++;
199
200         if (!strcmp(argv[0], "dt"))
201                 return adtimg_get_dt(argc, argv);
202
203         printf("Error: Wrong argument '%s'\n", argv[0]);
204         return CMD_RET_FAILURE;
205 }
206
207 static struct cmd_tbl cmd_adtimg_sub[] = {
208         U_BOOT_CMD_MKENT(addr, CONFIG_SYS_MAXARGS, 1, do_adtimg_addr, "", ""),
209         U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_adtimg_dump, "", ""),
210         U_BOOT_CMD_MKENT(get, CONFIG_SYS_MAXARGS, 1, do_adtimg_get, "", ""),
211 };
212
213 static int do_adtimg(struct cmd_tbl *cmdtp, int flag, int argc,
214                      char *const argv[])
215 {
216         struct cmd_tbl *cp;
217
218         cp = find_cmd_tbl(argv[1], cmd_adtimg_sub, ARRAY_SIZE(cmd_adtimg_sub));
219
220         /* Strip off leading 'adtimg' command argument */
221         argc--;
222         argv++;
223
224         if (!cp || argc > cp->maxargs)
225                 return CMD_RET_USAGE;
226         if (flag == CMD_FLAG_REPEAT && !cmd_is_repeatable(cp))
227                 return CMD_RET_SUCCESS;
228
229         return cp->cmd(cmdtp, flag, argc, argv);
230 }
231
232 U_BOOT_CMD(
233         adtimg, CONFIG_SYS_MAXARGS, 0, do_adtimg,
234         "manipulate dtb/dtbo Android image",
235         "addr <addr> - Set image location to <addr>\n"
236         "adtimg dump        - Print out image contents\n"
237         "adtimg get dt --index=<index> [avar [svar]]         - Get DT address/size by index\n"
238         "\n"
239         "Legend:\n"
240         "  - <addr>: DTB/DTBO image address (hex) in RAM\n"
241         "  - <index>: index (hex/dec) of desired DT in the image\n"
242         "  - <avar>: variable name to contain DT address (hex)\n"
243         "  - <svar>: variable name to contain DT size (hex)"
244 );