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_MEM32: 75 case UPIO_MEM32BE: 76 port->regshift = 2; /* fall-through */ 77 case UPIO_MEM: 78 port->mapbase = addr; 79 break; 80 case UPIO_PORT: 81 port->iobase = addr; 82 break; 83 default: 84 return -EINVAL; 85 } 86 87 if (options) { 88 device->baud = simple_strtoul(options, NULL, 0); 89 length = min(strcspn(options, " ") + 1, 90 (size_t)(sizeof(device->options))); 91 strlcpy(device->options, options, length); 92 } 93 94 if (port->iotype == UPIO_MEM || port->iotype == UPIO_MEM32 || 95 port->iotype == UPIO_MEM32BE) 96 pr_info("Early serial console at MMIO%s 0x%llx (options '%s')\n", 97 (port->iotype == UPIO_MEM) ? "" : 98 (port->iotype == UPIO_MEM32) ? "32" : "32be", 99 (unsigned long long)port->mapbase, 100 device->options); 101 else 102 pr_info("Early serial console at I/O port 0x%lx (options '%s')\n", 103 port->iobase, 104 device->options); 105 106 return 0; 107 } 108 109 static int __init register_earlycon(char *buf, const struct earlycon_id *match) 110 { 111 int err; 112 struct uart_port *port = &early_console_dev.port; 113 114 /* On parsing error, pass the options buf to the setup function */ 115 if (buf && !parse_options(&early_console_dev, buf)) 116 buf = NULL; 117 118 port->uartclk = BASE_BAUD * 16; 119 if (port->mapbase) 120 port->membase = earlycon_map(port->mapbase, 64); 121 122 early_console_dev.con->data = &early_console_dev; 123 err = match->setup(&early_console_dev, buf); 124 if (err < 0) 125 return err; 126 if (!early_console_dev.con->write) 127 return -ENODEV; 128 129 register_console(early_console_dev.con); 130 return 0; 131 } 132 133 /** 134 * setup_earlycon - match and register earlycon console 135 * @buf: earlycon param string 136 * 137 * Registers the earlycon console matching the earlycon specified 138 * in the param string @buf. Acceptable param strings are of the form 139 * <name>,io|mmio|mmio32|mmio32be,<addr>,<options> 140 * <name>,0x<addr>,<options> 141 * <name>,<options> 142 * <name> 143 * 144 * Only for the third form does the earlycon setup() method receive the 145 * <options> string in the 'options' parameter; all other forms set 146 * the parameter to NULL. 147 * 148 * Returns 0 if an attempt to register the earlycon was made, 149 * otherwise negative error code 150 */ 151 int __init setup_earlycon(char *buf) 152 { 153 const struct earlycon_id *match; 154 155 if (!buf || !buf[0]) 156 return -EINVAL; 157 158 if (early_con.flags & CON_ENABLED) 159 return -EALREADY; 160 161 for (match = __earlycon_table; match->name[0]; match++) { 162 size_t len = strlen(match->name); 163 164 if (strncmp(buf, match->name, len)) 165 continue; 166 167 if (buf[len]) { 168 if (buf[len] != ',') 169 continue; 170 buf += len + 1; 171 } else 172 buf = NULL; 173 174 return register_earlycon(buf, match); 175 } 176 177 return -ENOENT; 178 } 179 180 /* early_param wrapper for setup_earlycon() */ 181 static int __init param_setup_earlycon(char *buf) 182 { 183 int err; 184 185 /* 186 * Just 'earlycon' is a valid param for devicetree earlycons; 187 * don't generate a warning from parse_early_params() in that case 188 */ 189 if (!buf || !buf[0]) 190 return 0; 191 192 err = setup_earlycon(buf); 193 if (err == -ENOENT || err == -EALREADY) 194 return 0; 195 return err; 196 } 197 early_param("earlycon", param_setup_earlycon); 198 199 int __init of_setup_earlycon(unsigned long addr, 200 int (*setup)(struct earlycon_device *, const char *)) 201 { 202 int err; 203 struct uart_port *port = &early_console_dev.port; 204 205 port->iotype = UPIO_MEM; 206 port->mapbase = addr; 207 port->uartclk = BASE_BAUD * 16; 208 port->membase = earlycon_map(addr, SZ_4K); 209 210 early_console_dev.con->data = &early_console_dev; 211 err = setup(&early_console_dev, NULL); 212 if (err < 0) 213 return err; 214 if (!early_console_dev.con->write) 215 return -ENODEV; 216 217 218 register_console(early_console_dev.con); 219 return 0; 220 } 221