Eric Lee / smarc-uboot | Embedian Git Server

Commit e0343ea466a651ee574e5ceeb5c522fdcb6116ab

Authored by Ji Luo 2019-03-12 16:15:54 +0800

Exists in smarc_8mm-imx_v2018.03_4.14.98_2.0.0_ga and in 4 other branches

MA-14318-1 Support dual bootloader for xen

Trusty is not supported for xen so we don't need to check
the keyslot package or rollback index in spl. Reassign the
dram address for spl and u-boot to avoid conflicts.

Support serial init functions to enable debug console
in spl when xen is running.

Test: Boot and A/B slot switch on imx8qm_mek.

Change-Id: If6829252f1ec2e32255f951715c8747181951fd0
Signed-off-by: Ji Luo <ji.luo@nxp.com>
Reviewed-by: Peng Fan <peng.fan@nxp.com>

Showing 4 changed files with 65 additions and 3 deletions Inline Diff

drivers/serial/serial.c
drivers/serial/serial_xen.c
include/configs/imx8qm_mek_android_auto_xen.h
lib/avb/fsl/fsl_avb_ab_flow.c

drivers/serial/serial.c

Diff comments View file @ e0343ea

 /*
  * (C) Copyright 2004
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <environment.h>
 #include <serial.h>
 #include <stdio_dev.h>
 #include <post.h>
 #include <linux/compiler.h>
 #include <errno.h>
 DECLARE_GLOBAL_DATA_PTR;
 static struct serial_device *serial_devices;
 static struct serial_device *serial_current;
 /*
  * Table with supported baudrates (defined in config_xyz.h)
  */
 static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
 /**
  * serial_null() - Void registration routine of a serial driver
  *
  * This routine implements a void registration routine of a serial
  * driver. The registration routine of a particular driver is aliased
  * to this empty function in case the driver is not compiled into
  * U-Boot.
  */
 static void serial_null(void)
 {
 }
 /**
  * on_baudrate() - Update the actual baudrate when the env var changes
  *
  * This will check for a valid baudrate and only apply it if valid.
  */
 static int on_baudrate(const char *name, const char *value, enum env_op op,
 	int flags)
 {
 	int i;
 	int baudrate;
 	switch (op) {
 	case env_op_create:
 	case env_op_overwrite:
 		/*
 		 * Switch to new baudrate if new baudrate is supported
 		 */
 		baudrate = simple_strtoul(value, NULL, 10);
 		/* Not actually changing */
 		if (gd->baudrate == baudrate)
 			return 0;
 		for (i = 0; i < ARRAY_SIZE(baudrate_table); ++i) {
 			if (baudrate == baudrate_table[i])
 				break;
 		}
 		if (i == ARRAY_SIZE(baudrate_table)) {
 			if ((flags & H_FORCE) == 0)
 				printf("## Baudrate %d bps not supported\n",
 					baudrate);
 			return 1;
 		}
 		if ((flags & H_INTERACTIVE) != 0) {
 			printf("## Switch baudrate to %d"
 				" bps and press ENTER ...\n", baudrate);
 			udelay(50000);
 		}
 		gd->baudrate = baudrate;
 		serial_setbrg();
 		udelay(50000);
 		if ((flags & H_INTERACTIVE) != 0)
 			while (1) {
 				if (getc() == '\r')
 					break;
 			}
 		return 0;
 	case env_op_delete:
 		printf("## Baudrate may not be deleted\n");
 		return 1;
 	default:
 		return 0;
 	}
 }
 U_BOOT_ENV_CALLBACK(baudrate, on_baudrate);
 /**
  * serial_initfunc() - Forward declare of driver registration routine
  * @name:	Name of the real driver registration routine.
  *
  * This macro expands onto forward declaration of a driver registration
  * routine, which is then used below in serial_initialize() function.
  * The declaration is made weak and aliases to serial_null() so in case
  * the driver is not compiled in, the function is still declared and can
  * be used, but aliases to serial_null() and thus is optimized away.
  */
 #define serial_initfunc(name)					\
 	void name(void)						\
 		__attribute__((weak, alias("serial_null")));
 serial_initfunc(amirix_serial_initialize);
 serial_initfunc(arc_serial_initialize);
 serial_initfunc(arm_dcc_initialize);
 serial_initfunc(asc_serial_initialize);
 serial_initfunc(atmel_serial_initialize);
 serial_initfunc(au1x00_serial_initialize);
 serial_initfunc(bfin_jtag_initialize);
 serial_initfunc(bfin_serial_initialize);
 serial_initfunc(bmw_serial_initialize);
 serial_initfunc(clps7111_serial_initialize);
 serial_initfunc(cogent_serial_initialize);
 serial_initfunc(cpci750_serial_initialize);
 serial_initfunc(evb64260_serial_initialize);
 serial_initfunc(imx_serial_initialize);
 serial_initfunc(iop480_serial_initialize);
 serial_initfunc(jz_serial_initialize);
 serial_initfunc(leon2_serial_initialize);
 serial_initfunc(leon3_serial_initialize);
 serial_initfunc(lh7a40x_serial_initialize);
 serial_initfunc(lpc32xx_serial_initialize);
 serial_initfunc(marvell_serial_initialize);
 serial_initfunc(max3100_serial_initialize);
 serial_initfunc(mcf_serial_initialize);
 serial_initfunc(ml2_serial_initialize);
 serial_initfunc(mpc85xx_serial_initialize);
 serial_initfunc(mpc8xx_serial_initialize);
 serial_initfunc(mxc_serial_initialize);
+serial_initfunc(xen_serial_initialize);
 serial_initfunc(serial_lpuart_initialize);
 serial_initfunc(mxs_auart_initialize);
 serial_initfunc(ns16550_serial_initialize);
 serial_initfunc(oc_serial_initialize);
 serial_initfunc(p3mx_serial_initialize);
 serial_initfunc(pl01x_serial_initialize);
 serial_initfunc(pxa_serial_initialize);
 serial_initfunc(s3c24xx_serial_initialize);
 serial_initfunc(s5p_serial_initialize);
 serial_initfunc(sa1100_serial_initialize);
 serial_initfunc(sandbox_serial_initialize);
 serial_initfunc(sconsole_serial_initialize);
 serial_initfunc(sh_serial_initialize);
 serial_initfunc(stm32_serial_initialize);
 serial_initfunc(uartlite_serial_initialize);
 serial_initfunc(xen_debug_serial_initialize);
 serial_initfunc(zynq_serial_initialize);
 /**
  * serial_register() - Register serial driver with serial driver core
  * @dev:	Pointer to the serial driver structure
  *
  * This function registers the serial driver supplied via @dev with
  * serial driver core, thus making U-Boot aware of it and making it
  * available for U-Boot to use. On platforms that still require manual
  * relocation of constant variables, relocation of the supplied structure
  * is performed.
  */
 void serial_register(struct serial_device *dev)
 {
 #ifdef CONFIG_NEEDS_MANUAL_RELOC
 	if (dev->start)
 		dev->start += gd->reloc_off;
 	if (dev->stop)
 		dev->stop += gd->reloc_off;
 	if (dev->setbrg)
 		dev->setbrg += gd->reloc_off;
 	if (dev->getc)
 		dev->getc += gd->reloc_off;
 	if (dev->tstc)
 		dev->tstc += gd->reloc_off;
 	if (dev->putc)
 		dev->putc += gd->reloc_off;
 	if (dev->puts)
 		dev->puts += gd->reloc_off;
 #endif
 	dev->next = serial_devices;
 	serial_devices = dev;
 }
 /**
  * serial_initialize() - Register all compiled-in serial port drivers
  *
  * This function registers all serial port drivers that are compiled
  * into the U-Boot binary with the serial core, thus making them
  * available to U-Boot to use. Lastly, this function assigns a default
  * serial port to the serial core. That serial port is then used as a
  * default output.
  */
 void serial_initialize(void)
 {
 	amirix_serial_initialize();
 	arc_serial_initialize();
 	arm_dcc_initialize();
 	asc_serial_initialize();
 	atmel_serial_initialize();
 	au1x00_serial_initialize();
 	bfin_jtag_initialize();
 	bfin_serial_initialize();
 	bmw_serial_initialize();
 	clps7111_serial_initialize();
 	cogent_serial_initialize();
 	cpci750_serial_initialize();
 	evb64260_serial_initialize();
 	imx_serial_initialize();
 	iop480_serial_initialize();
 	jz_serial_initialize();
 	leon2_serial_initialize();
 	leon3_serial_initialize();
 	lh7a40x_serial_initialize();
 	lpc32xx_serial_initialize();
 	marvell_serial_initialize();
 	max3100_serial_initialize();
 	mcf_serial_initialize();
 	ml2_serial_initialize();
 	mpc85xx_serial_initialize();
 	mpc8xx_serial_initialize();
 	mxc_serial_initialize();
+	xen_serial_initialize();
 	serial_lpuart_initialize();
 	mxs_auart_initialize();
 	ns16550_serial_initialize();
 	oc_serial_initialize();
 	p3mx_serial_initialize();
 	pl01x_serial_initialize();
 	pxa_serial_initialize();
 	s3c24xx_serial_initialize();
 	s5p_serial_initialize();
 	sa1100_serial_initialize();
 	sandbox_serial_initialize();
 	sconsole_serial_initialize();
 	sh_serial_initialize();
 	stm32_serial_initialize();
 	uartlite_serial_initialize();
 	xen_debug_serial_initialize();
 	zynq_serial_initialize();
 	serial_assign(default_serial_console()->name);
 }
 static int serial_stub_start(struct stdio_dev *sdev)
 {
 	struct serial_device *dev = sdev->priv;
 	return dev->start();
 }
 static int serial_stub_stop(struct stdio_dev *sdev)
 {
 	struct serial_device *dev = sdev->priv;
 	return dev->stop();
 }
 static void serial_stub_putc(struct stdio_dev *sdev, const char ch)
 {
 	struct serial_device *dev = sdev->priv;
 	dev->putc(ch);
 }
 static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
 {
 	struct serial_device *dev = sdev->priv;
 	dev->puts(str);
 }
 static int serial_stub_getc(struct stdio_dev *sdev)
 {
 	struct serial_device *dev = sdev->priv;
 	return dev->getc();
 }
 static int serial_stub_tstc(struct stdio_dev *sdev)
 {
 	struct serial_device *dev = sdev->priv;
 	return dev->tstc();
 }
 /**
  * serial_stdio_init() - Register serial ports with STDIO core
  *
  * This function generates a proxy driver for each serial port driver.
  * These proxy drivers then register with the STDIO core, making the
  * serial drivers available as STDIO devices.
  */
 void serial_stdio_init(void)
 {
 	struct stdio_dev dev;
 	struct serial_device *s = serial_devices;
 	while (s) {
 		memset(&dev, 0, sizeof(dev));
 		strcpy(dev.name, s->name);
 		dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
 		dev.start = serial_stub_start;
 		dev.stop = serial_stub_stop;
 		dev.putc = serial_stub_putc;
 		dev.puts = serial_stub_puts;
 		dev.getc = serial_stub_getc;
 		dev.tstc = serial_stub_tstc;
 		dev.priv = s;
 		stdio_register(&dev);
 		s = s->next;
 	}
 }
 /**
  * serial_assign() - Select the serial output device by name
  * @name:	Name of the serial driver to be used as default output
  *
  * This function configures the serial output multiplexing by
  * selecting which serial device will be used as default. In case
  * the STDIO "serial" device is selected as stdin/stdout/stderr,
  * the serial device previously configured by this function will be
  * used for the particular operation.
  *
  * Returns 0 on success, negative on error.
  */
 int serial_assign(const char *name)
 {
 	struct serial_device *s;
 	for (s = serial_devices; s; s = s->next) {
 		if (strcmp(s->name, name))
 			continue;
 		serial_current = s;
 		return 0;
 	}
 	return -EINVAL;
 }
 /**
  * serial_reinit_all() - Reinitialize all compiled-in serial ports
  *
  * This function reinitializes all serial ports that are compiled
  * into U-Boot by calling their serial_start() functions.
  */
 void serial_reinit_all(void)
 {
 	struct serial_device *s;
 	for (s = serial_devices; s; s = s->next)
 		s->start();
 }
 /**
  * get_current() - Return pointer to currently selected serial port
  *
  * This function returns a pointer to currently selected serial port.
  * The currently selected serial port is altered by serial_assign()
  * function.
  *
  * In case this function is called before relocation or before any serial
  * port is configured, this function calls default_serial_console() to
  * determine the serial port. Otherwise, the configured serial port is
  * returned.
  *
  * Returns pointer to the currently selected serial port on success,
  * NULL on error.
  */
 static struct serial_device *get_current(void)
 {
 	struct serial_device *dev;
 	if (!(gd->flags & GD_FLG_RELOC))
 		dev = default_serial_console();
 	else if (!serial_current)
 		dev = default_serial_console();
 	else
 		dev = serial_current;
 	/* We must have a console device */
 	if (!dev) {
 #ifdef CONFIG_SPL_BUILD
 		puts("Cannot find console\n");
 		hang();
 #else
 		panic("Cannot find console\n");
 #endif
 	}
 	return dev;
 }
 /**
  * serial_init() - Initialize currently selected serial port
  *
  * This function initializes the currently selected serial port. This
  * usually involves setting up the registers of that particular port,
  * enabling clock and such. This function uses the get_current() call
  * to determine which port is selected.
  *
  * Returns 0 on success, negative on error.
  */
 int serial_init(void)
 {
 	gd->flags |= GD_FLG_SERIAL_READY;
 	return get_current()->start();
 }
 /**
  * serial_setbrg() - Configure baud-rate of currently selected serial port
  *
  * This function configures the baud-rate of the currently selected
  * serial port. The baud-rate is retrieved from global data within
  * the serial port driver. This function uses the get_current() call
  * to determine which port is selected.
  *
  * Returns 0 on success, negative on error.
  */
 void serial_setbrg(void)
 {
 	get_current()->setbrg();
 }
 /**
  * serial_getc() - Read character from currently selected serial port
  *
  * This function retrieves a character from currently selected serial
  * port. In case there is no character waiting on the serial port,
  * this function will block and wait for the character to appear. This
  * function uses the get_current() call to determine which port is
  * selected.
  *
  * Returns the character on success, negative on error.
  */
 int serial_getc(void)
 {
 	return get_current()->getc();
 }
 /**
  * serial_tstc() - Test if data is available on currently selected serial port
  *
  * This function tests if one or more characters are available on
  * currently selected serial port. This function never blocks. This
  * function uses the get_current() call to determine which port is
  * selected.
  *
  * Returns positive if character is available, zero otherwise.
  */
 int serial_tstc(void)
 {
 	return get_current()->tstc();
 }
 /**
  * serial_putc() - Output character via currently selected serial port
  * @c:	Single character to be output from the serial port.
  *
  * This function outputs a character via currently selected serial
  * port. This character is passed to the serial port driver responsible
  * for controlling the hardware. The hardware may still be in process
  * of transmitting another character, therefore this function may block
  * for a short amount of time. This function uses the get_current()
  * call to determine which port is selected.
  */
 void serial_putc(const char c)
 {
 	get_current()->putc(c);
 }
 /**
  * serial_puts() - Output string via currently selected serial port
  * @s:	Zero-terminated string to be output from the serial port.
  *
  * This function outputs a zero-terminated string via currently
  * selected serial port. This function behaves as an accelerator
  * in case the hardware can queue multiple characters for transfer.
  * The whole string that is to be output is available to the function
  * implementing the hardware manipulation. Transmitting the whole
  * string may take some time, thus this function may block for some
  * amount of time. This function uses the get_current() call to
  * determine which port is selected.
  */
 void serial_puts(const char *s)
 {
 	get_current()->puts(s);
 }
 /**
  * default_serial_puts() - Output string by calling serial_putc() in loop
  * @s:	Zero-terminated string to be output from the serial port.
  *
  * This function outputs a zero-terminated string by calling serial_putc()
  * in a loop. Most drivers do not support queueing more than one byte for
  * transfer, thus this function precisely implements their serial_puts().
  *
  * To optimize the number of get_current() calls, this function only
  * calls get_current() once and then directly accesses the putc() call
  * of the &struct serial_device .
  */
 void default_serial_puts(const char *s)
 {
 	struct serial_device *dev = get_current();
 	while (*s)
 		dev->putc(*s++);
 }
 #if CONFIG_POST & CONFIG_SYS_POST_UART
 static const int bauds[] = CONFIG_SYS_BAUDRATE_TABLE;
 /**
  * uart_post_test() - Test the currently selected serial port using POST
  * @flags:	POST framework flags
  *
  * Do a loopback test of the currently selected serial port. This
  * function is only useful in the context of the POST testing framwork.
  * The serial port is first configured into loopback mode and then
  * characters are sent through it.
  *
  * Returns 0 on success, value otherwise.
  */
 /* Mark weak until post/cpu/.../uart.c migrate over */
 __weak
 int uart_post_test(int flags)
 {
 	unsigned char c;
 	int ret, saved_baud, b;
 	struct serial_device *saved_dev, *s;
 	/* Save current serial state */
 	ret = 0;
 	saved_dev = serial_current;
 	saved_baud = gd->baudrate;
 	for (s = serial_devices; s; s = s->next) {
 		/* If this driver doesn't support loop back, skip it */
 		if (!s->loop)
 			continue;
 		/* Test the next device */
 		serial_current = s;
 		ret = serial_init();
 		if (ret)
 			goto done;
 		/* Consume anything that happens to be queued */
 		while (serial_tstc())
 			serial_getc();
 		/* Enable loop back */
 		s->loop(1);
 		/* Test every available baud rate */
 		for (b = 0; b < ARRAY_SIZE(bauds); ++b) {
 			gd->baudrate = bauds[b];
 			serial_setbrg();
 			/*
 			 * Stick to printable chars to avoid issues:
 			 *  - terminal corruption
 			 *  - serial program reacting to sequences and sending
 			 *    back random extra data
 			 *  - most serial drivers add in extra chars (like \r\n)
 			 */
 			for (c = 0x20; c < 0x7f; ++c) {
 				/* Send it out */
 				serial_putc(c);
 				/* Make sure it's the same one */
 				ret = (c != serial_getc());
 				if (ret) {
 					s->loop(0);
 					goto done;
 				}
 				/* Clean up the output in case it was sent */
 				serial_putc('\b');
 				ret = ('\b' != serial_getc());
 				if (ret) {
 					s->loop(0);
 					goto done;
 				}
 			}
 		}
 		/* Disable loop back */
 		s->loop(0);
 		/* XXX: There is no serial_stop() !? */
 		if (s->stop)
 			s->stop();
 	}
  done:
 	/* Restore previous serial state */
 	serial_current = saved_dev;
 	gd->baudrate = saved_baud;
 	serial_reinit_all();
 	serial_setbrg();
 	return ret;
 }
 #endif

drivers/serial/serial_xen.c

Diff comments View file @ e0343ea

 /*
  * Copyright 2018 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <debug_uart.h>
 #include <dm.h>
 #include <errno.h>
 #include <fdtdec.h>
 #include <linux/compiler.h>
 #include <serial.h>
 #include <xen/events.h>
 #include <xen/hvm.h>
 #include <xen/interface/sched.h>
 #include <xen/interface/hvm/hvm_op.h>
 #include <xen/interface/hvm/params.h>
 #include <xen/interface/io/console.h>
 #include <xen/interface/io/ring.h>
 DECLARE_GLOBAL_DATA_PTR;
 #ifdef CONFIG_DM_SERIAL
 struct xen_uart_priv {
 	struct xencons_interface *intf;
 	u32 evtchn;
 	int vtermno;
 	struct hvc_struct *hvc;
 	grant_ref_t gntref;
 };
 int xen_serial_setbrg(struct udevice *dev, int baudrate)
 {
 	return 0;
 }
 static int xen_serial_probe(struct udevice *dev)
 {
 	struct xen_uart_priv *priv = dev_get_priv(dev);
 	u64 v = 0;
 	unsigned long gfn;
 	int r;
 	r = hvm_get_parameter(HVM_PARAM_CONSOLE_EVTCHN, &v);
 	if (r < 0 || v == 0)
 		return r;
 	priv->evtchn = v;
 	r = hvm_get_parameter(HVM_PARAM_CONSOLE_PFN, &v);
 	if (r < 0 || v == 0)
 		return -ENODEV;
 	gfn = v;
 	priv->intf = (struct xencons_interface *)(gfn << XEN_PAGE_SHIFT);
 	if (!priv->intf)
 		return -EINVAL;
 	return 0;
 }
 static int xen_serial_pending(struct udevice *dev, bool input)
 {
 	struct xen_uart_priv *priv = dev_get_priv(dev);
 	struct xencons_interface *intf = priv->intf;
 	if (!input || intf->in_cons == intf->in_prod)
 		return 0;
 	return 1;
 }
 static int xen_serial_getc(struct udevice *dev)
 {
 	struct xen_uart_priv *priv = dev_get_priv(dev);
 	struct xencons_interface *intf = priv->intf;
 	XENCONS_RING_IDX cons;
 	char c;
 	while (intf->in_cons == intf->in_prod) {
 		mb(); /* wait */
 	}
 	cons = intf->in_cons;
 	mb();			/* get pointers before reading ring */
 	c = intf->in[MASK_XENCONS_IDX(cons++, intf->in)];
 	mb();			/* read ring before consuming */
 	intf->in_cons = cons;
 	notify_remote_via_evtchn(priv->evtchn);
 	return c;
 }
 static int __write_console(struct udevice *dev, const char *data, int len)
 {
 	struct xen_uart_priv *priv = dev_get_priv(dev);
 	struct xencons_interface *intf = priv->intf;
 	XENCONS_RING_IDX cons, prod;
 	int sent = 0;
 	cons = intf->out_cons;
 	prod = intf->out_prod;
 	mb(); /* Update pointer */
 	WARN_ON((prod - cons) > sizeof(intf->out));
 	while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
 		intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
 	mb(); /* Update data before pointer */
 	intf->out_prod = prod;
 	if (sent)
 		notify_remote_via_evtchn(priv->evtchn);
 	if (data[sent - 1] == '\n')
 		serial_puts("\r");
 	return sent;
 }
 static int write_console(struct udevice *dev, const char *data, int len)
 {
 	/*
 	 * Make sure the whole buffer is emitted, polling if
 	 * necessary.  We don't ever want to rely on the hvc daemon
 	 * because the most interesting console output is when the
 	 * kernel is crippled.
 	 */
 	while (len) {
 		int sent = __write_console(dev, data, len);
 		data += sent;
 		len -= sent;
 		if (unlikely(len))
 			HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
 	}
 	return 0;
 }
 static int xen_serial_puts(struct udevice *dev, const char *str)
 {
 	write_console(dev, str, strlen(str));
 	return 0;
 }
 static int xen_serial_putc(struct udevice *dev, const char ch)
 {
 	write_console(dev, &ch, 1);
 	return 0;
 }
 static const struct dm_serial_ops xen_serial_ops = {
 	.puts = xen_serial_puts,
 	.putc = xen_serial_putc,
 	.getc = xen_serial_getc,
 	.pending = xen_serial_pending,
 };
 static const struct udevice_id xen_serial_ids[] = {
 	{ .compatible = "xen,xen" },
 	{ }
 };
 U_BOOT_DRIVER(serial_xen) = {
 	.name	= "serial_xen",
 	.id	= UCLASS_SERIAL,
 	.of_match = xen_serial_ids,
 	.priv_auto_alloc_size = sizeof(struct xen_uart_priv),
 	.probe = xen_serial_probe,
 	.ops	= &xen_serial_ops,
 	.flags = DM_FLAG_PRE_RELOC,
 };
 #else
+static void xen_serial_putc(const char c)
+{
+	(void)HYPERVISOR_console_io(CONSOLEIO_write, 1, &c);
+}
+static void xen_serial_puts(const char *str)
+{
+	(void)HYPERVISOR_console_io(CONSOLEIO_write, strlen(str), str);
+}
+static int xen_serial_tstc(void)
+{
+	return 0;
+}
+static int xen_serial_init(void)
+{
+}
+static void xen_serial_setbrg(void)
+{
+}
+static struct serial_device xen_serial_drv = {
+	.name	= "xen_serial",
+	.start	= xen_serial_init,
+	.stop	= NULL,
+	.setbrg	= xen_serial_setbrg,
+	.getc	= NULL,
+	.putc	= xen_serial_putc,
+	.puts	= xen_serial_puts,
+	.tstc	= xen_serial_tstc,
+};
 __weak struct serial_device *default_serial_console(void)
 {
-	return NULL;
+	return &xen_serial_drv;
 }
 #endif
 #ifdef CONFIG_DEBUG_UART_XEN
 void _debug_uart_init(void)
 {
 }
 void _debug_uart_putc(int ch)
 {
 	/* If \n, also do \r */
 	if (ch == '\n')
 		serial_putc('\r');
 	(void)HYPERVISOR_console_io(CONSOLEIO_write, 1, &ch);
 	return;
 }
 DEBUG_UART_FUNCS
 #endif

include/configs/imx8qm_mek_android_auto_xen.h

Diff comments View file @ e0343ea

 /*
  * Copyright 2018 NXP
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef IMX8QM_MEK_ANDROID_AUTO_XEN_H
 #define IMX8QM_MEK_ANDROID_AUTO_XEN_H
 #undef CONFIG_SYS_SDRAM_BASE
 #undef CONFIG_NR_DRAM_BANKS
 #undef PHYS_SDRAM_1
 #undef PHYS_SDRAM_2
 #undef PHYS_SDRAM_1_SIZE
 #undef PHYS_SDRAM_2_SIZE
 #define CONFIG_SYS_SDRAM_BASE		0x80000000
 #define CONFIG_NR_DRAM_BANKS		2
 #define PHYS_SDRAM_1			0x80000000
 #define PHYS_SDRAM_2			0x200000000
 #define PHYS_SDRAM_1_SIZE		0x80000000	/* 2 GB */
 #define PHYS_SDRAM_2_SIZE		0x50000000	/* 1280 MB */
 #undef CONFIG_LOADADDR
 #define CONFIG_LOADADDR			0x80080000
 #undef CONFIG_SYS_INIT_SP_ADDR
-#define CONFIG_SYS_INIT_SP_ADDR		0x80200000
+#define CONFIG_SYS_INIT_SP_ADDR		0x81200000
 #undef CONFIG_REQUIRE_SERIAL_CONSOLE
 #undef CONFIG_IMX_SMMU
 #undef CONFIG_FASTBOOT_USB_DEV
 #define CONFIG_FASTBOOT_USB_DEV 0 /* Use OTG port, not typec port */
 /* This needs to be stay same in iomem in domu.cfg */
 #ifdef SC_IPC_CH
 #undef SC_IPC_CH
 #endif
 #define SC_IPC_CH			0x5d1d0000
+#ifdef CONFIG_SPL_BUILD
+#undef CONFIG_SPL_BSS_START_ADDR
+#undef CONFIG_SYS_SPL_MALLOC_START
+#undef CONFIG_MALLOC_F_ADDR
+#undef CONFIG_SPL_TEXT_BASE
+#undef CONFIG_SPL_STACK
+#define CONFIG_SPL_TEXT_BASE		0x80080000
+#define CONFIG_MALLOC_F_ADDR		0x80100000
+#define CONFIG_SYS_SPL_MALLOC_START	0x80200000
+#define CONFIG_SPL_BSS_START_ADDR	0x80300000
+#define CONFIG_SPL_STACK		0x80400000
+#define CONFIG_SYS_SPL_PTE_RAM_BASE	0x80500000
+#endif
 #define AVB_AB_I_UNDERSTAND_LIBAVB_AB_IS_DEPRECATED
 #endif /* IMX8QM_MEK_ANDROID_AUTO_XEN_H */

lib/avb/fsl/fsl_avb_ab_flow.c

Diff comments View file @ e0343ea

 /*
  * Copyright 2018 NXP
  */
 #include <common.h>
 #include <fsl_avb.h>
 #include <mmc.h>
 #include <spl.h>
 #include <part.h>
 #include <image.h>
 #include "utils.h"
 #include "fsl_caam.h"
 #include "fsl_avbkey.h"
 #if defined(CONFIG_DUAL_BOOTLOADER) || !defined(CONFIG_SPL_BUILD)
 static const char* slot_suffixes[2] = {"_a", "_b"};
 /* This is a copy of slot_set_unbootable() form
  * external/avb/libavb_ab/avb_ab_flow.c.
  */
 void fsl_slot_set_unbootable(AvbABSlotData* slot) {
 	slot->priority = 0;
 	slot->tries_remaining = 0;
 	slot->successful_boot = 0;
 }
 /* Ensure all unbootable and/or illegal states are marked as the
  * canonical 'unbootable' state, e.g. priority=0, tries_remaining=0,
  * and successful_boot=0. This is a copy of slot_normalize from
  * external/avb/libavb_ab/avb_ab_flow.c.
  */
 void fsl_slot_normalize(AvbABSlotData* slot) {
 	if (slot->priority > 0) {
 #if defined(CONFIG_DUAL_BOOTLOADER) && !defined(CONFIG_SPL_BUILD)
 		if ((slot->tries_remaining == 0)
 			&& (!slot->successful_boot) && (slot->bootloader_verified != 1)) {
 			/* We've exhausted all tries -> unbootable. */
 			fsl_slot_set_unbootable(slot);
 		}
 #else
 		if ((slot->tries_remaining == 0) && (!slot->successful_boot)) {
 			/* We've exhausted all tries -> unbootable. */
 			fsl_slot_set_unbootable(slot);
 		}
 #endif
 		if ((slot->tries_remaining > 0) && (slot->successful_boot)) {
 			/* Illegal state - avb_ab_mark_slot_successful() will clear
 			* tries_remaining when setting successful_boot.
 			*/
 			fsl_slot_set_unbootable(slot);
 		}
 	} else {
 		fsl_slot_set_unbootable(slot);
 	}
 }
 /* This is a copy of slot_is_bootable() from
  * externel/avb/libavb_ab/avb_ab_flow.c.
  */
 bool fsl_slot_is_bootable(AvbABSlotData* slot) {
 	return (slot->priority > 0) &&
 		(slot->successful_boot || (slot->tries_remaining > 0));
 }
 #endif /* CONFIG_DUAL_BOOTLOADER || !CONFIG_SPL_BUILD */
 #if defined(CONFIG_DUAL_BOOTLOADER) && defined(CONFIG_SPL_BUILD)
 #define FSL_AB_METADATA_MISC_PARTITION_OFFSET 2048
 #define PARTITION_NAME_LEN 13
 #define PARTITION_MISC "misc"
 #define PARTITION_BOOTLOADER "bootloader"
 extern int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value);
 extern int mmc_load_image_parse_container(struct spl_image_info *spl_image,
 					struct mmc *mmc, unsigned long sector);
 /* Pre-declaration of h_spl_load_read(), see detail implementation in
  * common/spl/spl_mmc.c.
  */
 ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
 		      ulong count, void *buf);
 void fsl_avb_ab_data_update_crc_and_byteswap(const AvbABData* src,
 					     AvbABData* dest) {
 	memcpy(dest, src, sizeof(AvbABData));
 	dest->crc32 = cpu_to_be32(
 			avb_crc32((const uint8_t*)dest,
 				  sizeof(AvbABData) - sizeof(uint32_t)));
 }
 void fsl_avb_ab_data_init(AvbABData* data) {
 	memset(data, '\0', sizeof(AvbABData));
 	memcpy(data->magic, AVB_AB_MAGIC, AVB_AB_MAGIC_LEN);
 	data->version_major = AVB_AB_MAJOR_VERSION;
 	data->version_minor = AVB_AB_MINOR_VERSION;
 	data->slots[0].priority = AVB_AB_MAX_PRIORITY;
 	data->slots[0].tries_remaining = AVB_AB_MAX_TRIES_REMAINING;
 	data->slots[0].successful_boot = 0;
 	data->slots[0].bootloader_verified = 0;
 	data->slots[1].priority = AVB_AB_MAX_PRIORITY - 1;
 	data->slots[1].tries_remaining = AVB_AB_MAX_TRIES_REMAINING;
 	data->slots[1].successful_boot = 0;
 	data->slots[1].bootloader_verified = 0;
 }
 bool fsl_avb_ab_data_verify_and_byteswap(const AvbABData* src,
 					 AvbABData* dest) {
 	/* Ensure magic is correct. */
 	if (memcmp(src->magic, AVB_AB_MAGIC, AVB_AB_MAGIC_LEN) != 0) {
 		printf("Magic is incorrect.\n");
 		return false;
 	}
 	memcpy(dest, src, sizeof(AvbABData));
 	dest->crc32 = be32_to_cpu(dest->crc32);
 	/* Ensure we don't attempt to access any fields if the major version
 	* is not supported.
 	*/
 	if (dest->version_major > AVB_AB_MAJOR_VERSION) {
 		printf("No support for given major version.\n");
 		return false;
 	}
 	/* Fail if CRC32 doesn't match. */
 	if (dest->crc32 !=
 		avb_crc32((const uint8_t*)dest, sizeof(AvbABData) - sizeof(uint32_t))) {
 		printf("CRC32 does not match.\n");
 		return false;
 	}
 	return true;
 }
 /* Writes A/B metadata to disk only if it has changed.
  */
 int fsl_save_metadata_if_changed_dual_uboot(struct blk_desc *dev_desc,
 					    AvbABData* ab_data,
 					    AvbABData* ab_data_orig) {
 	AvbABData serialized;
 	size_t num_bytes;
 	disk_partition_t info;
 	/* Save metadata if changed. */
 	if (memcmp(ab_data, ab_data_orig, sizeof(AvbABData)) != 0) {
 		/* Get misc partition info */
 		if (part_get_info_by_name(dev_desc, PARTITION_MISC, &info) == -1) {
 			printf("Can't get partition info of partition: misc\n");
 			return -1;
 		}
 		/* Writing A/B metadata to disk. */
 		fsl_avb_ab_data_update_crc_and_byteswap(ab_data, &serialized);
 		if (write_to_partition_in_bytes(dev_desc, &info,
 				FSL_AB_METADATA_MISC_PARTITION_OFFSET,
 				sizeof(AvbABData),
 				(void *)&serialized, &num_bytes) ||
 				(num_bytes != sizeof(AvbABData))) {
 			printf("Error--write metadata fail!\n");
 			return -1;
 		}
 	}
 	return 0;
 }
 /* Load metadate from misc partition.
  */
 int fsl_load_metadata_dual_uboot(struct blk_desc *dev_desc,
 				 AvbABData* ab_data,
 				 AvbABData* ab_data_orig) {
 	disk_partition_t info;
 	AvbABData serialized;
 	size_t num_bytes;
 	if (part_get_info_by_name(dev_desc, PARTITION_MISC, &info) == -1) {
 		printf("Can't get partition info of partition: misc\n");
 		return -1;
 	} else {
 		read_from_partition_in_bytes(dev_desc, &info,
 						FSL_AB_METADATA_MISC_PARTITION_OFFSET,
 						sizeof(AvbABData),
 						(void *)ab_data, &num_bytes );
 		if (num_bytes != sizeof(AvbABData)) {
 			printf("Error--read metadata fail!\n");
 			return -1;
 		} else {
 			if (!fsl_avb_ab_data_verify_and_byteswap(ab_data, &serialized)) {
 				printf("Error validating A/B metadata from disk.\n");
 				printf("Resetting and writing new A/B metadata to disk.\n");
 				fsl_avb_ab_data_init(ab_data);
 				fsl_avb_ab_data_update_crc_and_byteswap(ab_data, &serialized);
 				num_bytes = 0;
 				if (write_to_partition_in_bytes(
 					dev_desc, &info,
 					FSL_AB_METADATA_MISC_PARTITION_OFFSET,
 					sizeof(AvbABData),
 					(void *)&serialized, &num_bytes) ||
 					(num_bytes != sizeof(AvbABData))) {
 					printf("Error--write metadata fail!\n");
 					return -1;
 				} else
 					return 0;
 			} else {
 				memcpy(ab_data_orig, ab_data, sizeof(AvbABData));
 				/* Ensure data is normalized, e.g. illegal states will be marked as
 				 * unbootable and all unbootable states are represented with
 				 * (priority=0, tries_remaining=0, successful_boot=0).
 				 */
 				fsl_slot_normalize(&ab_data->slots[0]);
 				fsl_slot_normalize(&ab_data->slots[1]);
 				return 0;
 			}
 		}
 	}
 }
+#ifndef CONFIG_XEN
 static int spl_verify_rbidx(struct mmc *mmc, AvbABSlotData *slot,
 			struct spl_image_info *spl_image)
 {
 	kblb_hdr_t hdr;
 	kblb_tag_t *rbk;
 	uint64_t extract_idx;
 #ifdef CONFIG_AVB_ATX
 	struct bl_rbindex_package *bl_rbindex;
 #endif
 	/* Make sure rollback index has been initialized before verify */
 	if (rpmb_init()) {
 		printf("RPMB init failed!\n");
 		return -1;
 	}
 	/* Read bootloader rollback index header first. */
 	if (rpmb_read(mmc, (uint8_t *)&hdr, sizeof(hdr),
 			BOOTLOADER_RBIDX_OFFSET) != 0) {
 		printf("Read RPMB error!\n");
 		return -1;
 	}
 	/* Read bootloader rollback index. */
 	rbk = &(hdr.bootloader_rbk_tags);
 	if (rpmb_read(mmc, (uint8_t *)&extract_idx, rbk->len, rbk->offset) != 0) {
 		printf("Read rollback index error!\n");
 		return -1;
 	}
 	/* Verify bootloader rollback index. */
 	if (spl_image->rbindex >= extract_idx) {
 		/* Rollback index verify pass, update it only when current slot
 		 * has been marked as successful.
 		 */
 		if ((slot->successful_boot != 0) && (spl_image->rbindex != extract_idx) &&
 				rpmb_write(mmc, (uint8_t *)(&(spl_image->rbindex)),
 				rbk->len, rbk->offset)) {
 			printf("Update bootloader rollback index failed!\n");
 			return -1;
 		}
 #ifdef CONFIG_AVB_ATX
 		/* Pass bootloader rbindex to u-boot here. */
 		bl_rbindex = (struct bl_rbindex_package *)BL_RBINDEX_LOAD_ADDR;
 		memcpy(bl_rbindex->magic, BL_RBINDEX_MAGIC, BL_RBINDEX_MAGIC_LEN);
 		if (slot->successful_boot != 0)
 			bl_rbindex->rbindex = spl_image->rbindex;
 		else
 			bl_rbindex->rbindex = extract_idx;
 #endif
 		return 0;
 	} else {
 		printf("Rollback index verify rejected!\n");
 		return -1;
 	}
 }
+#endif /* CONFIG_XEN */
 #ifdef CONFIG_PARSE_CONTAINER
 int mmc_load_image_parse_container_dual_uboot(
 		struct spl_image_info *spl_image, struct mmc *mmc)
 {
 	disk_partition_t info;
 	int ret = 0, n = 0;
 	char partition_name[PARTITION_NAME_LEN];
 	struct blk_desc *dev_desc;
 	AvbABData ab_data, ab_data_orig;
 	size_t slot_index_to_boot, target_slot;
+#ifndef CONFIG_XEN
 	struct keyslot_package kp;
+#endif
 	/* Check if gpt is valid */
 	dev_desc = mmc_get_blk_desc(mmc);
 	if (dev_desc) {
 		if (part_get_info(dev_desc, 1, &info)) {
 			printf("GPT is invalid, please flash correct GPT!\n");
 			return -1;
 		}
 	} else {
 		printf("Get block desc fail!\n");
 		return -1;
 	}
-	/* Read RPMB keyslot package */
+#ifndef CONFIG_XEN
+	/* Read RPMB keyslot package, xen won't check this. */
 	read_keyslot_package(&kp);
 	if (strcmp(kp.magic, KEYPACK_MAGIC)) {
 		if (rpmbkey_is_set()) {
 			printf("\nFATAL - RPMB key was destroyed!\n");
 			hang();
 		} else
 			printf("keyslot package magic error, do nothing here!\n");
 	} else {
 		/* Set power-on write protection to boot1 partition. */
 		if (mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP, BOOT1_PWR_WP)) {
 			printf("Unable to set power-on write protection to boot1!\n");
 			return -1;
 		}
 	}
+#endif
 	/* Load AB metadata from misc partition */
 	if (fsl_load_metadata_dual_uboot(dev_desc, &ab_data,
 					&ab_data_orig)) {
 		return -1;
 	}
 	slot_index_to_boot = 2;  // Means not 0 or 1
 	target_slot =
 	    (ab_data.slots[1].priority > ab_data.slots[0].priority) ? 1 : 0;
 	for (n = 0; n < 2; n++) {
 		if (!fsl_slot_is_bootable(&ab_data.slots[target_slot])) {
 			target_slot = (target_slot == 1 ? 0 : 1);
 			continue;
 		}
 		/* Choose slot to load. */
 		snprintf(partition_name, PARTITION_NAME_LEN,
 			 PARTITION_BOOTLOADER"%s",
 			 slot_suffixes[target_slot]);
 		/* Read part info from gpt */
 		if (part_get_info_by_name(dev_desc, partition_name, &info) == -1) {
 			printf("Can't get partition info of partition bootloader%s\n",
 				slot_suffixes[target_slot]);
 			ret = -1;
 			goto end;
 		} else {
 			ret = mmc_load_image_parse_container(spl_image, mmc, info.start);
+			/* Don't need to check rollback index for xen. */
+#ifndef CONFIG_XEN
 			/* Image loaded successfully, go to verify rollback index */
 			if (!ret && rpmbkey_is_set())
 				ret = spl_verify_rbidx(mmc, &ab_data.slots[target_slot], spl_image);
 			/* Copy rpmb keyslot to secure memory. */
 			if (!ret)
 				fill_secure_keyslot_package(&kp);
+#endif
 		}
 		/* Set current slot to unbootable if load/verify fail. */
 		if (ret != 0) {
 			printf("Load or verify bootloader%s fail, setting unbootable..\n",
 			       slot_suffixes[target_slot]);
 			fsl_slot_set_unbootable(&ab_data.slots[target_slot]);
 			/* Switch to another slot. */
 			target_slot = (target_slot == 1 ? 0 : 1);
 		} else {
 			slot_index_to_boot = target_slot;
 			n = 2;
 		}
 	}
 	if (slot_index_to_boot == 2) {
 		/* No bootable slots! */
 		printf("No bootable slots found.\n");
 		ret = -1;
 		goto end;
 	} else if (!ab_data.slots[slot_index_to_boot].successful_boot &&
 		   (ab_data.slots[slot_index_to_boot].tries_remaining > 0)) {
 		/* Set the bootloader_verified flag if current slot only has one chance. */
 		if (ab_data.slots[slot_index_to_boot].tries_remaining == 1)
 			ab_data.slots[slot_index_to_boot].bootloader_verified = 1;
 		ab_data.slots[slot_index_to_boot].tries_remaining -= 1;
 	}
 	printf("Booting from bootloader%s...\n", slot_suffixes[slot_index_to_boot]);
 end:
 	/* Save metadata if changed. */
 	if (fsl_save_metadata_if_changed_dual_uboot(dev_desc, &ab_data, &ab_data_orig)) {
 		ret = -1;
 	}
 	if (ret)
 		return -1;
 	else
 		return 0;
 }
 #else /* CONFIG_PARSE_CONTAINER */
 int mmc_load_image_raw_sector_dual_uboot(
 		struct spl_image_info *spl_image, struct mmc *mmc)
 {
 	unsigned long count;
 	disk_partition_t info;
 	int ret = 0, n = 0;
 	char partition_name[PARTITION_NAME_LEN];
 	struct blk_desc *dev_desc;
 	struct image_header *header;
 	AvbABData ab_data, ab_data_orig;
 	size_t slot_index_to_boot, target_slot;
 	struct keyslot_package kp;
 	/* Check if gpt is valid */
 	dev_desc = mmc_get_blk_desc(mmc);
 	if (dev_desc) {
 		if (part_get_info(dev_desc, 1, &info)) {
 			printf("GPT is invalid, please flash correct GPT!\n");
 			return -1;
 		}
 	} else {
 		printf("Get block desc fail!\n");
 		return -1;
 	}
 	/* Init RPMB keyslot package if not initialized before. */
 	read_keyslot_package(&kp);
 	if (strcmp(kp.magic, KEYPACK_MAGIC)) {
 		printf("keyslot package magic error. Will generate new one\n");
 		if (gen_rpmb_key(&kp)) {
 			printf("Generate keyslot package fail!\n");
 			return -1;
 		}
 	}
 	/* Set power-on write protection to boot1 partition. */
 	if (mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_WP, BOOT1_PWR_WP)) {
 		printf("Unable to set power-on write protection to boot1!\n");
 		return -1;
 	}
 	/* Load AB metadata from misc partition */
 	if (fsl_load_metadata_dual_uboot(dev_desc, &ab_data,
 					&ab_data_orig)) {
 		return -1;
 	}
 	slot_index_to_boot = 2;  // Means not 0 or 1
 	target_slot =
 	    (ab_data.slots[1].priority > ab_data.slots[0].priority) ? 1 : 0;
 	for (n = 0; n < 2; n++) {
 		if (!fsl_slot_is_bootable(&ab_data.slots[target_slot])) {
 			target_slot = (target_slot == 1 ? 0 : 1);
 			continue;
 		}
 		/* Choose slot to load. */
 		snprintf(partition_name, PARTITION_NAME_LEN,
 			 PARTITION_BOOTLOADER"%s",
 			 slot_suffixes[target_slot]);
 		/* Read part info from gpt */
 		if (part_get_info_by_name(dev_desc, partition_name, &info) == -1) {
 			printf("Can't get partition info of partition bootloader%s\n",
 				slot_suffixes[target_slot]);
 			ret = -1;
 			goto end;
 		} else {
 			header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
 				 sizeof(struct image_header));
 			/* read image header to find the image size & load address */
 			count = blk_dread(dev_desc, info.start, 1, header);
 			if (count == 0) {
 				ret = -1;
 				goto end;
 			}
 			/* Load fit and check HAB */
 			if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
 					image_get_magic(header) == FDT_MAGIC) {
 				struct spl_load_info load;
 				debug("Found FIT\n");
 				load.dev = mmc;
 				load.priv = NULL;
 				load.filename = NULL;
 				load.bl_len = mmc->read_bl_len;
 				load.read = h_spl_load_read;
 				ret = spl_load_simple_fit(spl_image, &load,
 							  info.start, header);
 			} else {
 				ret = -1;
 			}
 			/* Fit image loaded successfully, go to verify rollback index */
 			if (!ret)
 				ret = spl_verify_rbidx(mmc, &ab_data.slots[target_slot], spl_image);
 			/* Copy rpmb keyslot to secure memory. */
 			if (!ret)
 				fill_secure_keyslot_package(&kp);
 		}
 		/* Set current slot to unbootable if load/verify fail. */
 		if (ret != 0) {
 			printf("Load or verify bootloader%s fail, setting unbootable..\n",
 			       slot_suffixes[target_slot]);
 			fsl_slot_set_unbootable(&ab_data.slots[target_slot]);
 			/* Switch to another slot. */
 			target_slot = (target_slot == 1 ? 0 : 1);
 		} else {
 			slot_index_to_boot = target_slot;
 			n = 2;
 		}
 	}
 	if (slot_index_to_boot == 2) {
 		/* No bootable slots! */
 		printf("No bootable slots found.\n");
 		ret = -1;
 		goto end;
 	} else if (!ab_data.slots[slot_index_to_boot].successful_boot &&
 		   (ab_data.slots[slot_index_to_boot].tries_remaining > 0)) {
 		/* Set the bootloader_verified flag as if current slot only has one chance. */
 		if (ab_data.slots[slot_index_to_boot].tries_remaining == 1)
 			ab_data.slots[slot_index_to_boot].bootloader_verified = 1;
 		ab_data.slots[slot_index_to_boot].tries_remaining -= 1;
 	}
 	printf("Booting from bootloader%s...\n", slot_suffixes[slot_index_to_boot]);
 end:
 	/* Save metadata if changed. */
 	if (fsl_save_metadata_if_changed_dual_uboot(dev_desc, &ab_data, &ab_data_orig)) {
 		ret = -1;
 	}
 	if (ret)
 		return -1;
 	else
 		return 0;
 }
 /*
  * spl_fit_get_rbindex(): Get rollback index of the bootloader.
  * @fit:	Pointer to the FDT blob.
  * @images:	Offset of the /images subnode.
  *
  * Return:	the rollback index value of bootloader or a negative
  * 		error number.
  */
 int spl_fit_get_rbindex(const void *fit, int images)
 {
 	const char *str;
 	uint64_t index;
 	int conf_node;
 	int len;
 	conf_node = fit_find_config_node(fit);
 	if (conf_node < 0) {
 		return conf_node;
 	}
 	str = fdt_getprop(fit, conf_node, "rbindex", &len);
 	if (!str) {
 		debug("cannot find property 'rbindex'\n");
 		return -EINVAL;
 	}
 	index = simple_strtoul(str, NULL, 10);
 	return index;
 }
 #endif /* CONFIG_PARSE_CONTAINER */
 /* For normal build */
 #elif !defined(CONFIG_SPL_BUILD)
 /* Writes A/B metadata to disk only if it has been changed.
  */
 static AvbIOResult fsl_save_metadata_if_changed(AvbABOps* ab_ops,
 						AvbABData* ab_data,
 						AvbABData* ab_data_orig) {
 	if (avb_safe_memcmp(ab_data, ab_data_orig, sizeof(AvbABData)) != 0) {
 		avb_debug("Writing A/B metadata to disk.\n");
 		return ab_ops->write_ab_metadata(ab_ops, ab_data);
 	}
 	return AVB_IO_RESULT_OK;
 }
 /* Helper function to load metadata - returns AVB_IO_RESULT_OK on
  * success, error code otherwise. This is a copy of load_metadata()
  * from /lib/avb/libavb_ab/avb_ab_flow.c.
  */
 static AvbIOResult fsl_load_metadata(AvbABOps* ab_ops,
 				     AvbABData* ab_data,
 				     AvbABData* ab_data_orig) {
 	AvbIOResult io_ret;
 	io_ret = ab_ops->read_ab_metadata(ab_ops, ab_data);
 	if (io_ret != AVB_IO_RESULT_OK) {
 		avb_error("I/O error while loading A/B metadata.\n");
 		return io_ret;
 	}
 	*ab_data_orig = *ab_data;
 	/* Ensure data is normalized, e.g. illegal states will be marked as
 	 * unbootable and all unbootable states are represented with
 	 * (priority=0, tries_remaining=0, successful_boot=0).
 	 */
 	fsl_slot_normalize(&ab_data->slots[0]);
 	fsl_slot_normalize(&ab_data->slots[1]);
 	return AVB_IO_RESULT_OK;
 }
 #ifdef CONFIG_DUAL_BOOTLOADER
 AvbABFlowResult avb_flow_dual_uboot(AvbABOps* ab_ops,
 				    const char* const* requested_partitions,
 				    AvbSlotVerifyFlags flags,
 				    AvbHashtreeErrorMode hashtree_error_mode,
 				    AvbSlotVerifyData** out_data) {
 	AvbOps* ops = ab_ops->ops;
 	AvbSlotVerifyData* slot_data = NULL;
 	AvbSlotVerifyData* data = NULL;
 	AvbABFlowResult ret;
 	AvbABData ab_data, ab_data_orig;
 	AvbIOResult io_ret;
 	bool saw_and_allowed_verification_error = false;
 	AvbSlotVerifyResult verify_result;
 	bool set_slot_unbootable = false;
 	int target_slot, n;
 	uint64_t rollback_index_value = 0;
 	uint64_t current_rollback_index_value = 0;
 	io_ret = fsl_load_metadata(ab_ops, &ab_data, &ab_data_orig);
 	if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 		ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 		goto out;
 	} else if (io_ret != AVB_IO_RESULT_OK) {
 		ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 		goto out;
 	}
 	/* Choose the target slot, it should be the same with the one in SPL. */
 	target_slot = get_curr_slot(&ab_data);
 	if (target_slot == -1) {
 		ret = AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS;
 		printf("No bootable slot found!\n");
 		goto out;
 	}
 	/* Clear the bootloader_verified flag. */
 	ab_data.slots[target_slot].bootloader_verified = 0;
 	printf("Verifying slot %s ...\n", slot_suffixes[target_slot]);
 	verify_result = avb_slot_verify(ops,
 					requested_partitions,
 					slot_suffixes[target_slot],
 					flags,
 					hashtree_error_mode,
 					&slot_data);
 	switch (verify_result) {
 		case AVB_SLOT_VERIFY_RESULT_ERROR_OOM:
 			ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 			goto out;
 		case AVB_SLOT_VERIFY_RESULT_ERROR_IO:
 			ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 			goto out;
 		case AVB_SLOT_VERIFY_RESULT_OK:
 			ret = AVB_AB_FLOW_RESULT_OK;
 			break;
 		case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA:
 		case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION:
 			/* Even with AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR
 			 * these mean game over.
 			 */
 			set_slot_unbootable = true;
 			break;
 		case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION:
 		case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX:
 		case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED:
 			if (flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR) {
 				/* Do nothing since we allow this. */
 				avb_debugv("Allowing slot ",
 					   slot_suffixes[target_slot],
 					   " which verified "
 					   "with result ",
 					   avb_slot_verify_result_to_string(verify_result),
 					   " because "
 					   "AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR "
 					   "is set.\n",
 					   NULL);
 				saw_and_allowed_verification_error =
 					 true;
 			} else {
 				set_slot_unbootable = true;
 			}
 			break;
 		case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT:
 			ret = AVB_AB_FLOW_RESULT_ERROR_INVALID_ARGUMENT;
 			goto out;
 			/* Do not add a 'default:' case here because
 			 * of -Wswitch.
 			 */
 	}
 	if (set_slot_unbootable) {
 		avb_errorv("Error verifying slot ",
 			   slot_suffixes[target_slot],
 			   " with result ",
 			   avb_slot_verify_result_to_string(verify_result),
 			   " - setting unbootable.\n",
 			   NULL);
 		fsl_slot_set_unbootable(&ab_data.slots[target_slot]);
 		/* Only the slot chosen by SPL will be verified here so we
 		 * return AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS if the
 		 * slot should be set unbootable.
 		 */
 		ret = AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS;
 		goto out;
 	}
 	/* Update stored rollback index only when the slot has been marked
 	 * as successful. Do this for every rollback index location.
 	*/
 	if (ab_data.slots[target_slot].successful_boot != 0) {
 		for (n = 0; n < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS; n++) {
 			rollback_index_value = slot_data->rollback_indexes[n];
 			if (rollback_index_value != 0) {
 				io_ret = ops->read_rollback_index(
 						ops, n, &current_rollback_index_value);
 				if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 					ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 					goto out;
 				} else if (io_ret != AVB_IO_RESULT_OK) {
 					avb_error("Error getting rollback index for slot.\n");
 					ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 					goto out;
 				}
 				if (current_rollback_index_value != rollback_index_value) {
 					io_ret = ops->write_rollback_index(
 							ops, n, rollback_index_value);
 					if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 						ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 						goto out;
 					} else if (io_ret != AVB_IO_RESULT_OK) {
 						avb_error("Error setting stored rollback index.\n");
 						ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 						goto out;
 					}
 				}
 			}
 		}
 	}
 	/* Finally, select this slot. */
 	avb_assert(slot_data != NULL);
 	data = slot_data;
 	slot_data = NULL;
 	if (saw_and_allowed_verification_error) {
 		avb_assert(
 			flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR);
 		ret = AVB_AB_FLOW_RESULT_OK_WITH_VERIFICATION_ERROR;
 	} else {
 		ret = AVB_AB_FLOW_RESULT_OK;
 	}
 out:
 	io_ret = fsl_save_metadata_if_changed(ab_ops, &ab_data, &ab_data_orig);
 	if (io_ret != AVB_IO_RESULT_OK) {
 		if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 			ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 		} else {
 			ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 		}
 		if (data != NULL) {
 			avb_slot_verify_data_free(data);
 			data = NULL;
 		}
 	}
 	if (slot_data != NULL)
 		avb_slot_verify_data_free(slot_data);
 	if (out_data != NULL) {
 		*out_data = data;
 	} else {
 		if (data != NULL) {
 			avb_slot_verify_data_free(data);
 		}
 	}
 	return ret;
 }
 #else /* CONFIG_DUAL_BOOTLOADER */
 /* For legacy i.mx6/7, we won't enable A/B due to the limitation of
  * storage capacity, but we still want to verify boot/recovery with
  * AVB. */
 AvbABFlowResult avb_single_flow(AvbABOps* ab_ops,
                             const char* const* requested_partitions,
                             AvbSlotVerifyFlags flags,
                             AvbHashtreeErrorMode hashtree_error_mode,
                             AvbSlotVerifyData** out_data) {
   AvbOps* ops = ab_ops->ops;
   AvbSlotVerifyData* slot_data = NULL;
   AvbSlotVerifyData* data = NULL;
   AvbABFlowResult ret;
   bool saw_and_allowed_verification_error = false;
   /* Validate boot/recovery. */
   AvbSlotVerifyResult verify_result;
   verify_result = avb_slot_verify(ops,
                     requested_partitions,
                     "",
                     flags,
                     hashtree_error_mode,
                     &slot_data);
   switch (verify_result) {
       case AVB_SLOT_VERIFY_RESULT_ERROR_OOM:
         ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
         goto out;
       case AVB_SLOT_VERIFY_RESULT_ERROR_IO:
         ret = AVB_AB_FLOW_RESULT_ERROR_IO;
         goto out;
       case AVB_SLOT_VERIFY_RESULT_OK:
         break;
       case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA:
       case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION:
           /* Even with AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR
            * these mean game over.
            */
         ret = AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS;
         goto out;
       /* explicit fallthrough. */
       case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION:
       case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX:
       case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED:
         if (flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR) {
           /* Do nothing since we allow this. */
           avb_debugv("Allowing slot ",
                      slot_suffixes[n],
                      " which verified "
                      "with result ",
                      avb_slot_verify_result_to_string(verify_result),
                      " because "
                      "AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR "
                      "is set.\n",
                      NULL);
           saw_and_allowed_verification_error = true;
         } else {
             ret = AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS;
             goto out;
         }
         break;
       case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT:
         ret = AVB_AB_FLOW_RESULT_ERROR_INVALID_ARGUMENT;
         goto out;
         /* Do not add a 'default:' case here because of -Wswitch. */
       }
   avb_assert(slot_data != NULL);
   data = slot_data;
   slot_data = NULL;
   if (saw_and_allowed_verification_error) {
     avb_assert(flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR);
     ret = AVB_AB_FLOW_RESULT_OK_WITH_VERIFICATION_ERROR;
   } else {
     ret = AVB_AB_FLOW_RESULT_OK;
   }
 out:
   if (slot_data != NULL) {
     avb_slot_verify_data_free(slot_data);
   }
   if (out_data != NULL) {
     *out_data = data;
   } else {
     if (data != NULL) {
       avb_slot_verify_data_free(data);
     }
   }
   return ret;
 }
 AvbABFlowResult avb_ab_flow_fast(AvbABOps* ab_ops,
 				 const char* const* requested_partitions,
 				 AvbSlotVerifyFlags flags,
 				 AvbHashtreeErrorMode hashtree_error_mode,
 				 AvbSlotVerifyData** out_data) {
 	AvbOps* ops = ab_ops->ops;
 	AvbSlotVerifyData* slot_data[2] = {NULL, NULL};
 	AvbSlotVerifyData* data = NULL;
 	AvbABFlowResult ret;
 	AvbABData ab_data, ab_data_orig;
 	size_t slot_index_to_boot, n;
 	AvbIOResult io_ret;
 	bool saw_and_allowed_verification_error = false;
 	size_t target_slot;
 	AvbSlotVerifyResult verify_result;
 	bool set_slot_unbootable = false;
 	uint64_t rollback_index_value = 0;
 	uint64_t current_rollback_index_value = 0;
 	io_ret = fsl_load_metadata(ab_ops, &ab_data, &ab_data_orig);
 	if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 		ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 		goto out;
 	} else if (io_ret != AVB_IO_RESULT_OK) {
 		ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 		goto out;
 	}
 	slot_index_to_boot = 2;  // Means not 0 or 1
 	target_slot =
 	    (ab_data.slots[1].priority > ab_data.slots[0].priority) ? 1 : 0;
 	for (n = 0; n < 2; n++) {
 		if (!fsl_slot_is_bootable(&ab_data.slots[target_slot])) {
 			target_slot = (target_slot == 1 ? 0 : 1);
 			continue;
 		}
 		verify_result = avb_slot_verify(ops,
 						requested_partitions,
 						slot_suffixes[target_slot],
 						flags,
 						hashtree_error_mode,
 						&slot_data[target_slot]);
 		switch (verify_result) {
 			case AVB_SLOT_VERIFY_RESULT_ERROR_OOM:
 				ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 				goto out;
 			case AVB_SLOT_VERIFY_RESULT_ERROR_IO:
 				ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 				goto out;
 			case AVB_SLOT_VERIFY_RESULT_OK:
 				slot_index_to_boot = target_slot;
 				n = 2;
 				break;
 			case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA:
 			case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION:
 				/* Even with AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR
 				 * these mean game over.
 				 */
 				set_slot_unbootable = true;
 				break;
 			/* explicit fallthrough. */
 			case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION:
 			case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX:
 			case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED:
 				if (flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR) {
 					/* Do nothing since we allow this. */
 					avb_debugv("Allowing slot ",
 						   slot_suffixes[target_slot],
 						   " which verified "
 						   "with result ",
 						   avb_slot_verify_result_to_string(verify_result),
 						   " because "
 						   "AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR "
 						   "is set.\n",
 						   NULL);
 					saw_and_allowed_verification_error =
 						 true;
 					slot_index_to_boot = target_slot;
 					n = 2;
 				} else {
 					set_slot_unbootable = true;
 				}
 				break;
 			case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT:
 				ret = AVB_AB_FLOW_RESULT_ERROR_INVALID_ARGUMENT;
 				goto out;
 				/* Do not add a 'default:' case here because
 				 * of -Wswitch.
 				 */
 		}
 		if (set_slot_unbootable) {
 			avb_errorv("Error verifying slot ",
 				   slot_suffixes[target_slot],
 				   " with result ",
 				   avb_slot_verify_result_to_string(verify_result),
 				   " - setting unbootable.\n",
 				   NULL);
 			fsl_slot_set_unbootable(&ab_data.slots[target_slot]);
 			set_slot_unbootable = false;
 		}
 		/* switch to another slot */
 		target_slot = (target_slot == 1 ? 0 : 1);
 	}
 	if (slot_index_to_boot == 2) {
 		/* No bootable slots! */
 		avb_error("No bootable slots found.\n");
 		ret = AVB_AB_FLOW_RESULT_ERROR_NO_BOOTABLE_SLOTS;
 		goto out;
 	}
 	/* Update stored rollback index only when the slot has been marked
 	 * as successful. Do this for every rollback index location.
 	*/
 	if (ab_data.slots[slot_index_to_boot].successful_boot != 0) {
 		for (n = 0; n < AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS; n++) {
 			rollback_index_value = slot_data[slot_index_to_boot]->rollback_indexes[n];
 			if (rollback_index_value != 0) {
 				io_ret = ops->read_rollback_index(
 						ops, n, &current_rollback_index_value);
 				if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 					ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 					goto out;
 				} else if (io_ret != AVB_IO_RESULT_OK) {
 					avb_error("Error getting rollback index for slot.\n");
 					ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 					goto out;
 				}
 				if (current_rollback_index_value != rollback_index_value) {
 					io_ret = ops->write_rollback_index(
 							ops, n, rollback_index_value);
 					if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 						ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 						goto out;
 					} else if (io_ret != AVB_IO_RESULT_OK) {
 						avb_error("Error setting stored rollback index.\n");
 						ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 						goto out;
 					}
 				}
 			}
 		}
 	}
 	/* Finally, select this slot. */
 	avb_assert(slot_data[slot_index_to_boot] != NULL);
 	data = slot_data[slot_index_to_boot];
 	slot_data[slot_index_to_boot] = NULL;
 	if (saw_and_allowed_verification_error) {
 		avb_assert(
 			flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR);
 		ret = AVB_AB_FLOW_RESULT_OK_WITH_VERIFICATION_ERROR;
 	} else {
 		ret = AVB_AB_FLOW_RESULT_OK;
 	}
 	/* ... and decrement tries remaining, if applicable. */
 	if (!ab_data.slots[slot_index_to_boot].successful_boot &&
 	    (ab_data.slots[slot_index_to_boot].tries_remaining > 0)) {
 		ab_data.slots[slot_index_to_boot].tries_remaining -= 1;
 	}
 out:
 	io_ret = fsl_save_metadata_if_changed(ab_ops, &ab_data, &ab_data_orig);
 	if (io_ret != AVB_IO_RESULT_OK) {
 		if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 			ret = AVB_AB_FLOW_RESULT_ERROR_OOM;
 		} else {
 			ret = AVB_AB_FLOW_RESULT_ERROR_IO;
 		}
 		if (data != NULL) {
 			avb_slot_verify_data_free(data);
 			data = NULL;
 		}
 	}
 	for (n = 0; n < 2; n++) {
 		if (slot_data[n] != NULL) {
 			avb_slot_verify_data_free(slot_data[n]);
 		}
 	}
 	if (out_data != NULL) {
 		*out_data = data;
 	} else {
 		if (data != NULL) {
 			avb_slot_verify_data_free(data);
 		}
 	}
 	return ret;
 }
 #endif /* CONFIG_DUAL_BOOTLOADER */
 #endif /* CONFIG_DUAL_BOOTLOADER && CONFIG_SPL_BUILD */