drivers/tty/serial/earlycon.c

   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 }