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