test/boot/bootflow.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Test for bootdev functions. All start with 'bootdev'
   4  *
   5  * Copyright 2021 Google LLC
   6  * Written by Simon Glass <[email protected]>
   7  */
   8
   9 #include <common.h>
  10 #include <bootdev.h>
  11 #include <bootflow.h>
  12 #include <bootmeth.h>
  13 #include <bootstd.h>
  14 #include <cli.h>
  15 #include <dm.h>
  16 #include <expo.h>
  17 #ifdef CONFIG_SANDBOX
  18 #include <asm/test.h>
  19 #endif
  20 #include <dm/device-internal.h>
  21 #include <dm/lists.h>
  22 #include <test/suites.h>
  23 #include <test/ut.h>
  24 #include "bootstd_common.h"
  25 #include "../../boot/bootflow_internal.h"
  26 #include "../../boot/scene_internal.h"
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 extern U_BOOT_DRIVER(bootmeth_script);
  31
  32 static int inject_response(struct unit_test_state *uts)
  33 {
  34         /*
  35          * The image being booted presents a menu of options:
  36          *
  37          * Fedora-Workstation-armhfp-31-1.9 Boot Options.
  38          * 1:   Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)
  39          * Enter choice:
  40          *
  41          * Provide input for this, to avoid waiting two seconds for a timeout.
  42          */
  43         ut_asserteq(2, console_in_puts("1\n"));
  44
  45         return 0;
  46 }
  47
  48 /* Check 'bootflow scan/list' commands */
  49 static int bootflow_cmd(struct unit_test_state *uts)
  50 {
  51         console_record_reset_enable();
  52         ut_assertok(run_command("bootdev select 1", 0));
  53         ut_assert_console_end();
  54         ut_assertok(run_command("bootflow scan -lH", 0));
  55         ut_assert_nextline("Scanning for bootflows in bootdev 'mmc1.bootdev'");
  56         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
  57         ut_assert_nextlinen("---");
  58         ut_assert_nextline("  0  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
  59         ut_assert_nextlinen("---");
  60         ut_assert_nextline("(1 bootflow, 1 valid)");
  61         ut_assert_console_end();
  62
  63         ut_assertok(run_command("bootflow list", 0));
  64         ut_assert_nextline("Showing bootflows for bootdev 'mmc1.bootdev'");
  65         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
  66         ut_assert_nextlinen("---");
  67         ut_assert_nextline("  0  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
  68         ut_assert_nextlinen("---");
  69         ut_assert_nextline("(1 bootflow, 1 valid)");
  70         ut_assert_console_end();
  71
  72         return 0;
  73 }
  74 BOOTSTD_TEST(bootflow_cmd, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
  75
  76 /* Check 'bootflow scan' with a name / label / seq */
  77 static int bootflow_cmd_label(struct unit_test_state *uts)
  78 {
  79         console_record_reset_enable();
  80         ut_assertok(run_command("bootflow scan -lH mmc1", 0));
  81         ut_assert_nextline("Scanning for bootflows in bootdev 'mmc1.bootdev'");
  82         ut_assert_skip_to_line("(1 bootflow, 1 valid)");
  83         ut_assert_console_end();
  84
  85         ut_assertok(run_command("bootflow scan -lH mmc0.bootdev", 0));
  86         ut_assert_nextline("Scanning for bootflows in bootdev 'mmc0.bootdev'");
  87         ut_assert_skip_to_line("(0 bootflows, 0 valid)");
  88         ut_assert_console_end();
  89
  90         ut_assertok(run_command("bootflow scan -lH 0", 0));
  91         ut_assert_nextline("Scanning for bootflows in bootdev 'mmc2.bootdev'");
  92         ut_assert_skip_to_line("(0 bootflows, 0 valid)");
  93         ut_assert_console_end();
  94
  95         return 0;
  96 }
  97 BOOTSTD_TEST(bootflow_cmd_label, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
  98
  99 /* Check 'bootflow scan/list' commands using all bootdevs */
 100 static int bootflow_cmd_glob(struct unit_test_state *uts)
 101 {
 102         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 103
 104         console_record_reset_enable();
 105         ut_assertok(run_command("bootflow scan -lGH", 0));
 106         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 107         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
 108         ut_assert_nextlinen("---");
 109         ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
 110         ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
 111         ut_assert_nextline("  0  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
 112         ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
 113         ut_assert_nextline("No more bootdevs");
 114         ut_assert_nextlinen("---");
 115         ut_assert_nextline("(1 bootflow, 1 valid)");
 116         ut_assert_console_end();
 117
 118         ut_assertok(run_command("bootflow list", 0));
 119         ut_assert_nextline("Showing all bootflows");
 120         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
 121         ut_assert_nextlinen("---");
 122         ut_assert_nextline("  0  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
 123         ut_assert_nextlinen("---");
 124         ut_assert_nextline("(1 bootflow, 1 valid)");
 125         ut_assert_console_end();
 126
 127         return 0;
 128 }
 129 BOOTSTD_TEST(bootflow_cmd_glob, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 130
 131 /* Check 'bootflow scan -e' */
 132 static int bootflow_cmd_scan_e(struct unit_test_state *uts)
 133 {
 134         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 135
 136         console_record_reset_enable();
 137         ut_assertok(run_command("bootflow scan -aleGH", 0));
 138         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 139         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
 140         ut_assert_nextlinen("---");
 141         ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
 142         ut_assert_nextline("  0  syslinux     media   mmc          0  mmc2.bootdev.whole        <NULL>");
 143         ut_assert_nextline("     ** No partition found, err=-93");
 144         ut_assert_nextline("  1  efi          media   mmc          0  mmc2.bootdev.whole        <NULL>");
 145         ut_assert_nextline("     ** No partition found, err=-93");
 146
 147         ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
 148         ut_assert_nextline("  2  syslinux     media   mmc          0  mmc1.bootdev.whole        <NULL>");
 149         ut_assert_nextline("     ** No partition found, err=-2");
 150         ut_assert_nextline("  3  efi          media   mmc          0  mmc1.bootdev.whole        <NULL>");
 151         ut_assert_nextline("     ** No partition found, err=-2");
 152         ut_assert_nextline("  4  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
 153         ut_assert_nextline("  5  efi          fs      mmc          1  mmc1.bootdev.part_1       efi/boot/bootsbox.efi");
 154
 155         ut_assert_skip_to_line("Scanning bootdev 'mmc0.bootdev':");
 156         ut_assert_skip_to_line(" 3f  efi          media   mmc          0  mmc0.bootdev.whole        <NULL>");
 157         ut_assert_nextline("     ** No partition found, err=-93");
 158         ut_assert_nextline("No more bootdevs");
 159         ut_assert_nextlinen("---");
 160         ut_assert_nextline("(64 bootflows, 1 valid)");
 161         ut_assert_console_end();
 162
 163         ut_assertok(run_command("bootflow list", 0));
 164         ut_assert_nextline("Showing all bootflows");
 165         ut_assert_nextline("Seq  Method       State   Uclass    Part  Name                      Filename");
 166         ut_assert_nextlinen("---");
 167         ut_assert_nextline("  0  syslinux     media   mmc          0  mmc2.bootdev.whole        <NULL>");
 168         ut_assert_nextline("  1  efi          media   mmc          0  mmc2.bootdev.whole        <NULL>");
 169         ut_assert_skip_to_line("  4  syslinux     ready   mmc          1  mmc1.bootdev.part_1       /extlinux/extlinux.conf");
 170         ut_assert_skip_to_line(" 3f  efi          media   mmc          0  mmc0.bootdev.whole        <NULL>");
 171         ut_assert_nextlinen("---");
 172         ut_assert_nextline("(64 bootflows, 1 valid)");
 173         ut_assert_console_end();
 174
 175         return 0;
 176 }
 177 BOOTSTD_TEST(bootflow_cmd_scan_e, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 178
 179 /* Check 'bootflow info' */
 180 static int bootflow_cmd_info(struct unit_test_state *uts)
 181 {
 182         console_record_reset_enable();
 183         ut_assertok(run_command("bootdev select 1", 0));
 184         ut_assert_console_end();
 185         ut_assertok(run_command("bootflow scan", 0));
 186         ut_assert_console_end();
 187         ut_assertok(run_command("bootflow select 0", 0));
 188         ut_assert_console_end();
 189         ut_assertok(run_command("bootflow info", 0));
 190         ut_assert_nextline("Name:      mmc1.bootdev.part_1");
 191         ut_assert_nextline("Device:    mmc1.bootdev");
 192         ut_assert_nextline("Block dev: mmc1.blk");
 193         ut_assert_nextline("Method:    syslinux");
 194         ut_assert_nextline("State:     ready");
 195         ut_assert_nextline("Partition: 1");
 196         ut_assert_nextline("Subdir:    (none)");
 197         ut_assert_nextline("Filename:  /extlinux/extlinux.conf");
 198         ut_assert_nextlinen("Buffer:    ");
 199         ut_assert_nextline("Size:      253 (595 bytes)");
 200         ut_assert_nextline("OS:        Fedora-Workstation-armhfp-31-1.9 (5.3.7-301.fc31.armv7hl)");
 201         ut_assert_nextline("Logo:      (none)");
 202         ut_assert_nextline("FDT:       <NULL>");
 203         ut_assert_nextline("Error:     0");
 204         ut_assert_console_end();
 205
 206         ut_assertok(run_command("bootflow info -d", 0));
 207         ut_assert_nextline("Name:      mmc1.bootdev.part_1");
 208         ut_assert_skip_to_line("Error:     0");
 209         ut_assert_nextline("Contents:");
 210         ut_assert_nextline("%s", "");
 211         ut_assert_nextline("# extlinux.conf generated by appliance-creator");
 212         ut_assert_skip_to_line("        initrd /initramfs-5.3.7-301.fc31.armv7hl.img");
 213         ut_assert_console_end();
 214
 215         return 0;
 216 }
 217 BOOTSTD_TEST(bootflow_cmd_info, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 218
 219 /* Check 'bootflow scan -b' to boot the first available bootdev */
 220 static int bootflow_scan_boot(struct unit_test_state *uts)
 221 {
 222         console_record_reset_enable();
 223         ut_assertok(inject_response(uts));
 224         ut_assertok(run_command("bootflow scan -b", 0));
 225         ut_assert_nextline(
 226                 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
 227         ut_assert_nextline("Ignoring unknown command: ui");
 228
 229         /*
 230          * We expect it to get through to boot although sandbox always returns
 231          * -EFAULT as it cannot actually boot the kernel
 232          */
 233         ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
 234         ut_assert_nextline("Boot failed (err=-14)");
 235         ut_assert_console_end();
 236
 237         return 0;
 238 }
 239 BOOTSTD_TEST(bootflow_scan_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 240
 241 /* Check iterating through available bootflows */
 242 static int bootflow_iter(struct unit_test_state *uts)
 243 {
 244         struct bootflow_iter iter;
 245         struct bootflow bflow;
 246
 247         bootstd_clear_glob();
 248
 249         /* The first device is mmc2.bootdev which has no media */
 250         ut_asserteq(-EPROTONOSUPPORT,
 251                     bootflow_scan_first(&iter, BOOTFLOWF_ALL | BOOTFLOWF_SKIP_GLOBAL, &bflow));
 252         ut_asserteq(2, iter.num_methods);
 253         ut_asserteq(0, iter.cur_method);
 254         ut_asserteq(0, iter.part);
 255         ut_asserteq(0, iter.max_part);
 256         ut_asserteq_str("syslinux", iter.method->name);
 257         ut_asserteq(0, bflow.err);
 258
 259         /*
 260          * This shows MEDIA even though there is none, since in
 261          * bootdev_find_in_blk() we call part_get_info() which returns
 262          * -EPROTONOSUPPORT. Ideally it would return -EEOPNOTSUPP and we would
 263          * know.
 264          */
 265         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 266
 267         ut_asserteq(-EPROTONOSUPPORT, bootflow_scan_next(&iter, &bflow));
 268         ut_asserteq(2, iter.num_methods);
 269         ut_asserteq(1, iter.cur_method);
 270         ut_asserteq(0, iter.part);
 271         ut_asserteq(0, iter.max_part);
 272         ut_asserteq_str("efi", iter.method->name);
 273         ut_asserteq(0, bflow.err);
 274         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 275         bootflow_free(&bflow);
 276
 277         /* The next device is mmc1.bootdev - at first we use the whole device */
 278         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 279         ut_asserteq(2, iter.num_methods);
 280         ut_asserteq(0, iter.cur_method);
 281         ut_asserteq(0, iter.part);
 282         ut_asserteq(0x1e, iter.max_part);
 283         ut_asserteq_str("syslinux", iter.method->name);
 284         ut_asserteq(0, bflow.err);
 285         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 286         bootflow_free(&bflow);
 287
 288         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 289         ut_asserteq(2, iter.num_methods);
 290         ut_asserteq(1, iter.cur_method);
 291         ut_asserteq(0, iter.part);
 292         ut_asserteq(0x1e, iter.max_part);
 293         ut_asserteq_str("efi", iter.method->name);
 294         ut_asserteq(0, bflow.err);
 295         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 296         bootflow_free(&bflow);
 297
 298         /* Then more to partition 1 where we find something */
 299         ut_assertok(bootflow_scan_next(&iter, &bflow));
 300         ut_asserteq(2, iter.num_methods);
 301         ut_asserteq(0, iter.cur_method);
 302         ut_asserteq(1, iter.part);
 303         ut_asserteq(0x1e, iter.max_part);
 304         ut_asserteq_str("syslinux", iter.method->name);
 305         ut_asserteq(0, bflow.err);
 306         ut_asserteq(BOOTFLOWST_READY, bflow.state);
 307         bootflow_free(&bflow);
 308
 309         ut_asserteq(-ENOENT, bootflow_scan_next(&iter, &bflow));
 310         ut_asserteq(2, iter.num_methods);
 311         ut_asserteq(1, iter.cur_method);
 312         ut_asserteq(1, iter.part);
 313         ut_asserteq(0x1e, iter.max_part);
 314         ut_asserteq_str("efi", iter.method->name);
 315         ut_asserteq(0, bflow.err);
 316         ut_asserteq(BOOTFLOWST_FS, bflow.state);
 317         bootflow_free(&bflow);
 318
 319         /* Then more to partition 2 which exists but is not bootable */
 320         ut_asserteq(-EINVAL, bootflow_scan_next(&iter, &bflow));
 321         ut_asserteq(2, iter.num_methods);
 322         ut_asserteq(0, iter.cur_method);
 323         ut_asserteq(2, iter.part);
 324         ut_asserteq(0x1e, iter.max_part);
 325         ut_asserteq_str("syslinux", iter.method->name);
 326         ut_asserteq(0, bflow.err);
 327         ut_asserteq(BOOTFLOWST_MEDIA, bflow.state);
 328         bootflow_free(&bflow);
 329
 330         bootflow_iter_uninit(&iter);
 331
 332         ut_assert_console_end();
 333
 334         return 0;
 335 }
 336 BOOTSTD_TEST(bootflow_iter, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 337
 338 #if defined(CONFIG_SANDBOX) && defined(CONFIG_BOOTMETH_GLOBAL)
 339 /* Check using the system bootdev */
 340 static int bootflow_system(struct unit_test_state *uts)
 341 {
 342         struct udevice *bootstd, *dev;
 343
 344         if (!IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR))
 345                 return -EAGAIN;
 346         ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
 347         ut_assertok(device_bind(bootstd, DM_DRIVER_GET(bootmeth_efi_mgr),
 348                                 "efi_mgr", 0, ofnode_null(), &dev));
 349         ut_assertok(device_probe(dev));
 350         sandbox_set_fake_efi_mgr_dev(dev, true);
 351
 352         /* We should get a single 'bootmgr' method right at the end */
 353         bootstd_clear_glob();
 354         console_record_reset_enable();
 355         ut_assertok(run_command("bootflow scan -lH", 0));
 356         ut_assert_skip_to_line(
 357                 "  0  efi_mgr      ready   (none)       0  <NULL>                    <NULL>");
 358         ut_assert_skip_to_line("No more bootdevs");
 359         ut_assert_skip_to_line("(2 bootflows, 2 valid)");
 360         ut_assert_console_end();
 361
 362         return 0;
 363 }
 364 BOOTSTD_TEST(bootflow_system, UT_TESTF_DM | UT_TESTF_SCAN_PDATA |
 365              UT_TESTF_SCAN_FDT);
 366 #endif
 367
 368 /* Check disabling a bootmethod if it requests it */
 369 static int bootflow_iter_disable(struct unit_test_state *uts)
 370 {
 371         struct udevice *bootstd, *dev;
 372         struct bootflow_iter iter;
 373         struct bootflow bflow;
 374         int i;
 375
 376         /* Add the EFI bootmgr driver */
 377         ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
 378         ut_assertok(device_bind_driver(bootstd, "bootmeth_sandbox", "sandbox",
 379                                        &dev));
 380
 381         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 382
 383         bootstd_clear_glob();
 384         console_record_reset_enable();
 385         ut_assertok(inject_response(uts));
 386         ut_assertok(run_command("bootflow scan -lbH", 0));
 387
 388         /* Try to boot the bootmgr flow, which will fail */
 389         console_record_reset_enable();
 390         ut_assertok(bootflow_scan_first(&iter, 0, &bflow));
 391         ut_asserteq(3, iter.num_methods);
 392         ut_asserteq_str("sandbox", iter.method->name);
 393         ut_assertok(inject_response(uts));
 394         ut_asserteq(-ENOTSUPP, bootflow_run_boot(&iter, &bflow));
 395
 396         ut_assert_skip_to_line("Boot method 'sandbox' failed and will not be retried");
 397         ut_assert_console_end();
 398
 399         /* Check that the sandbox bootmeth has been removed */
 400         ut_asserteq(2, iter.num_methods);
 401         for (i = 0; i < iter.num_methods; i++)
 402                 ut_assert(strcmp("sandbox", iter.method_order[i]->name));
 403
 404         return 0;
 405 }
 406 BOOTSTD_TEST(bootflow_iter_disable, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 407
 408 /* Check 'bootflow scan' with a bootmeth ordering including a global bootmeth */
 409 static int bootflow_scan_glob_bootmeth(struct unit_test_state *uts)
 410 {
 411         if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL))
 412                 return -EAGAIN;
 413
 414         ut_assertok(bootstd_test_drop_bootdev_order(uts));
 415
 416         /*
 417          * Make sure that the -G flag makes the scan fail, since this is not
 418          * supported when an ordering is provided
 419          */
 420         console_record_reset_enable();
 421         ut_assertok(bootmeth_set_order("efi firmware0"));
 422         ut_assertok(run_command("bootflow scan -lGH", 0));
 423         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 424         ut_assert_nextline(
 425                 "Seq  Method       State   Uclass    Part  Name                      Filename");
 426         ut_assert_nextlinen("---");
 427         ut_assert_nextlinen("---");
 428         ut_assert_nextline("(0 bootflows, 0 valid)");
 429         ut_assert_console_end();
 430
 431         ut_assertok(run_command("bootflow scan -lH", 0));
 432         ut_assert_nextline("Scanning for bootflows in all bootdevs");
 433         ut_assert_nextline(
 434                 "Seq  Method       State   Uclass    Part  Name                      Filename");
 435         ut_assert_nextlinen("---");
 436         ut_assert_nextline("Scanning global bootmeth 'firmware0':");
 437         ut_assert_nextline("Scanning bootdev 'mmc2.bootdev':");
 438         ut_assert_nextline("Scanning bootdev 'mmc1.bootdev':");
 439         ut_assert_nextline("Scanning bootdev 'mmc0.bootdev':");
 440         ut_assert_nextline("No more bootdevs");
 441         ut_assert_nextlinen("---");
 442         ut_assert_nextline("(0 bootflows, 0 valid)");
 443         ut_assert_console_end();
 444
 445         return 0;
 446 }
 447 BOOTSTD_TEST(bootflow_scan_glob_bootmeth, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 448
 449 /* Check 'bootflow boot' to boot a selected bootflow */
 450 static int bootflow_cmd_boot(struct unit_test_state *uts)
 451 {
 452         console_record_reset_enable();
 453         ut_assertok(run_command("bootdev select 1", 0));
 454         ut_assert_console_end();
 455         ut_assertok(run_command("bootflow scan", 0));
 456         ut_assert_console_end();
 457         ut_assertok(run_command("bootflow select 0", 0));
 458         ut_assert_console_end();
 459
 460         ut_assertok(inject_response(uts));
 461         ut_asserteq(1, run_command("bootflow boot", 0));
 462         ut_assert_nextline(
 463                 "** Booting bootflow 'mmc1.bootdev.part_1' with syslinux");
 464         ut_assert_nextline("Ignoring unknown command: ui");
 465
 466         /*
 467          * We expect it to get through to boot although sandbox always returns
 468          * -EFAULT as it cannot actually boot the kernel
 469          */
 470         ut_assert_skip_to_line("sandbox: continuing, as we cannot run Linux");
 471         ut_assert_nextline("Boot failed (err=-14)");
 472         ut_assert_console_end();
 473
 474         return 0;
 475 }
 476 BOOTSTD_TEST(bootflow_cmd_boot, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 477
 478 /**
 479  * prep_mmc4_bootdev() - Set up the mmc4 bootdev so we can access a fake Armbian
 480  *
 481  * @uts: Unit test state
 482  * Returns 0 on success, -ve on failure
 483  */
 484 static int prep_mmc4_bootdev(struct unit_test_state *uts)
 485 {
 486         static const char *order[] = {"mmc2", "mmc1", "mmc4", NULL};
 487         struct udevice *dev, *bootstd;
 488         struct bootstd_priv *std;
 489         const char **old_order;
 490         ofnode node;
 491
 492         /* Enable the mmc4 node since we need a second bootflow */
 493         node = ofnode_path("/mmc4");
 494         ut_assertok(lists_bind_fdt(gd->dm_root, node, &dev, NULL, false));
 495
 496         /* Enable the script bootmeth too */
 497         ut_assertok(uclass_first_device_err(UCLASS_BOOTSTD, &bootstd));
 498         ut_assertok(device_bind(bootstd, DM_DRIVER_REF(bootmeth_script),
 499                                 "bootmeth_script", 0, ofnode_null(), &dev));
 500
 501         /* Change the order to include mmc4 */
 502         std = dev_get_priv(bootstd);
 503         old_order = std->bootdev_order;
 504         std->bootdev_order = order;
 505
 506         console_record_reset_enable();
 507         ut_assertok(run_command("bootflow scan", 0));
 508         ut_assert_console_end();
 509
 510         /* Restore the order used by the device tree */
 511         std->bootdev_order = old_order;
 512
 513         return 0;
 514 }
 515
 516 /* Check 'bootflow menu' to select a bootflow */
 517 static int bootflow_cmd_menu(struct unit_test_state *uts)
 518 {
 519         char prev[3];
 520
 521         ut_assertok(prep_mmc4_bootdev(uts));
 522
 523         /* Add keypresses to move to and select the second one in the list */
 524         prev[0] = CTL_CH('n');
 525         prev[1] = '\r';
 526         prev[2] = '\0';
 527         ut_asserteq(2, console_in_puts(prev));
 528
 529         ut_assertok(run_command("bootflow menu", 0));
 530         ut_assert_nextline("Selected: Armbian");
 531         ut_assert_console_end();
 532
 533         return 0;
 534 }
 535 BOOTSTD_TEST(bootflow_cmd_menu, UT_TESTF_DM | UT_TESTF_SCAN_FDT);
 536
 537 /**
 538  * check_font() - Check that the font size for an item matches expectations
 539  *
 540  * @uts: Unit test state
 541  * @scn: Scene containing the text object
 542  * @id: ID of the text object
 543  * Returns 0 on success, -ve on failure
 544  */
 545 static int check_font(struct unit_test_state *uts, struct scene *scn, uint id,
 546                       int font_size)
 547 {
 548         struct scene_obj_txt *txt;
 549
 550         txt = scene_obj_find(scn, id, SCENEOBJT_TEXT);
 551         ut_assertnonnull(txt);
 552
 553         ut_asserteq(font_size, txt->font_size);
 554
 555         return 0;
 556 }
 557
 558 /* Check themes work with a bootflow menu */
 559 static int bootflow_menu_theme(struct unit_test_state *uts)
 560 {
 561         const int font_size = 30;
 562         struct scene *scn;
 563         struct expo *exp;
 564         ofnode node;
 565         int i;
 566
 567         ut_assertok(prep_mmc4_bootdev(uts));
 568
 569         ut_assertok(bootflow_menu_new(&exp));
 570         node = ofnode_path("/bootstd/theme");
 571         ut_assert(ofnode_valid(node));
 572         ut_assertok(bootflow_menu_apply_theme(exp, node));
 573
 574         scn = expo_lookup_scene_id(exp, MAIN);
 575         ut_assertnonnull(scn);
 576
 577         /*
 578          * Check that the txt objects have the correct font size from the
 579          * device tree node: bootstd/theme
 580          *
 581          * Check both menu items, since there are two bootflows
 582          */
 583         ut_assertok(check_font(uts, scn, OBJ_PROMPT, font_size));
 584         ut_assertok(check_font(uts, scn, OBJ_POINTER, font_size));
 585         for (i = 0; i < 2; i++) {
 586                 ut_assertok(check_font(uts, scn, ITEM_DESC + i, font_size));
 587                 ut_assertok(check_font(uts, scn, ITEM_KEY + i, font_size));
 588                 ut_assertok(check_font(uts, scn, ITEM_LABEL + i, font_size));
 589         }
 590
 591         expo_destroy(exp);
 592
 593         return 0;
 594 }
 595 BOOTSTD_TEST(bootflow_menu_theme, UT_TESTF_DM | UT_TESTF_SCAN_FDT);