X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=drivers%2Fserial%2Fserial-uclass.c;h=7703c674929ceae005cf7e71d41f88fc9475f68c;hb=0ed0db985abaa95a326ebfd268785e0b310d9d5d;hp=9131a8f93d9a5adff359d2940ddfd6a6a05c445e;hpb=358b8bc204f365be28fed94f23e53e04183a8c7f;p=oweals%2Fu-boot.git diff --git a/drivers/serial/serial-uclass.c b/drivers/serial/serial-uclass.c index 9131a8f93d..7703c67492 100644 --- a/drivers/serial/serial-uclass.c +++ b/drivers/serial/serial-uclass.c @@ -1,22 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0+ /* * Copyright (c) 2014 The Chromium OS Authors. - * - * SPDX-License-Identifier: GPL-2.0+ */ #include #include -#include +#include #include -#include +#include #include #include #include #include #include #include - -#include +#include DECLARE_GLOBAL_DATA_PTR; @@ -25,63 +23,147 @@ DECLARE_GLOBAL_DATA_PTR; */ static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE; -#ifndef CONFIG_SYS_MALLOC_F_LEN -#error "Serial is required before relocation - define CONFIG_SYS_MALLOC_F_LEN to make this work" +#if !CONFIG_VAL(SYS_MALLOC_F_LEN) +#error "Serial is required before relocation - define CONFIG_$(SPL_)SYS_MALLOC_F_LEN to make this work" #endif -static void serial_find_console_or_panic(void) +#if CONFIG_IS_ENABLED(SERIAL_PRESENT) +static int serial_check_stdout(const void *blob, struct udevice **devp) { - struct udevice *dev; - -#ifdef CONFIG_OF_CONTROL - int node; + int node = -1; + const char *str, *p, *name; + int namelen; /* Check for a chosen console */ - node = fdtdec_get_chosen_node(gd->fdt_blob, "stdout-path"); - if (node < 0) - node = fdt_path_offset(gd->fdt_blob, "console"); - if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, &dev)) { - gd->cur_serial_dev = dev; - return; + str = fdtdec_get_chosen_prop(blob, "stdout-path"); + if (str) { + p = strchr(str, ':'); + namelen = p ? p - str : strlen(str); + node = fdt_path_offset_namelen(blob, str, namelen); + + if (node < 0) { + /* + * Deal with things like + * stdout-path = "serial0:115200n8"; + * + * We need to look up the alias and then follow it to + * the correct node. + */ + name = fdt_get_alias_namelen(blob, str, namelen); + if (name) + node = fdt_path_offset(blob, name); + } } + if (node < 0) + node = fdt_path_offset(blob, "console"); + if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, devp)) + return 0; + /* - * If the console is not marked to be bound before relocation, bind - * it anyway. + * If the console is not marked to be bound before relocation, bind it + * anyway. */ - if (node > 0 && - !lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &dev)) { - if (!device_probe(dev)) { + if (node > 0 && !lists_bind_fdt(gd->dm_root, offset_to_ofnode(node), + devp, false)) { + if (!device_probe(*devp)) + return 0; + } + + return -ENODEV; +} + +static void serial_find_console_or_panic(void) +{ + const void *blob = gd->fdt_blob; + struct udevice *dev; +#ifdef CONFIG_SERIAL_SEARCH_ALL + int ret; +#endif + + if (CONFIG_IS_ENABLED(OF_PLATDATA)) { + uclass_first_device(UCLASS_SERIAL, &dev); + if (dev) { gd->cur_serial_dev = dev; return; } + } else if (CONFIG_IS_ENABLED(OF_CONTROL) && blob) { + /* Live tree has support for stdout */ + if (of_live_active()) { + struct device_node *np = of_get_stdout(); + + if (np && !uclass_get_device_by_ofnode(UCLASS_SERIAL, + np_to_ofnode(np), &dev)) { + gd->cur_serial_dev = dev; + return; + } + } else { + if (!serial_check_stdout(blob, &dev)) { + gd->cur_serial_dev = dev; + return; + } + } } -#endif - /* - * Try to use CONFIG_CONS_INDEX if available (it is numbered from 1!). - * - * Failing that, get the device with sequence number 0, or in extremis - * just the first serial device we can find. But we insist on having - * a console (even if it is silent). - */ + if (!SPL_BUILD || !CONFIG_IS_ENABLED(OF_CONTROL) || !blob) { + /* + * Try to use CONFIG_CONS_INDEX if available (it is numbered + * from 1!). + * + * Failing that, get the device with sequence number 0, or in + * extremis just the first working serial device we can find. + * But we insist on having a console (even if it is silent). + */ #ifdef CONFIG_CONS_INDEX #define INDEX (CONFIG_CONS_INDEX - 1) #else #define INDEX 0 #endif - if (uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) && - uclass_get_device(UCLASS_SERIAL, INDEX, &dev) && - (uclass_first_device(UCLASS_SERIAL, &dev) || !dev)) - panic("No serial driver found"); + +#ifdef CONFIG_SERIAL_SEARCH_ALL + if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || + !uclass_get_device(UCLASS_SERIAL, INDEX, &dev)) { + if (dev->flags & DM_FLAG_ACTIVATED) { + gd->cur_serial_dev = dev; + return; + } + } + + /* Search for any working device */ + for (ret = uclass_first_device_check(UCLASS_SERIAL, &dev); + dev; + ret = uclass_next_device_check(&dev)) { + if (!ret) { + /* Device did succeed probing */ + gd->cur_serial_dev = dev; + return; + } + } +#else + if (!uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) || + !uclass_get_device(UCLASS_SERIAL, INDEX, &dev) || + (!uclass_first_device(UCLASS_SERIAL, &dev) && dev)) { + gd->cur_serial_dev = dev; + return; + } +#endif + #undef INDEX - gd->cur_serial_dev = dev; + } + +#ifdef CONFIG_REQUIRE_SERIAL_CONSOLE + panic_str("No serial driver found"); +#endif } +#endif /* CONFIG_SERIAL_PRESENT */ /* Called prior to relocation */ int serial_init(void) { +#if CONFIG_IS_ENABLED(SERIAL_PRESENT) serial_find_console_or_panic(); gd->flags |= GD_FLG_SERIAL_READY; + serial_setbrg(); +#endif return 0; } @@ -89,7 +171,7 @@ int serial_init(void) /* Called after relocation */ void serial_initialize(void) { - serial_find_console_or_panic(); + serial_init(); } static void _serial_putc(struct udevice *dev, char ch) @@ -97,11 +179,12 @@ static void _serial_putc(struct udevice *dev, char ch) struct dm_serial_ops *ops = serial_get_ops(dev); int err; + if (ch == '\n') + _serial_putc(dev, '\r'); + do { err = ops->putc(dev, ch); } while (err == -EAGAIN); - if (ch == '\n') - _serial_putc(dev, '\r'); } static void _serial_puts(struct udevice *dev, const char *str) @@ -110,7 +193,7 @@ static void _serial_puts(struct udevice *dev, const char *str) _serial_putc(dev, *str++); } -static int _serial_getc(struct udevice *dev) +static int __serial_getc(struct udevice *dev) { struct dm_serial_ops *ops = serial_get_ops(dev); int err; @@ -124,7 +207,7 @@ static int _serial_getc(struct udevice *dev) return err >= 0 ? err : 0; } -static int _serial_tstc(struct udevice *dev) +static int __serial_tstc(struct udevice *dev) { struct dm_serial_ops *ops = serial_get_ops(dev); @@ -134,59 +217,153 @@ static int _serial_tstc(struct udevice *dev) return 1; } +#if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) +static int _serial_tstc(struct udevice *dev) +{ + struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); + + /* Read all available chars into the RX buffer */ + while (__serial_tstc(dev)) { + upriv->buf[upriv->wr_ptr++] = __serial_getc(dev); + upriv->wr_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE; + } + + return upriv->rd_ptr != upriv->wr_ptr ? 1 : 0; +} + +static int _serial_getc(struct udevice *dev) +{ + struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); + char val; + + if (upriv->rd_ptr == upriv->wr_ptr) + return __serial_getc(dev); + + val = upriv->buf[upriv->rd_ptr++]; + upriv->rd_ptr %= CONFIG_SERIAL_RX_BUFFER_SIZE; + + return val; +} + +#else /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */ + +static int _serial_getc(struct udevice *dev) +{ + return __serial_getc(dev); +} + +static int _serial_tstc(struct udevice *dev) +{ + return __serial_tstc(dev); +} +#endif /* CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) */ + void serial_putc(char ch) { - _serial_putc(gd->cur_serial_dev, ch); + if (gd->cur_serial_dev) + _serial_putc(gd->cur_serial_dev, ch); } void serial_puts(const char *str) { - _serial_puts(gd->cur_serial_dev, str); + if (gd->cur_serial_dev) + _serial_puts(gd->cur_serial_dev, str); } int serial_getc(void) { + if (!gd->cur_serial_dev) + return 0; + return _serial_getc(gd->cur_serial_dev); } int serial_tstc(void) { + if (!gd->cur_serial_dev) + return 0; + return _serial_tstc(gd->cur_serial_dev); } void serial_setbrg(void) { - struct dm_serial_ops *ops = serial_get_ops(gd->cur_serial_dev); + struct dm_serial_ops *ops; + if (!gd->cur_serial_dev) + return; + + ops = serial_get_ops(gd->cur_serial_dev); if (ops->setbrg) ops->setbrg(gd->cur_serial_dev, gd->baudrate); } +int serial_getconfig(struct udevice *dev, uint *config) +{ + struct dm_serial_ops *ops; + + ops = serial_get_ops(dev); + if (ops->getconfig) + return ops->getconfig(dev, config); + + return 0; +} + +int serial_setconfig(struct udevice *dev, uint config) +{ + struct dm_serial_ops *ops; + + ops = serial_get_ops(dev); + if (ops->setconfig) + return ops->setconfig(dev, config); + + return 0; +} + +int serial_getinfo(struct udevice *dev, struct serial_device_info *info) +{ + struct dm_serial_ops *ops; + + if (!info) + return -EINVAL; + + info->baudrate = gd->baudrate; + + ops = serial_get_ops(dev); + if (ops->getinfo) + return ops->getinfo(dev, info); + + return -EINVAL; +} + void serial_stdio_init(void) { } -#ifdef CONFIG_DM_STDIO +#if defined(CONFIG_DM_STDIO) + +#if CONFIG_IS_ENABLED(SERIAL_PRESENT) static void serial_stub_putc(struct stdio_dev *sdev, const char ch) { _serial_putc(sdev->priv, ch); } #endif -void serial_stub_puts(struct stdio_dev *sdev, const char *str) +static void serial_stub_puts(struct stdio_dev *sdev, const char *str) { _serial_puts(sdev->priv, str); } -int serial_stub_getc(struct stdio_dev *sdev) +static int serial_stub_getc(struct stdio_dev *sdev) { return _serial_getc(sdev->priv); } -int serial_stub_tstc(struct stdio_dev *sdev) +static int serial_stub_tstc(struct stdio_dev *sdev) { return _serial_tstc(sdev->priv); } +#endif /** * on_baudrate() - Update the actual baudrate when the env var changes @@ -249,15 +426,38 @@ static int on_baudrate(const char *name, const char *value, enum env_op op, } U_BOOT_ENV_CALLBACK(baudrate, on_baudrate); +#if CONFIG_IS_ENABLED(SERIAL_PRESENT) static int serial_post_probe(struct udevice *dev) { struct dm_serial_ops *ops = serial_get_ops(dev); #ifdef CONFIG_DM_STDIO - struct serial_dev_priv *upriv = dev->uclass_priv; + struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); struct stdio_dev sdev; #endif int ret; +#if defined(CONFIG_NEEDS_MANUAL_RELOC) + if (ops->setbrg) + ops->setbrg += gd->reloc_off; + if (ops->getc) + ops->getc += gd->reloc_off; + if (ops->putc) + ops->putc += gd->reloc_off; + if (ops->pending) + ops->pending += gd->reloc_off; + if (ops->clear) + ops->clear += gd->reloc_off; + if (ops->getconfig) + ops->getconfig += gd->reloc_off; + if (ops->setconfig) + ops->setconfig += gd->reloc_off; +#if CONFIG_POST & CONFIG_SYS_POST_UART + if (ops->loop) + ops->loop += gd->reloc_off; +#endif + if (ops->getinfo) + ops->getinfo += gd->reloc_off; +#endif /* Set the baud rate */ if (ops->setbrg) { ret = ops->setbrg(dev, gd->baudrate); @@ -271,12 +471,18 @@ static int serial_post_probe(struct udevice *dev) memset(&sdev, '\0', sizeof(sdev)); strncpy(sdev.name, dev->name, sizeof(sdev.name)); - sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT; + sdev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_DM; sdev.priv = dev; sdev.putc = serial_stub_putc; sdev.puts = serial_stub_puts; sdev.getc = serial_stub_getc; sdev.tstc = serial_stub_tstc; + +#if CONFIG_IS_ENABLED(SERIAL_RX_BUFFER) + /* Allocate the RX buffer */ + upriv->buf = malloc(CONFIG_SERIAL_RX_BUFFER_SIZE); +#endif + stdio_register_dev(&sdev, &upriv->sdev); #endif return 0; @@ -284,10 +490,10 @@ static int serial_post_probe(struct udevice *dev) static int serial_pre_remove(struct udevice *dev) { -#ifdef CONFIG_SYS_STDIO_DEREGISTER - struct serial_dev_priv *upriv = dev->uclass_priv; +#if CONFIG_IS_ENABLED(SYS_STDIO_DEREGISTER) + struct serial_dev_priv *upriv = dev_get_uclass_priv(dev); - if (stdio_deregister_dev(upriv->sdev, 0)) + if (stdio_deregister_dev(upriv->sdev, true)) return -EPERM; #endif @@ -302,3 +508,4 @@ UCLASS_DRIVER(serial) = { .pre_remove = serial_pre_remove, .per_device_auto_alloc_size = sizeof(struct serial_dev_priv), }; +#endif