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 */ 13 14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 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> 21 #include <linux/sizes.h> 22 #include <linux/mod_devicetable.h> 23 24 #ifdef CONFIG_FIX_EARLYCON_MEM 25 #include <asm/fixmap.h> 26 #endif 27 28 #include <asm/serial.h> 29 30 static struct console early_con = { 31 .name = "uart", /* 8250 console switch requires this name */ 32 .flags = CON_PRINTBUFFER | CON_BOOT, 33 .index = -1, 34 }; 35 36 static struct earlycon_device early_console_dev = { 37 .con = &early_con, 38 }; 39 40 extern struct earlycon_id __earlycon_table[]; 41 static const struct earlycon_id __earlycon_table_sentinel 42 __used __section(__earlycon_table_end); 43 44 static const struct of_device_id __earlycon_of_table_sentinel 45 __used __section(__earlycon_of_table_end); 46 47 static void __iomem * __init earlycon_map(unsigned long paddr, size_t size) 48 { 49 void __iomem *base; 50 #ifdef CONFIG_FIX_EARLYCON_MEM 51 set_fixmap_io(FIX_EARLYCON_MEM_BASE, paddr & PAGE_MASK); 52 base = (void __iomem *)__fix_to_virt(FIX_EARLYCON_MEM_BASE); 53 base += paddr & ~PAGE_MASK; 54 #else 55 base = ioremap(paddr, size); 56 #endif 57 if (!base) 58 pr_err("%s: Couldn't map 0x%llx\n", __func__, 59 (unsigned long long)paddr); 60 61 return base; 62 } 63 64 static int __init parse_options(struct earlycon_device *device, char *options) 65 { 66 struct uart_port *port = &device->port; 67 int length; 68 unsigned long addr; 69 70 if (uart_parse_earlycon(options, &port->iotype, &addr, &options)) 71 return -EINVAL; 72 73 switch (port->iotype) { 74 case UPIO_MEM: 75 port->mapbase = addr; 76 break; 77 case UPIO_MEM16: 78 port->regshift = 1; 79 port->mapbase = addr; 80 break; 81 case UPIO_MEM32: 82 case UPIO_MEM32BE: 83 port->regshift = 2; 84 port->mapbase = addr; 85 break; 86 case UPIO_PORT: 87 port->iobase = addr; 88 break; 89 default: 90 return -EINVAL; 91 } 92 93 if (options) { 94 device->baud = simple_strtoul(options, NULL, 0); 95 length = min(strcspn(options, " ") + 1, 96 (size_t)(sizeof(device->options))); 97 strlcpy(device->options, options, length); 98 } 99 100 if (port->iotype == UPIO_MEM || port->iotype == UPIO_MEM16 || 101 port->iotype == UPIO_MEM32 || port->iotype == UPIO_MEM32BE) 102 pr_info("Early serial console at MMIO%s 0x%llx (options '%s')\n", 103 (port->iotype == UPIO_MEM) ? "" : 104 (port->iotype == UPIO_MEM16) ? "16" : 105 (port->iotype == UPIO_MEM32) ? "32" : "32be", 106 (unsigned long long)port->mapbase, 107 device->options); 108 else 109 pr_info("Early serial console at I/O port 0x%lx (options '%s')\n", 110 port->iobase, 111 device->options); 112 113 return 0; 114 } 115 116 static int __init register_earlycon(char *buf, const struct earlycon_id *match) 117 { 118 int err; 119 struct uart_port *port = &early_console_dev.port; 120 121 /* On parsing error, pass the options buf to the setup function */ 122 if (buf && !parse_options(&early_console_dev, buf)) 123 buf = NULL; 124 125 spin_lock_init(&port->lock); 126 port->uartclk = BASE_BAUD * 16; 127 if (port->mapbase) 128 port->membase = earlycon_map(port->mapbase, 64); 129 130 early_console_dev.con->data = &early_console_dev; 131 err = match->setup(&early_console_dev, buf); 132 if (err < 0) 133 return err; 134 if (!early_console_dev.con->write) 135 return -ENODEV; 136 137 register_console(early_console_dev.con); 138 return 0; 139 } 140 141 /** 142 * setup_earlycon - match and register earlycon console 143 * @buf: earlycon param string 144 * 145 * Registers the earlycon console matching the earlycon specified 146 * in the param string @buf. Acceptable param strings are of the form 147 * <name>,io|mmio|mmio32|mmio32be,<addr>,<options> 148 * <name>,0x<addr>,<options> 149 * <name>,<options> 150 * <name> 151 * 152 * Only for the third form does the earlycon setup() method receive the 153 * <options> string in the 'options' parameter; all other forms set 154 * the parameter to NULL. 155 * 156 * Returns 0 if an attempt to register the earlycon was made, 157 * otherwise negative error code 158 */ 159 int __init setup_earlycon(char *buf) 160 { 161 const struct earlycon_id *match; 162 163 if (!buf || !buf[0]) 164 return -EINVAL; 165 166 if (early_con.flags & CON_ENABLED) 167 return -EALREADY; 168 169 for (match = __earlycon_table; match->name[0]; match++) { 170 size_t len = strlen(match->name); 171 172 if (strncmp(buf, match->name, len)) 173 continue; 174 175 if (buf[len]) { 176 if (buf[len] != ',') 177 continue; 178 buf += len + 1; 179 } else 180 buf = NULL; 181 182 return register_earlycon(buf, match); 183 } 184 185 return -ENOENT; 186 } 187 188 /* early_param wrapper for setup_earlycon() */ 189 static int __init param_setup_earlycon(char *buf) 190 { 191 int err; 192 193 /* 194 * Just 'earlycon' is a valid param for devicetree earlycons; 195 * don't generate a warning from parse_early_params() in that case 196 */ 197 if (!buf || !buf[0]) 198 return 0; 199 200 err = setup_earlycon(buf); 201 if (err == -ENOENT || err == -EALREADY) 202 return 0; 203 return err; 204 } 205 early_param("earlycon", param_setup_earlycon); 206 207 int __init of_setup_earlycon(unsigned long addr, 208 int (*setup)(struct earlycon_device *, const char *)) 209 { 210 int err; 211 struct uart_port *port = &early_console_dev.port; 212 213 spin_lock_init(&port->lock); 214 port->iotype = UPIO_MEM; 215 port->mapbase = addr; 216 port->uartclk = BASE_BAUD * 16; 217 port->membase = earlycon_map(addr, SZ_4K); 218 219 early_console_dev.con->data = &early_console_dev; 220 err = setup(&early_console_dev, NULL); 221 if (err < 0) 222 return err; 223 if (!early_console_dev.con->write) 224 return -ENODEV; 225 226 227 register_console(early_console_dev.con); 228 return 0; 229 } 230