vboot: rename USB to more accurate EXTERNAL

Rename enumerators of the vb2_dev_default_boot_target enum as follows,
because the term USB is not quite accurate (we can also boot from an SD
card).

 VB2_DEV_DEFAULT_BOOT_TARGET_DISK
 --> VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL

 VB2_DEV_DEFAULT_BOOT_TARGET_USB
 --> VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL

Also perform similar renaming for the following.

enum vb2_nv_param:
 VB2_NV_DEV_BOOT_USB
 --> VB2_NV_DEV_BOOT_EXTERNAL

enum vb2_secdata_fwmp_flags:
 VB2_SECDATA_FWMP_DEV_ENABLE_USB
 --> VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL

constants:
 VB2_NV_DEV_FLAG_USB
 --> VB2_NV_DEV_FLAG_EXTERNAL

functions:
 vb2_dev_boot_usb_allowed
 --> vb2_dev_boot_external_allowed

BRANCH=none
BUG=none
TEST=make runtests

Change-Id: Iad16fcf34d76da08c6d8a81e150c7fde927c743b
Signed-off-by: Yu-Ping Wu <yupingso@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/2237622
Reviewed-by: Joel Kitching <kitching@chromium.org>

19 files changed, 151 insertions, 146 deletions

diff --git a/firmware/2lib/2misc.c b/firmware/2lib/2misc.c
index 6276d8b9..71631617 100644
--- a/firmware/2lib/2misc.c
+++ b/firmware/2lib/2misc.c
@@ -250,7 +250,7 @@ vb2_error_t vb2_check_dev_switch(struct vb2_context *ctx)
 		 * initially disabled if the user later transitions back into
 		 * developer mode.
 		 */
-		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 0);
+		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 0);
 		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 0);
 		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 0);
 		vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, 0);
@@ -387,7 +387,7 @@ void vb2_enable_developer_mode(struct vb2_context *ctx)
 	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS, flags);
 
 	if (USB_BOOT_ON_DEV)
-		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 
 	VB2_DEBUG("Mode change will take effect on next reboot\n");
 }
@@ -515,9 +515,9 @@ enum vb2_dev_default_boot_target vb2api_get_dev_default_boot_target(
 		return VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY;
 
 	switch (vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT)) {
-		case VB2_DEV_DEFAULT_BOOT_TARGET_USB:
-			if (vb2_dev_boot_usb_allowed(ctx))
-				return VB2_DEV_DEFAULT_BOOT_TARGET_USB;
+		case VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL:
+			if (vb2_dev_boot_external_allowed(ctx))
+				return VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL;
 			break;
 
 		case VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY:
@@ -526,7 +526,7 @@ enum vb2_dev_default_boot_target vb2api_get_dev_default_boot_target(
 			break;
 	}
 
-	return VB2_DEV_DEFAULT_BOOT_TARGET_DISK;
+	return VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL;
 }
 
 int vb2_dev_boot_allowed(struct vb2_context *ctx)
@@ -549,13 +549,13 @@ int vb2_dev_boot_legacy_allowed(struct vb2_context *ctx)
 					 VB2_SECDATA_FWMP_DEV_ENABLE_LEGACY);
 }
 
-int vb2_dev_boot_usb_allowed(struct vb2_context *ctx)
+int vb2_dev_boot_external_allowed(struct vb2_context *ctx)
 {
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
-	return vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB) ||
+	return vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL) ||
 	       (gbb->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB) ||
-	       vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_USB);
+	       vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL);
 }
 
 int vb2api_use_short_dev_screen_delay(struct vb2_context *ctx)
diff --git a/firmware/2lib/2nvstorage.c b/firmware/2lib/2nvstorage.c
index 590c6e18..c3cdca5e 100644
--- a/firmware/2lib/2nvstorage.c
+++ b/firmware/2lib/2nvstorage.c
@@ -142,8 +142,8 @@ uint32_t vb2_nv_get(struct vb2_context *ctx, enum vb2_nv_param param)
 	case VB2_NV_KERNEL_FIELD:
 		return p[VB2_NV_OFFS_KERNEL1] | (p[VB2_NV_OFFS_KERNEL2] << 8);
 
-	case VB2_NV_DEV_BOOT_USB:
-		return GETBIT(VB2_NV_OFFS_DEV, VB2_NV_DEV_FLAG_USB);
+	case VB2_NV_DEV_BOOT_EXTERNAL:
+		return GETBIT(VB2_NV_OFFS_DEV, VB2_NV_DEV_FLAG_EXTERNAL);
 
 	case VB2_NV_DEV_BOOT_LEGACY:
 		return GETBIT(VB2_NV_OFFS_DEV, VB2_NV_DEV_FLAG_LEGACY);
@@ -327,8 +327,8 @@ void vb2_nv_set(struct vb2_context *ctx,
 		p[VB2_NV_OFFS_KERNEL2] = (uint8_t)(value >> 8);
 		break;
 
-	case VB2_NV_DEV_BOOT_USB:
-		SETBIT(VB2_NV_OFFS_DEV, VB2_NV_DEV_FLAG_USB);
+	case VB2_NV_DEV_BOOT_EXTERNAL:
+		SETBIT(VB2_NV_OFFS_DEV, VB2_NV_DEV_FLAG_EXTERNAL);
 		break;
 
 	case VB2_NV_DEV_BOOT_LEGACY:
@@ -343,7 +343,7 @@ void vb2_nv_set(struct vb2_context *ctx,
 		/* Map out of range values to disk */
 		if (value > (VB2_NV_DEV_FLAG_DEFAULT_BOOT >>
 			     VB2_NV_DEV_DEFAULT_BOOT_SHIFT))
-			value = VB2_DEV_DEFAULT_BOOT_TARGET_DISK;
+			value = VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL;
 
 		p[VB2_NV_OFFS_DEV] &= ~VB2_NV_DEV_FLAG_DEFAULT_BOOT;
 		p[VB2_NV_OFFS_DEV] |=
diff --git a/firmware/2lib/2ui_screens.c b/firmware/2lib/2ui_screens.c
index 473441ea..1a1259dd 100644
--- a/firmware/2lib/2ui_screens.c
+++ b/firmware/2lib/2ui_screens.c
@@ -426,13 +426,13 @@ vb2_error_t developer_mode_init(struct vb2_ui_context *ui)
 			1 << DEVELOPER_MODE_ITEM_RETURN_TO_SECURE;
 
 	/* Don't show "Boot from external disk" button if not allowed. */
-	if (!vb2_dev_boot_usb_allowed(ui->ctx))
+	if (!vb2_dev_boot_external_allowed(ui->ctx))
 		ui->state.disabled_item_mask |=
 			1 << DEVELOPER_MODE_ITEM_BOOT_EXTERNAL;
 
 	/* Choose the default selection. */
 	switch (default_boot) {
-	case VB2_DEV_DEFAULT_BOOT_TARGET_USB:
+	case VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL:
 		ui->state.selected_item = DEVELOPER_MODE_ITEM_BOOT_EXTERNAL;
 		break;
 	default:
@@ -464,7 +464,7 @@ vb2_error_t vb2_ui_developer_mode_boot_external_action(
 	/* Sanity check, should never happen. */
 	if (!(ui->ctx->flags & VB2_CONTEXT_DEVELOPER_MODE) ||
 	    !vb2_dev_boot_allowed(ui->ctx) ||
-	    !vb2_dev_boot_usb_allowed(ui->ctx)) {
+	    !vb2_dev_boot_external_allowed(ui->ctx)) {
 		VB2_DEBUG("ERROR: Dev mode external boot not allowed\n");
 		return VB2_REQUEST_UI_CONTINUE;
 	}
diff --git a/firmware/2lib/include/2api.h b/firmware/2lib/include/2api.h
index 9eeff85b..e78c85ad 100644
--- a/firmware/2lib/include/2api.h
+++ b/firmware/2lib/include/2api.h
@@ -863,11 +863,11 @@ int vb2api_phone_recovery_enabled(struct vb2_context *ctx);
 
 /* Default boot target in developer mode. */
 enum vb2_dev_default_boot_target {
-	/* Default to boot from disk. */
-	VB2_DEV_DEFAULT_BOOT_TARGET_DISK = 0,
+	/* Default to boot from internal disk. */
+	VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL = 0,
 
-	/* Default to boot from USB. */
-	VB2_DEV_DEFAULT_BOOT_TARGET_USB = 1,
+	/* Default to boot from external disk. */
+	VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL = 1,
 
 	/* Default to boot legacy OS. */
 	VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY = 2,
diff --git a/firmware/2lib/include/2gbb_flags.h b/firmware/2lib/include/2gbb_flags.h
index cd605d8d..c1c937c9 100644
--- a/firmware/2lib/include/2gbb_flags.h
+++ b/firmware/2lib/include/2gbb_flags.h
@@ -41,7 +41,10 @@ enum vb2_gbb_flag {
 	 */
 	VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON = 1 << 3,
 
-	/* Allow booting from USB in dev mode even if dev_boot_usb=0. */
+	/*
+	 * Allow booting from external disk in dev mode even if
+	 * dev_boot_usb=0.
+	 */
 	VB2_GBB_FLAG_FORCE_DEV_BOOT_USB = 1 << 4,
 
 	/* Disable firmware rollback protection. */
diff --git a/firmware/2lib/include/2misc.h b/firmware/2lib/include/2misc.h
index 2916b236..334b1485 100644
--- a/firmware/2lib/include/2misc.h
+++ b/firmware/2lib/include/2misc.h
@@ -223,7 +223,7 @@ int vb2_dev_boot_allowed(struct vb2_context *ctx);
 /**
  * Determine if booting from legacy BIOS is allowed.
  *
- * Legacy BIOS is allowed if one of the legacy-related flags is set:
+ * Legacy BIOS is allowed if any of these flags are set:
  * VB2_NV_DEV_BOOT_LEGACY, VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY, and
  * VB2_SECDATA_FWMP_DEV_ENABLE_LEGACY.
  *
@@ -233,15 +233,15 @@ int vb2_dev_boot_allowed(struct vb2_context *ctx);
 int vb2_dev_boot_legacy_allowed(struct vb2_context *ctx);
 
 /**
- * Determine if booting from USB or SD card is allowed.
+ * Determine if booting from external disk is allowed.
  *
- * Booting from USB is allowed if one of the USB-related flags is set:
- * VB2_NV_DEV_BOOT_USB, VB2_GBB_FLAG_FORCE_DEV_BOOT_USB, and
- * VB2_SECDATA_FWMP_DEV_ENABLE_USB.
+ * Booting from external disk is allowed if any of these flags are set:
+ * VB2_NV_DEV_BOOT_EXTERNAL, VB2_GBB_FLAG_FORCE_DEV_BOOT_USB, and
+ * VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL.
  *
  * @param ctx		Vboot context
  * @return 1 if allowed, or 0 otherwise.
  */
-int vb2_dev_boot_usb_allowed(struct vb2_context *ctx);
+int vb2_dev_boot_external_allowed(struct vb2_context *ctx);
 
 #endif  /* VBOOT_REFERENCE_2MISC_H_ */
diff --git a/firmware/2lib/include/2nvstorage.h b/firmware/2lib/include/2nvstorage.h
index 32a9b0a0..9de8056e 100644
--- a/firmware/2lib/include/2nvstorage.h
+++ b/firmware/2lib/include/2nvstorage.h
@@ -46,8 +46,8 @@ enum vb2_nv_param {
 	VB2_NV_LOCALIZATION_INDEX,
 	/* Field reserved for kernel/user-mode use; 16-bit value. */
 	VB2_NV_KERNEL_FIELD,
-	/* Allow booting from USB in developer mode.  0=no, 1=yes. */
-	VB2_NV_DEV_BOOT_USB,
+	/* Allow booting from external disk in developer mode.  0=no, 1=yes. */
+	VB2_NV_DEV_BOOT_EXTERNAL,
 	/* Allow booting of legacy OSes in developer mode.  0=no, 1=yes. */
 	VB2_NV_DEV_BOOT_LEGACY,
 	/* Only boot Google-signed images in developer mode.  0=no, 1=yes. */
diff --git a/firmware/2lib/include/2nvstorage_fields.h b/firmware/2lib/include/2nvstorage_fields.h
index ec1f85e1..9575e87e 100644
--- a/firmware/2lib/include/2nvstorage_fields.h
+++ b/firmware/2lib/include/2nvstorage_fields.h
@@ -89,7 +89,7 @@ enum vb2_nv_offset {
 #define VB2_NV_BOOT2_REQ_DIAG                  0x80
 
 /* Fields in VB2_NV_OFFS_DEV (unused = 0x80) */
-#define VB2_NV_DEV_FLAG_USB                    0x01
+#define VB2_NV_DEV_FLAG_EXTERNAL               0x01
 #define VB2_NV_DEV_FLAG_SIGNED_ONLY            0x02
 #define VB2_NV_DEV_FLAG_LEGACY                 0x04
 #define VB2_NV_DEV_FLAG_DEPRECATED_FASTBOOT_FULL_CAP      0x08
diff --git a/firmware/2lib/include/2secdata.h b/firmware/2lib/include/2secdata.h
index e0409b7b..56ebb3b2 100644
--- a/firmware/2lib/include/2secdata.h
+++ b/firmware/2lib/include/2secdata.h
@@ -155,7 +155,7 @@ void vb2_secdata_kernel_set_ec_hash(struct vb2_context *ctx,
 enum vb2_secdata_fwmp_flags {
 	VB2_SECDATA_FWMP_DEV_DISABLE_BOOT = (1 << 0),
 	VB2_SECDATA_FWMP_DEV_DISABLE_RECOVERY = (1 << 1),
-	VB2_SECDATA_FWMP_DEV_ENABLE_USB = (1 << 2),
+	VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL = (1 << 2),
 	VB2_SECDATA_FWMP_DEV_ENABLE_LEGACY = (1 << 3),
 	VB2_SECDATA_FWMP_DEV_ENABLE_OFFICIAL_ONLY = (1 << 4),
 	VB2_SECDATA_FWMP_DEV_USE_KEY_HASH = (1 << 5),
diff --git a/firmware/lib/vboot_ui_legacy.c b/firmware/lib/vboot_ui_legacy.c
index 1b6a32e8..5f84716a 100644
--- a/firmware/lib/vboot_ui_legacy.c
+++ b/firmware/lib/vboot_ui_legacy.c
@@ -95,7 +95,7 @@ vb2_error_t VbDisplayDebugInfo(struct vb2_context *ctx)
 	}
 
 	/* Add dev_boot_usb flag */
-	i = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB);
+	i = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL);
 	DEBUG_INFO_APPEND("\ndev_boot_usb: %d", i);
 
 	/* Add dev_boot_legacy flag */
diff --git a/firmware/lib/vboot_ui_legacy_clamshell.c b/firmware/lib/vboot_ui_legacy_clamshell.c
index 002ee18a..47e6fdba 100644
--- a/firmware/lib/vboot_ui_legacy_clamshell.c
+++ b/firmware/lib/vboot_ui_legacy_clamshell.c
@@ -203,14 +203,14 @@ static vb2_error_t vb2_developer_ui(struct vb2_context *ctx)
 
 	VB2_DEBUG("Entering\n");
 
-	/* Check if USB booting is allowed */
-	uint32_t allow_usb = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB);
+	/* Check if booting from external disk is allowed */
+	uint32_t allow_usb = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL);
 	uint32_t allow_legacy = vb2_nv_get(ctx, VB2_NV_DEV_BOOT_LEGACY);
 
-	/* Check if the default is to boot using disk, usb, or legacy */
+	/* Check if the default boot target: internal/external disk or legacy */
 	uint32_t default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT);
 
-	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_USB)
+	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL)
 		use_usb = 1;
 	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY)
 		use_legacy = 1;
@@ -226,7 +226,7 @@ static vb2_error_t vb2_developer_ui(struct vb2_context *ctx)
 	}
 
 	/* Handle FWMP override */
-	if (vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_USB))
+	if (vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL))
 		allow_usb = 1;
 	if (vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_LEGACY))
 		allow_legacy = 1;
diff --git a/firmware/lib/vboot_ui_legacy_menu.c b/firmware/lib/vboot_ui_legacy_menu.c
index 5faa4642..c11e845f 100644
--- a/firmware/lib/vboot_ui_legacy_menu.c
+++ b/firmware/lib/vboot_ui_legacy_menu.c
@@ -213,9 +213,9 @@ static vb2_error_t boot_usb_action(struct vb2_context *ctx)
 		return VB2_REQUEST_UI_CONTINUE;
 	}
 
-	if (!vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB) &&
+	if (!vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL) &&
 	    !(vb2_get_gbb(ctx)->flags & VB2_GBB_FLAG_FORCE_DEV_BOOT_USB) &&
-	    !vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_USB)) {
+	    !vb2_secdata_fwmp_get_flag(ctx, VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL)) {
 		vb2_flash_screen(ctx);
 		vb2_error_notify("WARNING: Booting from external media "
 				 "(USB/SD) has not been enabled. Refer "
@@ -241,10 +241,10 @@ static vb2_error_t enter_developer_menu(struct vb2_context *ctx)
 	int menu_idx;
 	switch(default_boot) {
 	default:
-	case VB2_DEV_DEFAULT_BOOT_TARGET_DISK:
+	case VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL:
 		menu_idx = VB_DEV_DISK;
 		break;
-	case VB2_DEV_DEFAULT_BOOT_TARGET_USB:
+	case VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL:
 		menu_idx = VB_DEV_USB;
 		break;
 	case VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY:
@@ -845,7 +845,7 @@ static vb2_error_t vb2_developer_legacy_menu(struct vb2_context *ctx)
 	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY)
 		boot_legacy_action(ctx);	/* Doesn't return on success. */
 
-	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_USB)
+	if (default_boot == VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL)
 		if (VB2_SUCCESS == boot_usb_action(ctx))
 			return VB2_SUCCESS;
 
diff --git a/host/lib/crossystem.c b/host/lib/crossystem.c
index c5c72cfe..63f20c42 100644
--- a/host/lib/crossystem.c
+++ b/host/lib/crossystem.c
@@ -403,7 +403,7 @@ int VbGetSystemPropertyInt(const char *name)
 	} else if (!strcasecmp(name,"backup_nvram_request")) {
 		value = vb2_get_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST);
 	} else if (!strcasecmp(name,"dev_boot_usb")) {
-		value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_USB);
+		value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_EXTERNAL);
 	} else if (!strcasecmp(name,"dev_boot_legacy")) {
 		value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_LEGACY);
 	} else if (!strcasecmp(name,"dev_boot_signed_only")) {
@@ -593,7 +593,7 @@ int VbSetSystemPropertyInt(const char *name, int value)
 			VB2_NV_LOCALIZATION_INDEX, value);
 	} else if (!strcasecmp(name,"dev_boot_usb")) {
 		return vb2_set_nv_storage_with_backup(
-			VB2_NV_DEV_BOOT_USB, value);
+			VB2_NV_DEV_BOOT_EXTERNAL, value);
 	} else if (!strcasecmp(name,"dev_boot_legacy")) {
 		return vb2_set_nv_storage_with_backup(
 			VB2_NV_DEV_BOOT_LEGACY, value);
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index f363ba53..c076b1a3 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -504,13 +504,13 @@ static void dev_switch_tests(void)
 
 	/* Any normal mode boot clears dev boot flags */
 	reset_common_data();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, 1);
 	TEST_SUCC(vb2_check_dev_switch(ctx), "dev mode off");
-	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB),
-		0, "  cleared dev boot usb");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL),
+		0, "  cleared dev boot external");
 	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_LEGACY),
 		0, "  cleared dev boot legacy");
 	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY),
@@ -644,8 +644,8 @@ static void enable_dev_tests(void)
 	TEST_NEQ(vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS) &
 	         VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE, 0,
 		 "dev mode flag set");
-	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB), USB_BOOT_ON_DEV,
-		"NV_DEV_BOOT_USB set according to compile-time flag");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL), USB_BOOT_ON_DEV,
+		"NV_DEV_BOOT_EXTERNAL set according to compile-time flag");
 
 	/* secdata_firmware not initialized, aborts */
 	reset_common_data();
@@ -656,8 +656,8 @@ static void enable_dev_tests(void)
 	TEST_EQ(vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS) &
 	        VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE, 0,
 		"dev mode flag not set");
-	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB), 0,
-		"NV_DEV_BOOT_USB not set");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL), 0,
+		"NV_DEV_BOOT_EXTERNAL not set");
 }
 
 static void tpm_clear_tests(void)
@@ -855,49 +855,49 @@ static void dev_default_boot_tests(void)
 	/* No default boot */
 	reset_common_data();
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
 		"no default boot, boot disk");
 
 	/* Set boot legacy by GBB */
 	reset_common_data();
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
 		VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY,
 		"GBB set default boot legacy");
 
-	/* Boot from disk */
+	/* Boot from internal disk */
 	reset_common_data();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_DISK);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
-		"set default boot disk");
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
+		"set default boot internal disk");
 
-	/* Boot from usb */
+	/* Boot from external disk */
 	reset_common_data();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_USB,
-		"set default boot usb");
+		VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL,
+		"set default boot external disk");
 
-	/* Boot from usb not allowed */
+	/* Boot from external disk not allowed */
 	reset_common_data();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
-		"default boot usb not allowed");
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
+		"default boot external not allowed");
 	reset_common_data();
 	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
-		"default boot usb not allowed");
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
+		"default boot external not allowed");
 
 	/* Boot legacy */
 	reset_common_data();
@@ -913,14 +913,14 @@ static void dev_default_boot_tests(void)
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
 		"default boot legacy not allowed");
 	reset_common_data();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_TARGET_LEGACY);
 	TEST_EQ(vb2api_get_dev_default_boot_target(ctx),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
 		"default boot legacy not allowed");
 }
 
@@ -972,36 +972,36 @@ static void dev_boot_allowed_tests(void)
 	TEST_EQ(vb2_dev_boot_legacy_allowed(ctx), 1,
 		"dev boot legacy - all flags set");
 
-	/* USB boot - not allowed by default */
+	/* External boot - not allowed by default */
 	reset_common_data();
-	TEST_EQ(vb2_dev_boot_usb_allowed(ctx), 0,
-		"dev boot usb - not allowed by default");
+	TEST_EQ(vb2_dev_boot_external_allowed(ctx), 0,
+		"dev boot external - not allowed by default");
 
-	/* USB boot - enabled by nvdata */
+	/* External boot - enabled by nvdata */
 	reset_common_data();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
-	TEST_EQ(vb2_dev_boot_usb_allowed(ctx), 1, "dev boot usb -"
-		" nvdata enabled");
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
+	TEST_EQ(vb2_dev_boot_external_allowed(ctx), 1,
+		"dev boot external - nvdata enabled");
 
-	/* USB boot - enabled by FWMP */
+	/* External boot - enabled by FWMP */
 	reset_common_data();
-	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_USB;
-	TEST_EQ(vb2_dev_boot_usb_allowed(ctx), 1,
-		"dev boot usb - secdata enabled");
+	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL;
+	TEST_EQ(vb2_dev_boot_external_allowed(ctx), 1,
+		"dev boot external - secdata enabled");
 
-	/* USB boot - force enabled by GBB */
+	/* External boot - force enabled by GBB */
 	reset_common_data();
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
-	TEST_EQ(vb2_dev_boot_usb_allowed(ctx), 1,
-		"dev boot usb - GBB force enabled");
+	TEST_EQ(vb2_dev_boot_external_allowed(ctx), 1,
+		"dev boot external - GBB force enabled");
 
-	/* USB boot - set all flags */
+	/* External boot - set all flags */
 	reset_common_data();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
-	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_USB;
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
+	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL;
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
-	TEST_EQ(vb2_dev_boot_usb_allowed(ctx), 1,
-		"dev boot usb - all flags set");
+	TEST_EQ(vb2_dev_boot_external_allowed(ctx), 1,
+		"dev boot external - all flags set");
 }
 
 static void use_dev_screen_short_delay_tests(void)
diff --git a/tests/vb2_nvstorage_tests.c b/tests/vb2_nvstorage_tests.c
index a39109c5..a49f162d 100644
--- a/tests/vb2_nvstorage_tests.c
+++ b/tests/vb2_nvstorage_tests.c
@@ -40,7 +40,7 @@ static struct nv_field nvfields[] = {
 	{VB2_NV_RECOVERY_SUBCODE, 0, 0x56, 0xAC, "recovery subcode"},
 	{VB2_NV_LOCALIZATION_INDEX, 0, 0x69, 0xB0, "localization index"},
 	{VB2_NV_KERNEL_FIELD, 0, 0x1234, 0xFEDC, "kernel field"},
-	{VB2_NV_DEV_BOOT_USB, 0, 1, 0, "dev boot usb"},
+	{VB2_NV_DEV_BOOT_EXTERNAL, 0, 1, 0, "dev boot usb"},
 	{VB2_NV_DEV_BOOT_LEGACY, 0, 1, 0, "dev boot legacy"},
 	{VB2_NV_DEV_BOOT_SIGNED_ONLY, 0, 1, 0, "dev boot custom"},
 	{VB2_NV_DEV_DEFAULT_BOOT, 0, 1, 2, "dev default boot"},
@@ -260,9 +260,9 @@ static void nv_storage_test(uint32_t ctxflags)
 		VB2_FW_RESULT_UNKNOWN, "Fw prev result out of range");
 
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_DISK + 100);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL + 100);
 	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT),
-		VB2_DEV_DEFAULT_BOOT_TARGET_DISK,
+		VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL,
 		"default to booting from disk");
 }
 
diff --git a/tests/vb2_ui_tests.c b/tests/vb2_ui_tests.c
index 57c5db5b..ba2e29a2 100644
--- a/tests/vb2_ui_tests.c
+++ b/tests/vb2_ui_tests.c
@@ -59,7 +59,7 @@ static int mock_vbexbeep_called;
 static enum vb2_dev_default_boot_target mock_default_boot;
 static int mock_dev_boot_allowed;
 static int mock_dev_boot_legacy_allowed;
-static int mock_dev_boot_usb_allowed;
+static int mock_dev_boot_external_allowed;
 
 static int mock_vbexlegacy_called;
 static enum VbAltFwIndex_t mock_altfw_num_last;
@@ -250,10 +250,10 @@ static void reset_common_data(enum reset_type t)
 	mock_vbexbeep_called = 0;
 
 	/* For dev_boot* in 2misc.h */
-	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_DISK;
+	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_INTERNAL;
 	mock_dev_boot_allowed = 1;
 	mock_dev_boot_legacy_allowed = 0;
-	mock_dev_boot_usb_allowed = 0;
+	mock_dev_boot_external_allowed = 0;
 
 	/* For VbExLegacy */
 	mock_vbexlegacy_called = 0;
@@ -392,9 +392,9 @@ int vb2_dev_boot_legacy_allowed(struct vb2_context *c)
 	return mock_dev_boot_legacy_allowed;
 }
 
-int vb2_dev_boot_usb_allowed(struct vb2_context *c)
+int vb2_dev_boot_external_allowed(struct vb2_context *c)
 {
-	return mock_dev_boot_usb_allowed;
+	return mock_dev_boot_external_allowed;
 }
 
 vb2_error_t VbExLegacy(enum VbAltFwIndex_t altfw_num)
@@ -452,23 +452,23 @@ static void developer_tests(void)
 	TEST_EQ(mock_vbexbeep_called, 2, "  beeped twice");
 	TEST_TRUE(mock_iters >= mock_vbtlk_total, "  used up mock_vbtlk");
 
-	/* Proceed to USB after timeout */
+	/* Proceed to external disk after timeout */
 	reset_common_data(FOR_DEVELOPER);
 	add_mock_vbtlk(VB2_SUCCESS, VB_DISK_FLAG_REMOVABLE);
-	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_USB;
-	mock_dev_boot_usb_allowed = 1;
+	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL;
+	mock_dev_boot_external_allowed = 1;
 	TEST_EQ(vb2_developer_menu(ctx), VB2_SUCCESS,
-		"proceed to USB after timeout");
+		"proceed to external disk after timeout");
 	TEST_TRUE(mock_get_timer_last - mock_time_start >=
 		  30 * VB2_MSEC_PER_SEC, "  finished delay");
 	TEST_EQ(mock_vbexbeep_called, 2, "  beeped twice");
 	TEST_TRUE(mock_iters >= mock_vbtlk_total, "  used up mock_vbtlk");
 
-	/* Default boot USB not allowed, don't boot */
+	/* Default boot from external not allowed, don't boot */
 	reset_common_data(FOR_DEVELOPER);
-	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_USB;
+	mock_default_boot = VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL;
 	TEST_EQ(vb2_developer_menu(ctx), VB2_REQUEST_SHUTDOWN,
-		"default USB not allowed, don't boot");
+		"default boot from external not allowed, don't boot");
 	TEST_TRUE(mock_get_timer_last - mock_time_start >=
 		  30 * VB2_MSEC_PER_SEC, "  finished delay");
 	TEST_EQ(mock_vbexbeep_called, 2, "  beeped twice");
diff --git a/tests/vboot_ui_legacy_clamshell_tests.c b/tests/vboot_ui_legacy_clamshell_tests.c
index 6f9b0844..3b9727d8 100644
--- a/tests/vboot_ui_legacy_clamshell_tests.c
+++ b/tests/vboot_ui_legacy_clamshell_tests.c
@@ -536,28 +536,28 @@ static void VbBootDevTest(void)
 	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), VB2_ERROR_MOCK, "Timeout");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
-	/* Proceed to USB after timeout if boot USB and default boot
-	   USB are set */
+	/* Proceed to external disk after timeout if boot external and default
+	 * boot external are set */
 	ResetMocks();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vbtlk_retval = VB2_SUCCESS;
 	vbtlk_expect_removable = 1;
-	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U external");
 
-	/* Proceed to USB boot mode only if enabled */
+	/* Proceed to external boot mode only if enabled */
 	ResetMocks();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	vbtlk_expect_fixed = 1;
 	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), VB2_ERROR_MOCK, "Timeout");
 
-	/* If no USB tries fixed disk */
+	/* If no external tries fixed disk */
 	ResetMocks();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	vbtlk_expect_fixed = 1;
 	vbtlk_expect_removable = 1;
 	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), VB2_ERROR_MOCK,
@@ -785,20 +785,20 @@ static void VbBootDevTest(void)
 		TEST_EQ(altfw_num, key - '0', "  check altfw_num");
 	}
 
-	/* Ctrl+U boots USB only if enabled */
+	/* Ctrl+U boots external only if enabled */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_expect_fixed = 1;
 	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), VB2_ERROR_MOCK,
 		"Ctrl+U normal");
 
-	/* Ctrl+U enabled, with good USB boot */
+	/* Ctrl+U enabled, with good external boot */
 	ResetMocks();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS;
 	vbtlk_expect_removable = 1;
-	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U external");
 
 	/* Ctrl+U enabled via GBB */
 	ResetMocks();
@@ -806,19 +806,19 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS;
 	vbtlk_expect_removable = 1;
-	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U force external");
 
 	/* Ctrl+U enabled via FWMP */
 	ResetMocks();
-	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_USB;
+	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS;
 	vbtlk_expect_removable = 1;
-	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloperLegacyClamshell(ctx), 0, "Ctrl+U force external");
 
-	/* If no USB, eventually times out and tries fixed disk */
+	/* If no external disk, eventually times out and tries internal disk */
 	ResetMocks();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	/* TODO: Currently the test suite has no way of specifying the order in
 	   which the expected VbTryLoadKernel calls occur. */
@@ -1148,8 +1148,9 @@ static void VbBootRecTestGpio(uint32_t first, uint32_t second, uint32_t third,
 		TEST_EQ(VbBootRecoveryLegacyClamshell(ctx),
 			VB2_REQUEST_REBOOT_EC_TO_RO, msg);
 		TEST_EQ(virtdev_set, 1, "  virtual dev mode on");
-		TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_USB), !!USB_BOOT_ON_DEV,
-			"  NV_DEV_BOOT_USB enabled");
+		TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_BOOT_EXTERNAL),
+			!!USB_BOOT_ON_DEV,
+			"  NV_DEV_BOOT_EXTERNAL enabled");
 	} else {
 		TEST_EQ(VbBootRecoveryLegacyClamshell(ctx),
 			VB2_REQUEST_SHUTDOWN, msg);
diff --git a/tests/vboot_ui_legacy_menu_tests.c b/tests/vboot_ui_legacy_menu_tests.c
index 56f8f3ec..fee6a3f9 100644
--- a/tests/vboot_ui_legacy_menu_tests.c
+++ b/tests/vboot_ui_legacy_menu_tests.c
@@ -315,8 +315,8 @@ static void VbBootDevTest(void)
 	 * usb are set */
 	ResetMocksForDeveloper();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), 0, "Ctrl+U USB");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -329,7 +329,7 @@ static void VbBootDevTest(void)
 	/* Proceed to usb boot mode only if enabled */
 	ResetMocksForDeveloper();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"default USB not enabled");
 	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
@@ -347,9 +347,9 @@ static void VbBootDevTest(void)
 
 	/* If no USB tries fixed disk */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"default USB with no disk");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
@@ -680,7 +680,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled, with good USB boot */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), VB2_SUCCESS, "Ctrl+U USB");
@@ -696,7 +696,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled, without valid USB */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+U without valid USB");
@@ -730,7 +730,7 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled via FWMP */
 	ResetMocksForDeveloper();
-	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_USB;
+	fwmp->flags |= VB2_SECDATA_FWMP_DEV_ENABLE_EXTERNAL;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), VB2_SUCCESS,
@@ -744,7 +744,7 @@ static void VbBootDevTest(void)
 
 	/* If no valid USB, eventually times out and tries fixed disk */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+U failed - no USB");
@@ -770,7 +770,7 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), VB2_SUCCESS,
 		"Menu selected USB boot");
@@ -798,14 +798,14 @@ static void VbBootDevTest(void)
 	/* If default USB, the option is preselected */
 	ResetMocksForDeveloper();
 	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VB2_DEV_DEFAULT_BOOT_TARGET_USB);
+		   VB2_DEV_DEFAULT_BOOT_TARGET_EXTERNAL);
 	i = 0;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Enable OS Verif
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Show Debug Info
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Developer Options
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), VB2_SUCCESS,
 		"Menu selected USB default boot");
@@ -836,7 +836,7 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"Menu selected invalid USB boot");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
@@ -982,7 +982,7 @@ static void VbBootDevTest(void)
 
 	/* Use volume-up long press shortcut to boot USB */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), VB2_SUCCESS, "VolUp USB");
@@ -997,7 +997,7 @@ static void VbBootDevTest(void)
 
 	/* Can boot a valid USB image after failing to boot invalid image */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	mock_keypress[1] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	vbtlk_retval[0] = VB2_ERROR_MOCK - VB_DISK_FLAG_REMOVABLE;
@@ -1038,7 +1038,7 @@ static void VbBootDevTest(void)
 
 	/* Volume-up long press without valid USB will still time out */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	TEST_EQ(VbBootDeveloperLegacyMenu(ctx), vbtlk_retval_fixed,
 		"VolUp without valid USB");
@@ -1057,7 +1057,7 @@ static void VbBootDevTest(void)
 
 	/* Volume-up long press works from other menus, like LANGUAGE */
 	ResetMocksForDeveloper();
-	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_EXTERNAL, 1);
 	i = 0;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Enable OS Verif
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Show Debug Info
diff --git a/utility/crossystem.c b/utility/crossystem.c
index cece7600..8d1d1863 100644
--- a/utility/crossystem.c
+++ b/utility/crossystem.c
@@ -40,7 +40,8 @@ const Param sys_param_list[] = {
   {"dev_boot_legacy", CAN_WRITE, "Enable developer mode boot Legacy OSes"},
   {"dev_boot_signed_only", CAN_WRITE,
    "Enable developer mode boot only from official kernels"},
-  {"dev_boot_usb", CAN_WRITE, "Enable developer mode boot from USB/SD"},
+  {"dev_boot_usb", CAN_WRITE,
+   "Enable developer mode boot from external disk (USB/SD)"},
   {"dev_default_boot", IS_STRING|CAN_WRITE,
    "Default boot from disk, legacy or usb"},
   {"dev_enable_udc", CAN_WRITE, "Enable USB Device Controller"},