Skip to contentSkip to conversation

console: Implement flush() function

PATCH In review Pali Rohár 5 participants 34 messages Sep 5, 2022 – Sep 24, 2022

lore
Share & tools
lore
#0 lore raw

v3 cover console: Implement flush() function

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

 arch/sandbox/cpu/os.c          |  5 +++
 boot/bootm_os.c                |  1 +
 cmd/boot.c                     |  1 +
 cmd/elf.c                      |  2 ++
 cmd/load.c                     |  5 +++
 common/Kconfig                 |  6 ++++
 common/console.c               | 64 ++++++++++++++++++++++++++++++++++
 common/stdio.c                 |  8 +++++
 drivers/serial/serial-uclass.c | 31 ++++++++++++++++
 include/_exports.h             |  3 ++
 include/os.h                   |  8 +++++
 include/serial.h               |  5 +++
 include/stdio.h                | 15 ++++++++
 include/stdio_dev.h            |  7 ++++
 14 files changed, 161 insertions(+)
Signature · 1 line
2.20.1
#1 lore raw

PATCH v3 1/6 sandbox: Add function os_flush()

It flushes stdout.

---
 arch/sandbox/cpu/os.c | 5 +++++
 include/os.h          | 8 ++++++++
 2 files changed, 13 insertions(+)
arch/sandbox/cpu/os.c +5 -0
index f937991139c9..01845e388d35 100644
@@ -669,6 +669,11 @@ void os_puts(const char *str)
 		os_putc(*str++);
 }
 
+void os_flush(void)
+{
+	fflush(stdout);
+}
+
 int os_write_ram_buf(const char *fname)
 {
 	struct sandbox_state *state = state_get_current();
include/os.h +8 -0
index 148178787bc2..5b353ae9d94b 100644
@@ -295,6 +295,14 @@ void os_putc(int ch);
  */
 void os_puts(const char *str);
 
+/**
+ * os_flush() - flush controlling OS terminal
+ *
+ * This bypasses the U-Boot console support and flushes directly the OS
+ * stdout file descriptor.
+ */
+void os_flush(void);
+
 /**
  * os_write_ram_buf() - write the sandbox RAM buffer to a existing file
  *
Signature · 1 line
2.20.1
#17 lore raw

PATCH v3 5/6 serial: Call flush() before changing baudrate

In reply to Pali Rohár

Changing baudrate is a sensitive operation. To ensure that U-Boot messages printed before changing baudrate are not lost, call new U-Boot console flush() function.

---
Changes in v3:
* Remove support from serial.c
* Fix commit message

---
 cmd/load.c                     | 5 +++++
 drivers/serial/serial-uclass.c | 1 +
 2 files changed, 6 insertions(+)
cmd/load.c +5 -0
index e44ae0d56b75..5c4f34781d45 100644
@@ -83,6 +83,7 @@ static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ENTER ...\n",
 			load_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = load_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -126,6 +127,7 @@ static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -317,6 +319,7 @@ int do_save_serial(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			(int)current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -471,6 +474,7 @@ static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ENTER ...\n",
 			load_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = load_baudrate;
 		serial_setbrg();
 		udelay(50000);
@@ -533,6 +537,7 @@ static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
 		printf("## Switch baudrate to %d bps and press ESC ...\n",
 			current_baudrate);
 		udelay(50000);
+		flush();
 		gd->baudrate = current_baudrate;
 		serial_setbrg();
 		udelay(50000);
drivers/serial/serial-uclass.c +1 -0
index f028da0900cd..04b753c229ab 100644
@@ -476,6 +476,7 @@ static int on_baudrate(const char *name, const char *value, enum env_op op,
 			printf("## Switch baudrate to %d bps and press ENTER ...\n",
 			       baudrate);
 			udelay(50000);
+			flush();
 		}
 
 		gd->baudrate = baudrate;
Signature · 1 line
2.20.1
#10 lore raw

PATCH v3 4/6 serial: Implement serial_flush() function for console flush() fallback

In reply to Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

---
 common/console.c               |  3 +++
 common/stdio.c                 |  8 ++++++++
 drivers/serial/serial-uclass.c | 10 ++++++++++
 include/serial.h               |  5 +++++
 4 files changed, 26 insertions(+)
common/console.c +3 -0
index 0abfc224b53b..e4dc1da44a35 100644
@@ -797,6 +797,9 @@ void flush(void)
 	if (gd->flags & GD_FLG_DEVINIT) {
 		/* Send to the standard output */
 		fflush(stdout);
+	} else {
+		/* Send directly to the handler */
+		serial_flush();
 	}
 }
 #endif
common/stdio.c +8 -0
index 92161a0df87d..13083842cbd9 100644
@@ -87,6 +87,13 @@ static void stdio_serial_puts(struct stdio_dev *dev, const char *s)
 	serial_puts(s);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void stdio_serial_flush(struct stdio_dev *dev)
+{
+	serial_flush();
+}
+#endif
+
 static int stdio_serial_getc(struct stdio_dev *dev)
 {
 	return serial_getc();
@@ -112,6 +119,7 @@ static void drv_system_init (void)
 	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT;
 	dev.putc = stdio_serial_putc;
 	dev.puts = stdio_serial_puts;
+	STDIO_DEV_ASSIGN_FLUSH(&dev, stdio_serial_flush);
 	dev.getc = stdio_serial_getc;
 	dev.tstc = stdio_serial_tstc;
 	stdio_register (&dev);
drivers/serial/serial-uclass.c +10 -0
index be6502f3d24c..f028da0900cd 100644
@@ -327,6 +327,16 @@ void serial_puts(const char *str)
 		_serial_puts(gd->cur_serial_dev, str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+void serial_flush(void)
+{
+	if (!gd->cur_serial_dev)
+		return;
+
+	_serial_flush(gd->cur_serial_dev);
+}
+#endif
+
 int serial_getc(void)
 {
 	if (!gd->cur_serial_dev)
include/serial.h +5 -0
index 8c2e7adbc321..f9009d4046e3 100644
@@ -362,6 +362,11 @@ void serial_setbrg(void);
 void serial_putc(const char ch);
 void serial_putc_raw(const char ch);
 void serial_puts(const char *str);
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+void serial_flush(void);
+#else
+static inline void serial_flush(void) {}
+#endif
 int serial_getc(void);
 int serial_tstc(void);
 
Signature · 1 line
2.20.1
#4 lore raw

PATCH v3 2/6 console: Implement flush() function

In reply to Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Therefore introduce a new flush() and fflush() functions into console code. These functions will call .flush callback of associated stdio_dev device.

As this function may increase U-Boot side, allow to compile U-Boot without this function. For this purpose there is a new config CONSOLE_FLUSH_SUPPORT which is enabled by default and can be disabled. It is a good idea to have this option enabled for all boards which have enough space for it.

When option is disabled when U-Boot defines just empty static inline function fflush() to avoid ifdefs in other code.

---
Changes in v3:
* Added macro STDIO_DEV_ASSIGN_FLUSH()

---
 common/Kconfig      |  6 +++++
 common/console.c    | 61 +++++++++++++++++++++++++++++++++++++++++++++
 include/_exports.h  |  3 +++
 include/stdio.h     | 15 +++++++++++
 include/stdio_dev.h |  7 ++++++
 5 files changed, 92 insertions(+)
common/Kconfig +6 -0
index e7914ca750a3..109741cc6c44 100644
@@ -186,6 +186,12 @@ config PRE_CON_BUF_ADDR
 	  We should consider removing this option and allocating the memory
 	  in board_init_f_init_reserve() instead.
 
+config CONSOLE_FLUSH_SUPPORT
+	bool "Enable console flush support"
+	default y
+	help
+	  This enables compilation of flush() function for console flush support.
+
 config CONSOLE_MUX
 	bool "Enable console multiplexing"
 	default y if DM_VIDEO || VIDEO || LCD
common/console.c +61 -0

91 lines not on this page · raw message

include/_exports.h +3 -0
index f6df8b610734..1af946fac327 100644
@@ -12,6 +12,9 @@
 	EXPORT_FUNC(tstc, int, tstc, void)
 	EXPORT_FUNC(putc, void, putc, const char)
 	EXPORT_FUNC(puts, void, puts, const char *)
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+	EXPORT_FUNC(flush, void, flush, void)
+#endif
 	EXPORT_FUNC(printf, int, printf, const char*, ...)
 #if (defined(CONFIG_X86) && !defined(CONFIG_X86_64)) || defined(CONFIG_PPC)
 	EXPORT_FUNC(irq_install_handler, void, install_hdlr,
include/stdio.h +15 -0
index 1939a48f0fb6..3241e2d493fa 100644
@@ -15,6 +15,11 @@ int tstc(void);
 		defined(CONFIG_SPL_SERIAL))
 void putc(const char c);
 void puts(const char *s);
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+void flush(void);
+#else
+static inline void flush(void) {}
+#endif
 int __printf(1, 2) printf(const char *fmt, ...);
 int vprintf(const char *fmt, va_list args);
 #else
@@ -26,6 +31,10 @@ static inline void puts(const char *s)
 {
 }
 
+static inline void flush(void)
+{
+}
+
 static inline int __printf(1, 2) printf(const char *fmt, ...)
 {
 	return 0;
@@ -48,11 +57,17 @@ static inline int vprintf(const char *fmt, va_list args)
 /* stderr */
 #define eputc(c)		fputc(stderr, c)
 #define eputs(s)		fputs(stderr, s)
+#define eflush()		fflush(stderr)
 #define eprintf(fmt, args...)	fprintf(stderr, fmt, ##args)
 
 int __printf(2, 3) fprintf(int file, const char *fmt, ...);
 void fputs(int file, const char *s);
 void fputc(int file, const char c);
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+void fflush(int file);
+#else
+static inline void fflush(int file) {}
+#endif
 int ftstc(int file);
 int fgetc(int file);
 
include/stdio_dev.h +7 -0
index 270fa2729fb2..3105928970db 100644
@@ -37,6 +37,13 @@ struct stdio_dev {
 	void (*putc)(struct stdio_dev *dev, const char c);
 	/* To put a string (accelerator) */
 	void (*puts)(struct stdio_dev *dev, const char *s);
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+	/* To flush output queue */
+	void (*flush)(struct stdio_dev *dev);
+#define STDIO_DEV_ASSIGN_FLUSH(dev, flush_func) ((dev)->flush = (flush_func))
+#else
+#define STDIO_DEV_ASSIGN_FLUSH(dev, flush_func)
+#endif
 
 /* INPUT functions */
 
Signature · 1 line
2.20.1
#19 lore raw

PATCH v3 6/6 boot: Call flush() before booting

In reply to Pali Rohár

In a lot of cases kernel resets UART HW. To ensure that U-Boot messages printed before booting the kernel are not lost, call new U-Boot console flush() function.

---
Changes in v3:
* Fix commit message

---
 boot/bootm_os.c | 1 +
 cmd/boot.c      | 1 +
 cmd/elf.c       | 2 ++
 3 files changed, 4 insertions(+)
boot/bootm_os.c +1 -0
index f31820cd07ef..079224ce585b 100644
@@ -303,6 +303,7 @@ static void do_bootvx_fdt(bootm_headers_t *images)
 #else
 	printf("## Starting vxWorks at 0x%08lx\n", (ulong)images->ep);
 #endif
+	flush();
 
 	boot_jump_vxworks(images);
 
cmd/boot.c +1 -0
index be67a5980de3..14839c1cedcc 100644
@@ -32,6 +32,7 @@ static int do_go(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 	addr = hextoul(argv[1], NULL);
 
 	printf ("## Starting application at 0x%08lX ...\n", addr);
+	flush();
 
 	/*
 	 * pass address parameter as argv[0] (aka command name),
cmd/elf.c +2 -0
index ce40d3f72a7c..b7b9f506a526 100644
@@ -72,6 +72,7 @@ int do_bootelf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		return rcode;
 
 	printf("## Starting application at 0x%08lx ...\n", addr);
+	flush();
 
 	/*
 	 * pass address parameter as argv[0] (aka command name),
@@ -274,6 +275,7 @@ int do_bootvx(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 		puts("## Not an ELF image, assuming binary\n");
 
 	printf("## Starting vxWorks at 0x%08lx ...\n", addr);
+	flush();
 
 	dcache_disable();
 #if defined(CONFIG_ARM64) && defined(CONFIG_ARMV8_PSCI)
Signature · 1 line
2.20.1
#6 lore raw

PATCH v3 3/6 serial: Implement flush callback

In reply to Pali Rohár

UART drivers have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted.

Implement flush callback via serial driver's pending(false) callback which waits until HW transmit all characters from the queue.

---
 drivers/serial/serial-uclass.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
drivers/serial/serial-uclass.c +20 -0
index 30650e37b0d7..be6502f3d24c 100644
@@ -238,6 +238,18 @@ static void _serial_puts(struct udevice *dev, const char *str)
 	} while (*str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void _serial_flush(struct udevice *dev)
+{
+	struct dm_serial_ops *ops = serial_get_ops(dev);
+
+	if (!ops->pending)
+		return;
+	while (ops->pending(dev, false) > 0)
+		;
+}
+#endif
+
 static int __serial_getc(struct udevice *dev)
 {
 	struct dm_serial_ops *ops = serial_get_ops(dev);
@@ -398,6 +410,13 @@ static void serial_stub_puts(struct stdio_dev *sdev, const char *str)
 	_serial_puts(sdev->priv, str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void serial_stub_flush(struct stdio_dev *sdev)
+{
+	_serial_flush(sdev->priv);
+}
+#endif
+
 static int serial_stub_getc(struct stdio_dev *sdev)
 {
 	return _serial_getc(sdev->priv);
@@ -520,6 +539,7 @@ static int serial_post_probe(struct udevice *dev)
 	sdev.priv = dev;
 	sdev.putc = serial_stub_putc;
 	sdev.puts = serial_stub_puts;
+	STDIO_DEV_ASSIGN_FLUSH(&sdev, serial_stub_flush);
 	sdev.getc = serial_stub_getc;
 	sdev.tstc = serial_stub_tstc;
 
Signature · 1 line
2.20.1
#7 lore raw

Re: [PATCH v3 3/6] serial: Implement flush callback

Hi

Il lun 5 set 2022, 11:32 Pali Rohár <[email protected]> ha scritto:

Quoted 6 lines

UART drivers have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted.

Implement flush callback via serial driver's pending(false) callback which waits until HW transmit all characters from the queue.

This is a drain if you want to wait. Is not the right terminology?

Michael

Quoted 57 lines
---
 drivers/serial/serial-uclass.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
drivers/serial/serial-uclass.c +12 -0
index 30650e37b0d7..be6502f3d24c 100644
@@ -238,6 +238,18 @@ static void _serial_puts(struct udevice *dev, const
 char *str)
        } while (*str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void _serial_flush(struct udevice *dev)
+{
+       struct dm_serial_ops *ops = serial_get_ops(dev);
+
+       if (!ops->pending)
+               return;
+       while (ops->pending(dev, false) > 0)
+               ;
+}
+#endif
+
 static int __serial_getc(struct udevice *dev)
 {
        struct dm_serial_ops *ops = serial_get_ops(dev);
drivers/serial/serial-uclass.c +7 -0
@@ -398,6 +410,13 @@ static void serial_stub_puts(struct stdio_dev *sdev,
 const char *str)
        _serial_puts(sdev->priv, str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void serial_stub_flush(struct stdio_dev *sdev)
+{
+       _serial_flush(sdev->priv);
+}
+#endif
+
 static int serial_stub_getc(struct stdio_dev *sdev)
 {
        return _serial_getc(sdev->priv);
drivers/serial/serial-uclass.c +1 -1
@@ -520,6 +539,7 @@ static int serial_post_probe(struct udevice *dev)
        sdev.priv = dev;
        sdev.putc = serial_stub_putc;
        sdev.puts = serial_stub_puts;
+       STDIO_DEV_ASSIGN_FLUSH(&sdev, serial_stub_flush);
        sdev.getc = serial_stub_getc;
        sdev.tstc = serial_stub_tstc;
 
--

2.20.1

#8 lore raw

Re: [PATCH v3 3/6] serial: Implement flush callback

Quoted 4 lines · On Monday 05 September 2022 19:24:17 Michael Nazzareno Trimarchi wrote:

Hi

Il lun 5 set 2022, 11:32 Pali Rohár <[email protected]> ha scritto:

Quoted 8 lines
Quoted 6 lines

UART drivers have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted.

Implement flush callback via serial driver's pending(false) callback which waits until HW transmit all characters from the queue.

This is a drain if you want to wait. Is not the right terminology?

Yes, for tty devices it is drain. But for C stdio.h it is (f)flush. Hence I used more generic name flush() as it is not only for serial devices, but for any U-Boot stdio device. E.g. sandbox os use real fflush function.

But feel free to choose any other name of function. I do not care a much about it.

Quoted 60 lines

Michael

Quoted 57 lines
---
 drivers/serial/serial-uclass.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
drivers/serial/serial-uclass.c +12 -0
index 30650e37b0d7..be6502f3d24c 100644
@@ -238,6 +238,18 @@ static void _serial_puts(struct udevice *dev, const
 char *str)
        } while (*str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void _serial_flush(struct udevice *dev)
+{
+       struct dm_serial_ops *ops = serial_get_ops(dev);
+
+       if (!ops->pending)
+               return;
+       while (ops->pending(dev, false) > 0)
+               ;
+}
+#endif
+
 static int __serial_getc(struct udevice *dev)
 {
        struct dm_serial_ops *ops = serial_get_ops(dev);
drivers/serial/serial-uclass.c +7 -0
@@ -398,6 +410,13 @@ static void serial_stub_puts(struct stdio_dev *sdev,
 const char *str)
        _serial_puts(sdev->priv, str);
 }
 
+#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+static void serial_stub_flush(struct stdio_dev *sdev)
+{
+       _serial_flush(sdev->priv);
+}
+#endif
+
 static int serial_stub_getc(struct stdio_dev *sdev)
 {
        return _serial_getc(sdev->priv);
drivers/serial/serial-uclass.c +1 -1
@@ -520,6 +539,7 @@ static int serial_post_probe(struct udevice *dev)
        sdev.priv = dev;
        sdev.putc = serial_stub_putc;
        sdev.puts = serial_stub_puts;
+       STDIO_DEV_ASSIGN_FLUSH(&sdev, serial_stub_flush);
        sdev.getc = serial_stub_getc;
        sdev.tstc = serial_stub_tstc;
 
--

2.20.1

Reviewed-by on v3 6/6
#20 lore raw

Re: [PATCH v3 6/6] boot: Call flush() before booting

In reply to Pali Rohár
Quoted 6 lines · Pali Rohár

In a lot of cases kernel resets UART HW. To ensure that U-Boot messages printed before booting the kernel are not lost, call new U-Boot console flush() function.

Quoted 9 lines

---
Changes in v3:
* Fix commit message

---
 boot/bootm_os.c | 1 +
 cmd/boot.c      | 1 +
 cmd/elf.c       | 2 ++
 3 files changed, 4 insertions(+)

although I'm not sure why the load.c change is not in this patch too?

Reviewed-by on v3 5/6
#18 lore raw

Re: [PATCH v3 5/6] serial: Call flush() before changing baudrate

In reply to Pali Rohár
Quoted 6 lines · Pali Rohár

Changing baudrate is a sensitive operation. To ensure that U-Boot messages printed before changing baudrate are not lost, call new U-Boot console flush() function.

Quoted 9 lines

---
Changes in v3:
* Remove support from serial.c
* Fix commit message

---
 cmd/load.c                     | 5 +++++
 drivers/serial/serial-uclass.c | 1 +
 2 files changed, 6 insertions(+)
Reviewed-by on v3 2/6
#5 lore raw
In reply to Pali Rohár

Hi Pali,

Quoted 21 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Therefore introduce a new flush() and fflush() functions into console code. These functions will call .flush callback of associated stdio_dev device.

As this function may increase U-Boot side, allow to compile U-Boot without this function. For this purpose there is a new config CONSOLE_FLUSH_SUPPORT which is enabled by default and can be disabled. It is a good idea to have this option enabled for all boards which have enough space for it.

When option is disabled when U-Boot defines just empty static inline function fflush() to avoid ifdefs in other code.

---
Changes in v3:
* Added macro STDIO_DEV_ASSIGN_FLUSH()

Quoted 7 lines
---
 common/Kconfig      |  6 +++++
 common/console.c    | 61 +++++++++++++++++++++++++++++++++++++++++++++
 include/_exports.h  |  3 +++
 include/stdio.h     | 15 +++++++++++
 include/stdio_dev.h |  7 ++++++
 5 files changed, 92 insertions(+)
Reviewed-by on v3 3/6
#9 lore raw

Re: [PATCH v3 3/6] serial: Implement flush callback

In reply to Pali Rohár
Quoted 11 lines · Pali Rohár

UART drivers have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted.

Implement flush callback via serial driver's pending(false) callback which waits until HW transmit all characters from the queue.

---
 drivers/serial/serial-uclass.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
Reviewed-by on v3 4/6
#11 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

In reply to Pali Rohár
Quoted 8 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

Quoted 7 lines
---
 common/console.c               |  3 +++
 common/stdio.c                 |  8 ++++++++
 drivers/serial/serial-uclass.c | 10 ++++++++++
 include/serial.h               |  5 +++++
 4 files changed, 26 insertions(+)
#21 lore raw

Re: [PATCH v3 6/6] boot: Call flush() before booting

In reply to Simon Glass
Quoted 1 line · On Wednesday 07 September 2022 15:10:54 Simon Glass wrote:

although I'm not sure why the load.c change is not in this patch too?

Because I split boot and serial/load changes into separate patches as they are different logical things.

#12 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

In reply to Pali Rohár
Quoted 9 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

This breaks building on a number of platforms such as ds109 probably due to DM_SERIAL not being enabled.

Signature · 1 line
Tom
#13 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

Quoted 9 lines · On Tuesday 20 September 2022 17:40:39 Tom Rini wrote:
Quoted 7 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

Quoted 5 lines
Quoted 2 lines

This breaks building on a number of platforms such as ds109 probably due to DM_SERIAL not being enabled.

ds109 is failing on error:

LD u-boot
arm-linux-gnueabihf-ld.bfd: common/console.o: in function `flush':
/tmp/u-boot/common/console.c:802: undefined reference to serial_flush' arm-linux-gnueabihf-ld.bfd: common/stdio.o: in function stdio_serial_flush':
/tmp/u-boot/common/stdio.c:93: undefined reference to `serial_flush'
make: *** [Makefile:1782: u-boot] Error 1

And serial_flush() is implemented only in serial-uclass.c (which is DM_SERIAL code).

So could you try to add this additional guard (into this 4/6 patch)?

include/serial.h +1 -1
index f9009d4046e3..fe01bcfadb9b 100644
@@ -362,7 +362,7 @@ void serial_setbrg(void);
 void serial_putc(const char ch);
 void serial_putc_raw(const char ch);
 void serial_puts(const char *str);
-#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+#if defined(CONFIG_CONSOLE_FLUSH_SUPPORT) && CONFIG_IS_ENABLED(DM_SERIAL)
 void serial_flush(void);
 #else
 static inline void serial_flush(void) {}

ds109 with this change compiles fine on my computer.

#14 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

Quoted 44 lines · Pali Rohár
Quoted 9 lines · On Tuesday 20 September 2022 17:40:39 Tom Rini wrote:
Quoted 7 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

Quoted 5 lines
Quoted 2 lines

This breaks building on a number of platforms such as ds109 probably due to DM_SERIAL not being enabled.

ds109 is failing on error:

LD u-boot
arm-linux-gnueabihf-ld.bfd: common/console.o: in function `flush':
/tmp/u-boot/common/console.c:802: undefined reference to serial_flush' arm-linux-gnueabihf-ld.bfd: common/stdio.o: in function stdio_serial_flush':
/tmp/u-boot/common/stdio.c:93: undefined reference to `serial_flush'
make: *** [Makefile:1782: u-boot] Error 1

And serial_flush() is implemented only in serial-uclass.c (which is DM_SERIAL code).

So could you try to add this additional guard (into this 4/6 patch)?

include/serial.h +1 -1
index f9009d4046e3..fe01bcfadb9b 100644
@@ -362,7 +362,7 @@ void serial_setbrg(void);
 void serial_putc(const char ch);
 void serial_putc_raw(const char ch);
 void serial_puts(const char *str);
-#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+#if defined(CONFIG_CONSOLE_FLUSH_SUPPORT) && CONFIG_IS_ENABLED(DM_SERIAL)
 void serial_flush(void);
 #else
 static inline void serial_flush(void) {}
Quoted 1 line

ds109 with this change compiles fine on my computer.

It should, but that means that CONSOLE_FLUSH_SUPPORT itself should be depending on DM_SERIAL.

Signature · 1 line
Tom
#15 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

Quoted 45 lines · On Tuesday 20 September 2022 18:29:02 Tom Rini wrote:
Quoted 44 lines · Pali Rohár
Quoted 9 lines · On Tuesday 20 September 2022 17:40:39 Tom Rini wrote:
Quoted 7 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

Quoted 5 lines
Quoted 2 lines

This breaks building on a number of platforms such as ds109 probably due to DM_SERIAL not being enabled.

ds109 is failing on error:

LD u-boot
arm-linux-gnueabihf-ld.bfd: common/console.o: in function `flush':
/tmp/u-boot/common/console.c:802: undefined reference to serial_flush' arm-linux-gnueabihf-ld.bfd: common/stdio.o: in function stdio_serial_flush':
/tmp/u-boot/common/stdio.c:93: undefined reference to `serial_flush'
make: *** [Makefile:1782: u-boot] Error 1

And serial_flush() is implemented only in serial-uclass.c (which is DM_SERIAL code).

So could you try to add this additional guard (into this 4/6 patch)?

include/serial.h +1 -1
index f9009d4046e3..fe01bcfadb9b 100644
@@ -362,7 +362,7 @@ void serial_setbrg(void);
 void serial_putc(const char ch);
 void serial_putc_raw(const char ch);
 void serial_puts(const char *str);
-#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+#if defined(CONFIG_CONSOLE_FLUSH_SUPPORT) && CONFIG_IS_ENABLED(DM_SERIAL)
 void serial_flush(void);
 #else
 static inline void serial_flush(void) {}
Quoted 4 lines
Quoted 1 line

ds109 with this change compiles fine on my computer.

It should, but that means that CONSOLE_FLUSH_SUPPORT itself should be depending on DM_SERIAL.

No. Because CONSOLE_FLUSH_SUPPORT has nothing with serial. You can have e.g. LCD/VGA or USB tty output console device on platform without serial console (where would be whole serial subsystem disabled) and still able to use new flush support.

#16 lore raw

Re: [PATCH v3 4/6] serial: Implement serial_flush() function for console flush() fallback

Quoted 51 lines · Pali Rohár
Quoted 45 lines · On Tuesday 20 September 2022 18:29:02 Tom Rini wrote:
Quoted 44 lines · Pali Rohár
Quoted 9 lines · On Tuesday 20 September 2022 17:40:39 Tom Rini wrote:
Quoted 7 lines · Pali Rohár

Like in all other console functions, implement also serial_flush() function as a fallback int console flush() function.

Flush support is available only when config option CONSOLE_FLUSH_SUPPORT is enabled. So when it is disabled then provides just empty static inline function serial_flush().

Quoted 5 lines
Quoted 2 lines

This breaks building on a number of platforms such as ds109 probably due to DM_SERIAL not being enabled.

ds109 is failing on error:

LD u-boot
arm-linux-gnueabihf-ld.bfd: common/console.o: in function `flush':
/tmp/u-boot/common/console.c:802: undefined reference to serial_flush' arm-linux-gnueabihf-ld.bfd: common/stdio.o: in function stdio_serial_flush':
/tmp/u-boot/common/stdio.c:93: undefined reference to `serial_flush'
make: *** [Makefile:1782: u-boot] Error 1

And serial_flush() is implemented only in serial-uclass.c (which is DM_SERIAL code).

So could you try to add this additional guard (into this 4/6 patch)?

include/serial.h +1 -1
index f9009d4046e3..fe01bcfadb9b 100644
@@ -362,7 +362,7 @@ void serial_setbrg(void);
 void serial_putc(const char ch);
 void serial_putc_raw(const char ch);
 void serial_puts(const char *str);
-#ifdef CONFIG_CONSOLE_FLUSH_SUPPORT
+#if defined(CONFIG_CONSOLE_FLUSH_SUPPORT) && CONFIG_IS_ENABLED(DM_SERIAL)
 void serial_flush(void);
 #else
 static inline void serial_flush(void) {}
Quoted 4 lines
Quoted 1 line

ds109 with this change compiles fine on my computer.

It should, but that means that CONSOLE_FLUSH_SUPPORT itself should be depending on DM_SERIAL.

Quoted 4 lines

No. Because CONSOLE_FLUSH_SUPPORT has nothing with serial. You can have e.g. LCD/VGA or USB tty output console device on platform without serial console (where would be whole serial subsystem disabled) and still able to use new flush support.

Ah, hum. I'll apply the above and look at the before/after for everyone before I suggest anything further.

Signature · 1 line
Tom
#22 lore raw
In reply to Pali Rohár
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Please see
https://u-boot.readthedocs.io/en/latest/develop/ci_testing.html for how to run CI on the world yourself before submitting v4. Thanks!

Signature · 1 line
Tom
#23 lore raw
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Quoted 3 lines

Please see
https://u-boot.readthedocs.io/en/latest/develop/ci_testing.html for how to run CI on the world yourself before submitting v4. Thanks!

#24 lore raw
Quoted 48 lines · Pali Rohár
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Quoted 6 lines

Any idea how to handle this issue?

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

Signature · 1 line
Tom
#25 lore raw

Hi,

Quoted 47 lines · Tom Rini
Quoted 45 lines · Pali Rohár
Quoted 43 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Quoted 4 lines
Quoted 4 lines

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

I think you should rename the EFI flush() function to something like efi_flush().

Quoted 10 lines
Quoted 5 lines

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

--
Tom

Regards,
Simon

#26 lore raw
Quoted 50 lines · Simon Glass

Hi,

Quoted 47 lines · Tom Rini
Quoted 45 lines · Pali Rohár
Quoted 43 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Quoted 7 lines
Quoted 4 lines
Quoted 4 lines

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

I think you should rename the EFI flush() function to something like efi_flush().

lib/efi_selftest/efi_selftest_loadimage.c has a static function flush() which will override any global flush() function in the context of the unit test. The unit test does not access the console so it is not really problematic. But I have no objections to renaming it to efi_st_flush().

Using flush() as name for a global function that only flushes the console seems a bit generic. Why not use flush_console() as name to clearly indicate what the function does?

Best regards

Heinrich

Quoted 14 lines
Quoted 11 lines
Quoted 6 lines

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

--
Tom

Regards,
Simon

#27 lore raw
In reply to Simon Glass
Quoted 50 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 47 lines · Tom Rini
Quoted 45 lines · Pali Rohár
Quoted 43 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Quoted 7 lines
Quoted 4 lines
Quoted 4 lines

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

I think you should rename the EFI flush() function to something like efi_flush().

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

Quoted 13 lines
Quoted 10 lines
Quoted 5 lines

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

--
Tom

Regards,
Simon

#28 lore raw
Quoted 56 lines · Pali Rohár
Quoted 55 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 51 lines · Tom Rini
Quoted 49 lines · Pali Rohár
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

Quoted 7 lines
Quoted 2 lines

I think you should rename the EFI flush() function to something like efi_flush().

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Best regards

Heinrich

Quoted 14 lines
Quoted 14 lines
Quoted 11 lines
Quoted 6 lines

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

--
Tom

Regards,
Simon

#29 lore raw
Quoted 60 lines · On Thursday 22 September 2022 17:06:31 Heinrich Schuchardt wrote:
Quoted 59 lines · Pali Rohár
Quoted 57 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 47 lines · Tom Rini
Quoted 45 lines · Pali Rohár
Quoted 43 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Quoted 4 lines
Quoted 4 lines

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

I think you should rename the EFI flush() function to something like efi_flush().

Quoted 8 lines
Quoted 4 lines

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Hello! I updated https://github.com/u-boot/u-boot/pull/241 pull request for CI test. I added there above efi_selftest patch and after that CI test passed.

So Tom, is this enough for you? Or do you need something more?

Quoted 19 lines

Best regards

Heinrich

Quoted 14 lines
Quoted 14 lines
Quoted 11 lines
Quoted 6 lines

The only option which I see how to address it is to revert those changes in source files which always calls flush() function and replace them by my first attempt which use guard #ifdef to ensure that flush() call is completely eliminated at preprocessor stage when efi is enabled.

Adding in Heinrich.

--
Tom

Regards,
Simon

#30 lore raw
Quoted 70 lines · Pali Rohár
Quoted 60 lines · On Thursday 22 September 2022 17:06:31 Heinrich Schuchardt wrote:
Quoted 59 lines · Pali Rohár
Quoted 57 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 47 lines · Tom Rini
Quoted 45 lines · Pali Rohár
Quoted 43 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

Quoted 4 lines
Quoted 4 lines

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

I think you should rename the EFI flush() function to something like efi_flush().

Quoted 8 lines
Quoted 4 lines

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Quoted 5 lines

Hello! I updated https://github.com/u-boot/u-boot/pull/241 pull request for CI test. I added there above efi_selftest patch and after that CI test passed.

So Tom, is this enough for you? Or do you need something more?

Were you also going to rename flush as suggested?

Signature · 1 line
Tom
#31 lore raw
Quoted 71 lines · On Friday 23 September 2022 11:57:30 Tom Rini wrote:
Quoted 70 lines · Pali Rohár
Quoted 68 lines · On Thursday 22 September 2022 17:06:31 Heinrich Schuchardt wrote:
Quoted 56 lines · Pali Rohár
Quoted 55 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 51 lines · Tom Rini
Quoted 49 lines · Pali Rohár
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

Quoted 7 lines
Quoted 2 lines

I think you should rename the EFI flush() function to something like efi_flush().

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Quoted 7 lines
Quoted 5 lines

Hello! I updated https://github.com/u-boot/u-boot/pull/241 pull request for CI test. I added there above efi_selftest patch and after that CI test passed.

So Tom, is this enough for you? Or do you need something more?

Were you also going to rename flush as suggested?

I have not done any renaming (yet). I pushed on CI test above efi_st fix and this patch series (with 4/6 build fix issue). Nothing more.

About renaming, I'm not sure what if flush_console() is better name as this is generic API and it can do e.g. flushing LCD output. Just like generic puts() or getc(). I just do not know if generic name is better or worse...

#32 lore raw
Quoted 80 lines · Pali Rohár
Quoted 71 lines · On Friday 23 September 2022 11:57:30 Tom Rini wrote:
Quoted 70 lines · Pali Rohár
Quoted 68 lines · On Thursday 22 September 2022 17:06:31 Heinrich Schuchardt wrote:
Quoted 56 lines · Pali Rohár
Quoted 55 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 51 lines · Tom Rini
Quoted 49 lines · Pali Rohár
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

Quoted 7 lines
Quoted 2 lines

I think you should rename the EFI flush() function to something like efi_flush().

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Quoted 7 lines
Quoted 5 lines

Hello! I updated https://github.com/u-boot/u-boot/pull/241 pull request for CI test. I added there above efi_selftest patch and after that CI test passed.

So Tom, is this enough for you? Or do you need something more?

Were you also going to rename flush as suggested?

Quoted 7 lines

I have not done any renaming (yet). I pushed on CI test above efi_st fix and this patch series (with 4/6 build fix issue). Nothing more.

About renaming, I'm not sure what if flush_console() is better name as this is generic API and it can do e.g. flushing LCD output. Just like generic puts() or getc(). I just do not know if generic name is better or worse...

I'm not sure either, lets wait a little bit longer to see if anyone else chimes in with a strong opinion?

Signature · 1 line
Tom
#33 lore raw

Hi,

Quoted 85 lines · Tom Rini
Quoted 83 lines · Pali Rohár
Quoted 71 lines · On Friday 23 September 2022 11:57:30 Tom Rini wrote:
Quoted 70 lines · Pali Rohár
Quoted 68 lines · On Thursday 22 September 2022 17:06:31 Heinrich Schuchardt wrote:
Quoted 56 lines · Pali Rohár
Quoted 55 lines · On Thursday 22 September 2022 13:27:51 Simon Glass wrote:

Hi,

Quoted 51 lines · Tom Rini
Quoted 49 lines · Pali Rohár
Quoted 37 lines · On Wednesday 21 September 2022 09:49:24 Tom Rini wrote:
Quoted 27 lines · Pali Rohár

On certain places it is required to flush output print buffers to ensure that text strings were sent to console or serial devices. For example when printing message that U-Boot is going to boot kernel or when U-Boot is going to change baudrate of terminal device.

Some console devices, like UART, have putc/puts functions which just put characters into HW transmit queue and do not wait until all data are transmitted. Doing some sensitive operations (like changing baudrate or starting kernel which resets UART HW) cause that U-Boot messages are lost.

Therefore introduce a new flush() function, implement it for all serial devices via pending(false) callback and use this new flush() function on sensitive places after which output device may go into reset state.

This change fixes printing of U-Boot messages:
"## Starting application at ..."
"## Switch baudrate to ..."

Changes in v3:
* add macro STDIO_DEV_ASSIGN_FLUSH()
* fix commit messages
* remove changes from serial.c

Changes in v2:
* split one big patch into smaller 6 patches
* add config option to allow disabling this new function

Quoted 7 lines

Pali Rohár (6):
sandbox: Add function os_flush()
console: Implement flush() function
serial: Implement flush callback
serial: Implement serial_flush() function for console flush() fallback
serial: Call flush() before changing baudrate
boot: Call flush() before booting

Quoted 6 lines

Including the change you suggested to 4/6 to fix that build issue, there's at least one more large issue that prevents CI from getting too far:
https://source.denx.de/u-boot/u-boot/-/pipelines/13534
and they all have a failure similar to:
https://source.denx.de/u-boot/u-boot/-/jobs/500794#L51

It looks like that some efi stuff overloads u-boot functions, in this case newly added flush() function.

Any idea how to handle this issue?

Quoted 7 lines
Quoted 2 lines

I think you should rename the EFI flush() function to something like efi_flush().

Ok! I renamed EFI flush() function to efi_flush().

I put all patches into github pull request which started CI test:
https://github.com/u-boot/u-boot/pull/241

When merging, please, use
[PATCH 1/1] efi_selftest: prefix test functions with efi_st_
https://lists.denx.de/pipermail/u-boot/2022-September/495334.html

Quoted 7 lines
Quoted 5 lines

Hello! I updated https://github.com/u-boot/u-boot/pull/241 pull request for CI test. I added there above efi_selftest patch and after that CI test passed.

So Tom, is this enough for you? Or do you need something more?

Were you also going to rename flush as suggested?

I have not done any renaming (yet). I pushed on CI test above efi_st fix and this patch series (with 4/6 build fix issue). Nothing more.

Quoted 7 lines
Quoted 4 lines

About renaming, I'm not sure what if flush_console() is better name as this is generic API and it can do e.g. flushing LCD output. Just like generic puts() or getc(). I just do not know if generic name is better or worse...

I'm not sure either, lets wait a little bit longer to see if anyone else chimes in with a strong opinion?

I feel that flush() is probably the right name for now, since this is a generic function as the rest of those functions don't have prefixes or suffixes.

Regards,
Simon