/* * (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(altera_jtag_serial_initialize); serial_initfunc(altera_serial_initialize); 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(ks8695_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(mpc512x_serial_initialize); serial_initfunc(mpc5xx_serial_initialize); serial_initfunc(mpc8260_scc_serial_initialize); serial_initfunc(mpc8260_smc_serial_initialize); serial_initfunc(mpc85xx_serial_initialize); serial_initfunc(mpc8xx_serial_initialize); serial_initfunc(mxc_serial_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(uartlite_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) { altera_jtag_serial_initialize(); altera_serial_initialize(); 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(); ks8695_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(); mpc512x_serial_initialize(); mpc5xx_serial_initialize(); mpc8260_scc_serial_initialize(); mpc8260_smc_serial_initialize(); mpc85xx_serial_initialize(); mpc8xx_serial_initialize(); mxc_serial_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(); uartlite_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); } int serial_stub_getc(struct stdio_dev *sdev) { struct serial_device *dev = sdev->priv; return dev->getc(); } 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 firstly 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