1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2014 Linaro Ltd. 4 * Author: Rob Herring <robh@kernel.org> 5 * 6 * Based on 8250 earlycon: 7 * (c) Copyright 2004 Hewlett-Packard Development Company, L.P. 8 * Bjorn Helgaas <bjorn.helgaas@hp.com> 9 */ 10 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #include <linux/console.h> 14 #include <linux/kernel.h> 15 #include <linux/init.h> 16 #include <linux/io.h> 17 #include <linux/serial_core.h> 18 #include <linux/sizes.h> 19 #include <linux/of.h> 20 #include <linux/of_fdt.h> 21 #include <linux/acpi.h> 22 23 #ifdef CONFIG_FIX_EARLYCON_MEM 24 #include <asm/fixmap.h> 25 #endif 26 27 #include <asm/serial.h> 28 29 static struct console early_con = { 30 .name = "uart", /* fixed up at earlycon registration */ 31 .flags = CON_PRINTBUFFER | CON_BOOT, 32 .index = 0, 33 }; 34 35 static struct earlycon_device early_console_dev = { 36 .con = &early_con, 37 }; 38 39 static void __iomem * __init earlycon_map(resource_size_t paddr, size_t size) 40 { 41 void __iomem *base; 42 #ifdef CONFIG_FIX_EARLYCON_MEM 43 set_fixmap_io(FIX_EARLYCON_MEM_BASE, paddr & PAGE_MASK); 44 base = (void __iomem *)__fix_to_virt(FIX_EARLYCON_MEM_BASE); 45 base += paddr & ~PAGE_MASK; 46 #else 47 base = ioremap(paddr, size); 48 #endif 49 if (!base) 50 pr_err("%s: Couldn't map %pa\n", __func__, &paddr); 51 52 return base; 53 } 54 55 static void __init earlycon_init(struct earlycon_device *device, 56 const char *name) 57 { 58 struct console *earlycon = device->con; 59 struct uart_port *port = &device->port; 60 const char *s; 61 size_t len; 62 63 /* scan backwards from end of string for first non-numeral */ 64 for (s = name + strlen(name); 65 s > name && s[-1] >= '0' && s[-1] <= '9'; 66 s--) 67 ; 68 if (*s) 69 earlycon->index = simple_strtoul(s, NULL, 10); 70 len = s - name; 71 strlcpy(earlycon->name, name, min(len + 1, sizeof(earlycon->name))); 72 earlycon->data = &early_console_dev; 73 74 if (port->iotype == UPIO_MEM || port->iotype == UPIO_MEM16 || 75 port->iotype == UPIO_MEM32 || port->iotype == UPIO_MEM32BE) 76 pr_info("%s%d at MMIO%s %pa (options '%s')\n", 77 earlycon->name, earlycon->index, 78 (port->iotype == UPIO_MEM) ? "" : 79 (port->iotype == UPIO_MEM16) ? "16" : 80 (port->iotype == UPIO_MEM32) ? "32" : "32be", 81 &port->mapbase, device->options); 82 else 83 pr_info("%s%d at I/O port 0x%lx (options '%s')\n", 84 earlycon->name, earlycon->index, 85 port->iobase, device->options); 86 } 87 88 static int __init parse_options(struct earlycon_device *device, char *options) 89 { 90 struct uart_port *port = &device->port; 91 int length; 92 resource_size_t addr; 93 94 if (uart_parse_earlycon(options, &port->iotype, &addr, &options)) 95 return -EINVAL; 96 97 switch (port->iotype) { 98 case UPIO_MEM: 99 port->mapbase = addr; 100 break; 101 case UPIO_MEM16: 102 port->regshift = 1; 103 port->mapbase = addr; 104 break; 105 case UPIO_MEM32: 106 case UPIO_MEM32BE: 107 port->regshift = 2; 108 port->mapbase = addr; 109 break; 110 case UPIO_PORT: 111 port->iobase = addr; 112 break; 113 default: 114 return -EINVAL; 115 } 116 117 if (options) { 118 device->baud = simple_strtoul(options, NULL, 0); 119 length = min(strcspn(options, " ") + 1, 120 (size_t)(sizeof(device->options))); 121 strlcpy(device->options, options, length); 122 } 123 124 return 0; 125 } 126 127 static int __init register_earlycon(char *buf, const struct earlycon_id *match) 128 { 129 int err; 130 struct uart_port *port = &early_console_dev.port; 131 132 /* On parsing error, pass the options buf to the setup function */ 133 if (buf && !parse_options(&early_console_dev, buf)) 134 buf = NULL; 135 136 spin_lock_init(&port->lock); 137 port->uartclk = BASE_BAUD * 16; 138 if (port->mapbase) 139 port->membase = earlycon_map(port->mapbase, 64); 140 141 earlycon_init(&early_console_dev, match->name); 142 err = match->setup(&early_console_dev, buf); 143 if (err < 0) 144 return err; 145 if (!early_console_dev.con->write) 146 return -ENODEV; 147 148 register_console(early_console_dev.con); 149 return 0; 150 } 151 152 /** 153 * setup_earlycon - match and register earlycon console 154 * @buf: earlycon param string 155 * 156 * Registers the earlycon console matching the earlycon specified 157 * in the param string @buf. Acceptable param strings are of the form 158 * <name>,io|mmio|mmio32|mmio32be,<addr>,<options> 159 * <name>,0x<addr>,<options> 160 * <name>,<options> 161 * <name> 162 * 163 * Only for the third form does the earlycon setup() method receive the 164 * <options> string in the 'options' parameter; all other forms set 165 * the parameter to NULL. 166 * 167 * Returns 0 if an attempt to register the earlycon was made, 168 * otherwise negative error code 169 */ 170 int __init setup_earlycon(char *buf) 171 { 172 const struct earlycon_id *match; 173 174 if (!buf || !buf[0]) 175 return -EINVAL; 176 177 if (early_con.flags & CON_ENABLED) 178 return -EALREADY; 179 180 for (match = __earlycon_table; match < __earlycon_table_end; match++) { 181 size_t len = strlen(match->name); 182 183 if (strncmp(buf, match->name, len)) 184 continue; 185 186 if (buf[len]) { 187 if (buf[len] != ',') 188 continue; 189 buf += len + 1; 190 } else 191 buf = NULL; 192 193 return register_earlycon(buf, match); 194 } 195 196 return -ENOENT; 197 } 198 199 /* 200 * When CONFIG_ACPI_SPCR_TABLE is defined, "earlycon" without parameters in 201 * command line does not start DT earlycon immediately, instead it defers 202 * starting it until DT/ACPI decision is made. At that time if ACPI is enabled 203 * call parse_spcr(), else call early_init_dt_scan_chosen_stdout() 204 */ 205 bool earlycon_init_is_deferred __initdata; 206 207 /* early_param wrapper for setup_earlycon() */ 208 static int __init param_setup_earlycon(char *buf) 209 { 210 int err; 211 212 /* 213 * Just 'earlycon' is a valid param for devicetree earlycons; 214 * don't generate a warning from parse_early_params() in that case 215 */ 216 if (!buf || !buf[0]) { 217 if (IS_ENABLED(CONFIG_ACPI_SPCR_TABLE)) { 218 earlycon_init_is_deferred = true; 219 return 0; 220 } else if (!buf) { 221 return early_init_dt_scan_chosen_stdout(); 222 } 223 } 224 225 err = setup_earlycon(buf); 226 if (err == -ENOENT || err == -EALREADY) 227 return 0; 228 return err; 229 } 230 early_param("earlycon", param_setup_earlycon); 231 232 #ifdef CONFIG_OF_EARLY_FLATTREE 233 234 int __init of_setup_earlycon(const struct earlycon_id *match, 235 unsigned long node, 236 const char *options) 237 { 238 int err; 239 struct uart_port *port = &early_console_dev.port; 240 const __be32 *val; 241 bool big_endian; 242 u64 addr; 243 244 spin_lock_init(&port->lock); 245 port->iotype = UPIO_MEM; 246 addr = of_flat_dt_translate_address(node); 247 if (addr == OF_BAD_ADDR) { 248 pr_warn("[%s] bad address\n", match->name); 249 return -ENXIO; 250 } 251 port->mapbase = addr; 252 port->uartclk = BASE_BAUD * 16; 253 port->membase = earlycon_map(port->mapbase, SZ_4K); 254 255 val = of_get_flat_dt_prop(node, "reg-offset", NULL); 256 if (val) 257 port->mapbase += be32_to_cpu(*val); 258 val = of_get_flat_dt_prop(node, "reg-shift", NULL); 259 if (val) 260 port->regshift = be32_to_cpu(*val); 261 big_endian = of_get_flat_dt_prop(node, "big-endian", NULL) != NULL || 262 (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) && 263 of_get_flat_dt_prop(node, "native-endian", NULL) != NULL); 264 val = of_get_flat_dt_prop(node, "reg-io-width", NULL); 265 if (val) { 266 switch (be32_to_cpu(*val)) { 267 case 1: 268 port->iotype = UPIO_MEM; 269 break; 270 case 2: 271 port->iotype = UPIO_MEM16; 272 break; 273 case 4: 274 port->iotype = (big_endian) ? UPIO_MEM32BE : UPIO_MEM32; 275 break; 276 default: 277 pr_warn("[%s] unsupported reg-io-width\n", match->name); 278 return -EINVAL; 279 } 280 } 281 282 val = of_get_flat_dt_prop(node, "current-speed", NULL); 283 if (val) 284 early_console_dev.baud = be32_to_cpu(*val); 285 286 if (options) { 287 early_console_dev.baud = simple_strtoul(options, NULL, 0); 288 strlcpy(early_console_dev.options, options, 289 sizeof(early_console_dev.options)); 290 } 291 earlycon_init(&early_console_dev, match->name); 292 err = match->setup(&early_console_dev, options); 293 if (err < 0) 294 return err; 295 if (!early_console_dev.con->write) 296 return -ENODEV; 297 298 299 register_console(early_console_dev.con); 300 return 0; 301 } 302 303 #endif /* CONFIG_OF_EARLY_FLATTREE */ 304