// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2014 Linaro Ltd. * Author: Rob Herring <robh@kernel.org> * * Based on 8250 earlycon: * (c) Copyright 2004 Hewlett-Packard Development Company, L.P. *	Bjorn Helgaas <bjorn.helgaas@hp.com> */ #define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt #include <linux/console.h>#include <linux/kernel.h>#include <linux/init.h>#include <linux/io.h>#include <linux/serial_core.h>#include <linux/sizes.h>#include <linux/of.h>#include <linux/of_fdt.h>#include <linux/acpi.h> #ifdef CONFIG_FIX_EARLYCON_MEM#include <asm/fixmap.h>#endif #include <asm/serial.h> static struct console early_con = {	.name =		"uart",		/* fixed up at earlycon registration */	.flags =	CON_PRINTBUFFER | CON_BOOT,	.index =	0,}; static struct earlycon_device early_console_dev = {	.con = &early_con,}; static void __iomem * __init earlycon_map(resource_size_t paddr, size_t size){	void __iomem *base;#ifdef CONFIG_FIX_EARLYCON_MEM	set_fixmap_io(FIX_EARLYCON_MEM_BASE, paddr & PAGE_MASK);	base = (void __iomem *)__fix_to_virt(FIX_EARLYCON_MEM_BASE);	base += paddr & ~PAGE_MASK;#else	base = ioremap(paddr, size);#endif	if (!base)		pr_err("%s: Couldn't map %pa\n", __func__, &paddr); 	return base;} static void __init earlycon_init(struct earlycon_device *device,				 const char *name){	struct console *earlycon = device->con;	const char *s;	size_t len; 	/* scan backwards from end of string for first non-numeral */	for (s = name + strlen(name);	     s > name && s[-1] >= '0' && s[-1] <= '9';	     s--)		;	if (*s)		earlycon->index = simple_strtoul(s, NULL, 10);	len = s - name;	strscpy(earlycon->name, name, min(len + 1, sizeof(earlycon->name)));	earlycon->data = &early_console_dev;} static void __init earlycon_print_info(struct earlycon_device *device){	struct console *earlycon = device->con;	struct uart_port *port = &device->port;	char ioinfos[64]; 	uart_get_ioinfos(port, ioinfos, sizeof(ioinfos)); 	pr_info("%s%d%s (options '%s')\n", earlycon->name, earlycon->index,		ioinfos, device->options);} static int __init parse_options(struct earlycon_device *device, char *options){	struct uart_port *port = &device->port;	int length;	resource_size_t addr; 	if (uart_parse_earlycon(options, &port->iotype, &addr, &options))		return -EINVAL; 	switch (port->iotype) {	case UPIO_MEM:		port->mapbase = addr;		break;	case UPIO_MEM16:		port->regshift = 1;		port->mapbase = addr;		break;	case UPIO_MEM32:	case UPIO_MEM32BE:		port->regshift = 2;		port->mapbase = addr;		break;	case UPIO_PORT:		port->iobase = addr;		break;	default:		return -EINVAL;	} 	if (options) {		char *uartclk; 		device->baud = simple_strtoul(options, NULL, 0);		uartclk = strchr(options, ',');		if (uartclk && kstrtouint(uartclk + 1, 0, &port->uartclk) < 0)			pr_warn("[%s] unsupported earlycon uart clkrate option\n",				options);		length = min(strcspn(options, " ") + 1,			     (size_t)(sizeof(device->options)));		strscpy(device->options, options, length);	} 	return 0;} static int __init register_earlycon(char *buf, const struct earlycon_id *match){	int err;	struct uart_port *port = &early_console_dev.port; 	/* On parsing error, pass the options buf to the setup function */	if (buf && !parse_options(&early_console_dev, buf))		buf = NULL; 	spin_lock_init(&port->lock);	if (!port->uartclk)		port->uartclk = BASE_BAUD * 16;	if (port->mapbase)		port->membase = earlycon_map(port->mapbase, 64); 	earlycon_init(&early_console_dev, match->name);	err = match->setup(&early_console_dev, buf);	earlycon_print_info(&early_console_dev);	if (err < 0)		return err;	if (!early_console_dev.con->write)		return -ENODEV; 	register_console(early_console_dev.con);	return 0;} /** *	setup_earlycon - match and register earlycon console *	@buf:	earlycon param string * *	Registers the earlycon console matching the earlycon specified *	in the param string @buf. Acceptable param strings are of the form *	   <name>,io|mmio|mmio32|mmio32be,<addr>,<options> *	   <name>,0x<addr>,<options> *	   <name>,<options> *	   <name> * *	Only for the third form does the earlycon setup() method receive the *	<options> string in the 'options' parameter; all other forms set *	the parameter to NULL. * *	Returns 0 if an attempt to register the earlycon was made, *	otherwise negative error code */int __init setup_earlycon(char *buf){	const struct earlycon_id *match;	bool empty_compatible = true; 	if (!buf || !buf[0])		return -EINVAL; 	if (console_is_registered(&early_con))		return -EALREADY; again:	for (match = __earlycon_table; match < __earlycon_table_end; match++) {		size_t len = strlen(match->name); 		if (strncmp(buf, match->name, len))			continue; 		/* prefer entries with empty compatible */		if (empty_compatible && *match->compatible)			continue; 		if (buf[len]) {			if (buf[len] != ',')				continue;			buf += len + 1;		} else			buf = NULL; 		return register_earlycon(buf, match);	} 	if (empty_compatible) {		empty_compatible = false;		goto again;	} 	return -ENOENT;} /* * This defers the initialization of the early console until after ACPI has * been initialized. */bool earlycon_acpi_spcr_enable __initdata; /* early_param wrapper for setup_earlycon() */static int __init param_setup_earlycon(char *buf){	int err; 	/* Just 'earlycon' is a valid param for devicetree and ACPI SPCR. */	if (!buf || !buf[0]) {		if (IS_ENABLED(CONFIG_ACPI_SPCR_TABLE)) {			earlycon_acpi_spcr_enable = true;			return 0;		} else if (!buf) {			return early_init_dt_scan_chosen_stdout();		}	} 	err = setup_earlycon(buf);	if (err == -ENOENT || err == -EALREADY)		return 0;	return err;}early_param("earlycon", param_setup_earlycon); /* * The `console` parameter is overloaded. It's handled here as an early param * and in `printk.c` as a late param. It's possible to specify an early * `bootconsole` using `earlycon=uartXXXX` (handled above), or via * the `console=uartXXX` alias. See the comment in `8250_early.c`. */static int __init param_setup_earlycon_console_alias(char *buf){	/*	 * A plain `console` parameter must not enable the SPCR `bootconsole`	 * like a plain `earlycon` does.	 *	 * A `console=` parameter that specifies an empty value is used to	 * disable the `console`, not the `earlycon` `bootconsole`. The	 * disabling of the `console` is handled by `printk.c`.	 */	if (!buf || !buf[0])		return 0; 	return param_setup_earlycon(buf);}early_param("console", param_setup_earlycon_console_alias); #ifdef CONFIG_OF_EARLY_FLATTREE int __init of_setup_earlycon(const struct earlycon_id *match,			     unsigned long node,			     const char *options){	int err;	struct uart_port *port = &early_console_dev.port;	const __be32 *val;	bool big_endian;	u64 addr; 	if (console_is_registered(&early_con))		return -EALREADY; 	spin_lock_init(&port->lock);	port->iotype = UPIO_MEM;	addr = of_flat_dt_translate_address(node);	if (addr == OF_BAD_ADDR) {		pr_warn("[%s] bad address\n", match->name);		return -ENXIO;	}	port->mapbase = addr; 	val = of_get_flat_dt_prop(node, "reg-offset", NULL);	if (val)		port->mapbase += be32_to_cpu(*val);	port->membase = earlycon_map(port->mapbase, SZ_4K); 	val = of_get_flat_dt_prop(node, "reg-shift", NULL);	if (val)		port->regshift = be32_to_cpu(*val);	big_endian = of_get_flat_dt_prop(node, "big-endian", NULL) != NULL ||		(IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&		 of_get_flat_dt_prop(node, "native-endian", NULL) != NULL);	val = of_get_flat_dt_prop(node, "reg-io-width", NULL);	if (val) {		switch (be32_to_cpu(*val)) {		case 1:			port->iotype = UPIO_MEM;			break;		case 2:			port->iotype = UPIO_MEM16;			break;		case 4:			port->iotype = (big_endian) ? UPIO_MEM32BE : UPIO_MEM32;			break;		default:			pr_warn("[%s] unsupported reg-io-width\n", match->name);			return -EINVAL;		}	} 	val = of_get_flat_dt_prop(node, "current-speed", NULL);	if (val)		early_console_dev.baud = be32_to_cpu(*val); 	val = of_get_flat_dt_prop(node, "clock-frequency", NULL);	if (val)		port->uartclk = be32_to_cpu(*val); 	if (options) {		early_console_dev.baud = simple_strtoul(options, NULL, 0);		strscpy(early_console_dev.options, options,			sizeof(early_console_dev.options));	}	earlycon_init(&early_console_dev, match->name);	err = match->setup(&early_console_dev, options);	earlycon_print_info(&early_console_dev);	if (err < 0)		return err;	if (!early_console_dev.con->write)		return -ENODEV;  	register_console(early_console_dev.con);	return 0;} #endif /* CONFIG_OF_EARLY_FLATTREE */