1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2019 Eugeniu Rosca <rosca.eugeniu@gmail.com>
4 *
5 * Command to read/modify/write Android BCB fields
6 */
7
8 #include <android_bootloader_message.h>
9 #include <bcb.h>
10 #include <command.h>
11 #include <common.h>
12 #include <display_options.h>
13 #include <log.h>
14 #include <part.h>
15 #include <malloc.h>
16 #include <memalign.h>
17 #include <linux/err.h>
18
19 enum bcb_cmd {
20 BCB_CMD_LOAD,
21 BCB_CMD_FIELD_SET,
22 BCB_CMD_FIELD_CLEAR,
23 BCB_CMD_FIELD_TEST,
24 BCB_CMD_FIELD_DUMP,
25 BCB_CMD_STORE,
26 };
27
28 static int bcb_dev = -1;
29 static int bcb_part = -1;
30 static struct bootloader_message bcb __aligned(ARCH_DMA_MINALIGN) = { { 0 } };
31
bcb_cmd_get(char * cmd)32 static int bcb_cmd_get(char *cmd)
33 {
34 if (!strcmp(cmd, "load"))
35 return BCB_CMD_LOAD;
36 if (!strcmp(cmd, "set"))
37 return BCB_CMD_FIELD_SET;
38 if (!strcmp(cmd, "clear"))
39 return BCB_CMD_FIELD_CLEAR;
40 if (!strcmp(cmd, "test"))
41 return BCB_CMD_FIELD_TEST;
42 if (!strcmp(cmd, "store"))
43 return BCB_CMD_STORE;
44 if (!strcmp(cmd, "dump"))
45 return BCB_CMD_FIELD_DUMP;
46 else
47 return -1;
48 }
49
bcb_is_misused(int argc,char * const argv[])50 static int bcb_is_misused(int argc, char *const argv[])
51 {
52 int cmd = bcb_cmd_get(argv[0]);
53
54 switch (cmd) {
55 case BCB_CMD_LOAD:
56 case BCB_CMD_FIELD_SET:
57 if (argc != 3)
58 goto err;
59 break;
60 case BCB_CMD_FIELD_TEST:
61 if (argc != 4)
62 goto err;
63 break;
64 case BCB_CMD_FIELD_CLEAR:
65 if (argc != 1 && argc != 2)
66 goto err;
67 break;
68 case BCB_CMD_STORE:
69 if (argc != 1)
70 goto err;
71 break;
72 case BCB_CMD_FIELD_DUMP:
73 if (argc != 2)
74 goto err;
75 break;
76 default:
77 printf("Error: 'bcb %s' not supported\n", argv[0]);
78 return -1;
79 }
80
81 if (cmd != BCB_CMD_LOAD && (bcb_dev < 0 || bcb_part < 0)) {
82 printf("Error: Please, load BCB first!\n");
83 return -1;
84 }
85
86 return 0;
87 err:
88 printf("Error: Bad usage of 'bcb %s'\n", argv[0]);
89
90 return -1;
91 }
92
bcb_field_get(char * name,char ** fieldp,int * sizep)93 static int bcb_field_get(char *name, char **fieldp, int *sizep)
94 {
95 if (!strcmp(name, "command")) {
96 *fieldp = bcb.command;
97 *sizep = sizeof(bcb.command);
98 } else if (!strcmp(name, "status")) {
99 *fieldp = bcb.status;
100 *sizep = sizeof(bcb.status);
101 } else if (!strcmp(name, "recovery")) {
102 *fieldp = bcb.recovery;
103 *sizep = sizeof(bcb.recovery);
104 } else if (!strcmp(name, "stage")) {
105 *fieldp = bcb.stage;
106 *sizep = sizeof(bcb.stage);
107 } else if (!strcmp(name, "reserved")) {
108 *fieldp = bcb.reserved;
109 *sizep = sizeof(bcb.reserved);
110 } else {
111 printf("Error: Unknown bcb field '%s'\n", name);
112 return -1;
113 }
114
115 return 0;
116 }
117
__bcb_load(int devnum,const char * partp)118 static int __bcb_load(int devnum, const char *partp)
119 {
120 struct blk_desc *desc;
121 struct disk_partition info;
122 u64 cnt;
123 char *endp;
124 int part, ret;
125
126 desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, devnum);
127 if (!desc) {
128 ret = -ENODEV;
129 goto err_read_fail;
130 }
131
132 /*
133 * always select the USER mmc hwpart in case another
134 * blk operation selected a different hwpart
135 */
136 ret = blk_dselect_hwpart(desc, 0);
137 if (IS_ERR_VALUE(ret)) {
138 ret = -ENODEV;
139 goto err_read_fail;
140 }
141
142 part = simple_strtoul(partp, &endp, 0);
143 if (*endp == '\0') {
144 ret = part_get_info(desc, part, &info);
145 if (ret)
146 goto err_read_fail;
147 } else {
148 part = part_get_info_by_name(desc, partp, &info);
149 if (part < 0) {
150 ret = part;
151 goto err_read_fail;
152 }
153 }
154
155 cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), info.blksz);
156 if (cnt > info.size)
157 goto err_too_small;
158
159 if (blk_dread(desc, info.start, cnt, &bcb) != cnt) {
160 ret = -EIO;
161 goto err_read_fail;
162 }
163
164 bcb_dev = desc->devnum;
165 bcb_part = part;
166 debug("%s: Loaded from mmc %d:%d\n", __func__, bcb_dev, bcb_part);
167
168 return CMD_RET_SUCCESS;
169 err_read_fail:
170 printf("Error: mmc %d:%s read failed (%d)\n", devnum, partp, ret);
171 goto err;
172 err_too_small:
173 printf("Error: mmc %d:%s too small!", devnum, partp);
174 goto err;
175 err:
176 bcb_dev = -1;
177 bcb_part = -1;
178
179 return CMD_RET_FAILURE;
180 }
181
do_bcb_load(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])182 static int do_bcb_load(struct cmd_tbl *cmdtp, int flag, int argc,
183 char * const argv[])
184 {
185 char *endp;
186 int devnum = simple_strtoul(argv[1], &endp, 0);
187
188 if (*endp != '\0') {
189 printf("Error: Device id '%s' not a number\n", argv[1]);
190 return CMD_RET_FAILURE;
191 }
192
193 return __bcb_load(devnum, argv[2]);
194 }
195
__bcb_set(char * fieldp,const char * valp)196 static int __bcb_set(char *fieldp, const char *valp)
197 {
198 int size, len;
199 char *field, *str, *found, *tmp;
200
201 if (bcb_field_get(fieldp, &field, &size))
202 return CMD_RET_FAILURE;
203
204 len = strlen(valp);
205 if (len >= size) {
206 printf("Error: sizeof('%s') = %d >= %d = sizeof(bcb.%s)\n",
207 valp, len, size, fieldp);
208 return CMD_RET_FAILURE;
209 }
210 str = strdup(valp);
211 if (!str) {
212 printf("Error: Out of memory while strdup\n");
213 return CMD_RET_FAILURE;
214 }
215
216 tmp = str;
217 field[0] = '\0';
218 while ((found = strsep(&tmp, ":"))) {
219 if (field[0] != '\0')
220 strcat(field, "\n");
221 strcat(field, found);
222 }
223 free(str);
224
225 return CMD_RET_SUCCESS;
226 }
227
do_bcb_set(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])228 static int do_bcb_set(struct cmd_tbl *cmdtp, int flag, int argc,
229 char * const argv[])
230 {
231 return __bcb_set(argv[1], argv[2]);
232 }
233
do_bcb_clear(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])234 static int do_bcb_clear(struct cmd_tbl *cmdtp, int flag, int argc,
235 char *const argv[])
236 {
237 int size;
238 char *field;
239
240 if (argc == 1) {
241 memset(&bcb, 0, sizeof(bcb));
242 return CMD_RET_SUCCESS;
243 }
244
245 if (bcb_field_get(argv[1], &field, &size))
246 return CMD_RET_FAILURE;
247
248 memset(field, 0, size);
249
250 return CMD_RET_SUCCESS;
251 }
252
do_bcb_test(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])253 static int do_bcb_test(struct cmd_tbl *cmdtp, int flag, int argc,
254 char *const argv[])
255 {
256 int size;
257 char *field;
258 char *op = argv[2];
259
260 if (bcb_field_get(argv[1], &field, &size))
261 return CMD_RET_FAILURE;
262
263 if (*op == '=' && *(op + 1) == '\0') {
264 if (!strncmp(argv[3], field, size))
265 return CMD_RET_SUCCESS;
266 else
267 return CMD_RET_FAILURE;
268 } else if (*op == '~' && *(op + 1) == '\0') {
269 if (!strstr(field, argv[3]))
270 return CMD_RET_FAILURE;
271 else
272 return CMD_RET_SUCCESS;
273 } else {
274 printf("Error: Unknown operator '%s'\n", op);
275 }
276
277 return CMD_RET_FAILURE;
278 }
279
do_bcb_dump(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])280 static int do_bcb_dump(struct cmd_tbl *cmdtp, int flag, int argc,
281 char *const argv[])
282 {
283 int size;
284 char *field;
285
286 if (bcb_field_get(argv[1], &field, &size))
287 return CMD_RET_FAILURE;
288
289 print_buffer((ulong)field - (ulong)&bcb, (void *)field, 1, size, 16);
290
291 return CMD_RET_SUCCESS;
292 }
293
__bcb_store(void)294 static int __bcb_store(void)
295 {
296 struct blk_desc *desc;
297 struct disk_partition info;
298 u64 cnt;
299 int ret;
300
301 desc = blk_get_devnum_by_uclass_id(UCLASS_MMC, bcb_dev);
302 if (!desc) {
303 ret = -ENODEV;
304 goto err;
305 }
306
307 ret = part_get_info(desc, bcb_part, &info);
308 if (ret)
309 goto err;
310
311 cnt = DIV_ROUND_UP(sizeof(struct bootloader_message), info.blksz);
312
313 if (blk_dwrite(desc, info.start, cnt, &bcb) != cnt) {
314 ret = -EIO;
315 goto err;
316 }
317
318 return CMD_RET_SUCCESS;
319 err:
320 printf("Error: mmc %d:%d write failed (%d)\n", bcb_dev, bcb_part, ret);
321
322 return CMD_RET_FAILURE;
323 }
324
do_bcb_store(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])325 static int do_bcb_store(struct cmd_tbl *cmdtp, int flag, int argc,
326 char * const argv[])
327 {
328 return __bcb_store();
329 }
330
bcb_write_reboot_reason(int devnum,char * partp,const char * reasonp)331 int bcb_write_reboot_reason(int devnum, char *partp, const char *reasonp)
332 {
333 int ret;
334
335 ret = __bcb_load(devnum, partp);
336 if (ret != CMD_RET_SUCCESS)
337 return ret;
338
339 ret = __bcb_set("command", reasonp);
340 if (ret != CMD_RET_SUCCESS)
341 return ret;
342
343 ret = __bcb_store();
344 if (ret != CMD_RET_SUCCESS)
345 return ret;
346
347 return 0;
348 }
349
350 static struct cmd_tbl cmd_bcb_sub[] = {
351 U_BOOT_CMD_MKENT(load, CONFIG_SYS_MAXARGS, 1, do_bcb_load, "", ""),
352 U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 1, do_bcb_set, "", ""),
353 U_BOOT_CMD_MKENT(clear, CONFIG_SYS_MAXARGS, 1, do_bcb_clear, "", ""),
354 U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_bcb_test, "", ""),
355 U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_bcb_dump, "", ""),
356 U_BOOT_CMD_MKENT(store, CONFIG_SYS_MAXARGS, 1, do_bcb_store, "", ""),
357 };
358
do_bcb(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])359 static int do_bcb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
360 {
361 struct cmd_tbl *c;
362
363 if (argc < 2)
364 return CMD_RET_USAGE;
365
366 argc--;
367 argv++;
368
369 c = find_cmd_tbl(argv[0], cmd_bcb_sub, ARRAY_SIZE(cmd_bcb_sub));
370 if (!c)
371 return CMD_RET_USAGE;
372
373 if (bcb_is_misused(argc, argv)) {
374 /*
375 * We try to improve the user experience by reporting the
376 * root-cause of misusage, so don't return CMD_RET_USAGE,
377 * since the latter prints out the full-blown help text
378 */
379 return CMD_RET_FAILURE;
380 }
381
382 return c->cmd(cmdtp, flag, argc, argv);
383 }
384
385 U_BOOT_CMD(
386 bcb, CONFIG_SYS_MAXARGS, 1, do_bcb,
387 "Load/set/clear/test/dump/store Android BCB fields",
388 "load <dev> <part> - load BCB from mmc <dev>:<part>\n"
389 "bcb set <field> <val> - set BCB <field> to <val>\n"
390 "bcb clear [<field>] - clear BCB <field> or all fields\n"
391 "bcb test <field> <op> <val> - test BCB <field> against <val>\n"
392 "bcb dump <field> - dump BCB <field>\n"
393 "bcb store - store BCB back to mmc\n"
394 "\n"
395 "Legend:\n"
396 "<dev> - MMC device index containing the BCB partition\n"
397 "<part> - MMC partition index or name containing the BCB\n"
398 "<field> - one of {command,status,recovery,stage,reserved}\n"
399 "<op> - the binary operator used in 'bcb test':\n"
400 " '=' returns true if <val> matches the string stored in <field>\n"
401 " '~' returns true if <val> matches a subset of <field>'s string\n"
402 "<val> - string/text provided as input to bcb {set,test}\n"
403 " NOTE: any ':' character in <val> will be replaced by line feed\n"
404 " during 'bcb set' and used as separator by upper layers\n"
405 );
406