Documentation/devicetree/bindings/chosen.txt

stdout-path

Device trees may specify the device to be used for boot console output
with a stdout-path property under /chosen, as described in the Devicetree
Specification, e.g.

/ {     
        chosen {
                stdout-path = "/serial@f00:115200";
        };
        
        serial@f00 {
                compatible = "vendor,some-uart";
                reg = <0xf00 0x10>;
        };
};

If the character “:” is present in the value, this terminates the path.
The meaning of any characters following the “:” is device-specific, and
must be specified in the relevant binding documentation.

For UART devices, the preferred binding is a string in the form:

    <baud>{<parity>{<bits>{<flow>}}}

where

    baud    - baud rate in decimal
    parity  - 'n' (none), 'o', (odd) or 'e' (even)
    bits    - number of data bits
    flow    - 'r' (rts)

For example: 115200n8r

Implementation note: Linux will look for the property “linux,stdout-path” or
on PowerPC “stdout” if “stdout-path” is not found. However, the
“linux,stdout-path” and “stdout” properties are deprecated. New platforms
should only use the “stdout-path” property.

Documentation/devicetree/booting-without-of.txt

e) The /chosen node

This node is a bit “special”. Normally, that’s where Open Firmware
puts some variable environment information, like the arguments, or
the default input/output devices.

This specification makes a few of these mandatory, but also defines
some linux-specific properties that would be normally constructed by
the prom_init() trampoline when booting with an OF client interface,
but that you have to provide yourself when using the flattened format.

Recommended properties:

- bootargs : This zero-terminated string is passed as the kernel
  command line
- linux,stdout-path : This is the full path to your standard
  console device if any. Typically, if you have serial devices on
  your board, you may want to put the full path to the one set as
  the default console in the firmware here, for the kernel to pick
  it up as its own default console.

Note that u-boot creates and fills in the chosen node for platforms
that use it.

(Note: a practice that is now obsolete was to include a property
under /chosen called interrupt-controller which had a phandle value
that pointed to the main interrupt controller)

drivers/of/base.c

/**
 * of_alias_scan - Scan all properties of the 'aliases' node
 *
 * The function scans all the properties of the 'aliases' node and populates
 * the global lookup table with the properties.  It returns the
 * number of alias properties found, or an error code in case of failure.
 *
 * @dt_alloc:   An allocator that provides a virtual address to memory
 *              for storing the resulting tree
 */
void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
{
        struct property *pp;

        of_aliases = of_find_node_by_path("/aliases");
        of_chosen = of_find_node_by_path("/chosen");
        if (of_chosen == NULL)
                of_chosen = of_find_node_by_path("/chosen@0");

        if (of_chosen) {
                /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
                const char *name = NULL;

                if (of_property_read_string(of_chosen, "stdout-path", &name))
                        of_property_read_string(of_chosen, "linux,stdout-path",
                                                &name);
                if (IS_ENABLED(CONFIG_PPC) && !name)
                        of_property_read_string(of_aliases, "stdout", &name);
                if (name)
                        of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
        }

        if (!of_aliases)
                return;

        for_each_property_of_node(of_aliases, pp) {
                const char *start = pp->name;
                const char *end = start + strlen(start);
                struct device_node *np;
                struct alias_prop *ap;
                int id, len;

                /* Skip those we do not want to proceed */
                if (!strcmp(pp->name, "name") ||
                    !strcmp(pp->name, "phandle") ||
                    !strcmp(pp->name, "linux,phandle"))
                        continue;

                np = of_find_node_by_path(pp->value);
                if (!np)
                        continue;

                /* walk the alias backwards to extract the id and work out
                 * the 'stem' string */
                while (isdigit(*(end-1)) && end > start)
                        end--;
                len = end - start;

                if (kstrtoint(end, 10, &id) < 0)
                        continue;

                /* Allocate an alias_prop with enough space for the stem */
                ap = dt_alloc(sizeof(*ap) + len + 1, __alignof__(*ap));
                if (!ap)
                        continue;
                memset(ap, 0, sizeof(*ap) + len + 1);
                ap->alias = start;
                of_alias_add(ap, np, id, start, len);
        }
}