arch/x86/platform/mrst/early_printk_mrst.c

   1 /*
   2  * early_printk_mrst.c - early consoles for Intel MID platforms
   3  *
   4  * Copyright (c) 2008-2010, Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; version 2
   9  * of the License.
  10  */
  11
  12 /*
  13  * This file implements two early consoles named mrst and hsu.
  14  * mrst is based on Maxim3110 spi-uart device, it exists in both
  15  * Moorestown and Medfield platforms, while hsu is based on a High
  16  * Speed UART device which only exists in the Medfield platform
  17  */
  18
  19 #include <linux/serial_reg.h>
  20 #include <linux/serial_mfd.h>
  21 #include <linux/kmsg_dump.h>
  22 #include <linux/console.h>
  23 #include <linux/kernel.h>
  24 #include <linux/delay.h>
  25 #include <linux/init.h>
  26 #include <linux/io.h>
  27
  28 #include <asm/fixmap.h>
  29 #include <asm/pgtable.h>
  30 #include <asm/mrst.h>
  31
  32 #define MRST_SPI_TIMEOUT                0x200000
  33 #define MRST_REGBASE_SPI0               0xff128000
  34 #define MRST_REGBASE_SPI1               0xff128400
  35 #define MRST_CLK_SPI0_REG               0xff11d86c
  36
  37 /* Bit fields in CTRLR0 */
  38 #define SPI_DFS_OFFSET                  0
  39
  40 #define SPI_FRF_OFFSET                  4
  41 #define SPI_FRF_SPI                     0x0
  42 #define SPI_FRF_SSP                     0x1
  43 #define SPI_FRF_MICROWIRE               0x2
  44 #define SPI_FRF_RESV                    0x3
  45
  46 #define SPI_MODE_OFFSET                 6
  47 #define SPI_SCPH_OFFSET                 6
  48 #define SPI_SCOL_OFFSET                 7
  49 #define SPI_TMOD_OFFSET                 8
  50 #define SPI_TMOD_TR                     0x0             /* xmit & recv */
  51 #define SPI_TMOD_TO                     0x1             /* xmit only */
  52 #define SPI_TMOD_RO                     0x2             /* recv only */
  53 #define SPI_TMOD_EPROMREAD              0x3             /* eeprom read mode */
  54
  55 #define SPI_SLVOE_OFFSET                10
  56 #define SPI_SRL_OFFSET                  11
  57 #define SPI_CFS_OFFSET                  12
  58
  59 /* Bit fields in SR, 7 bits */
  60 #define SR_MASK                         0x7f            /* cover 7 bits */
  61 #define SR_BUSY                         (1 << 0)
  62 #define SR_TF_NOT_FULL                  (1 << 1)
  63 #define SR_TF_EMPT                      (1 << 2)
  64 #define SR_RF_NOT_EMPT                  (1 << 3)
  65 #define SR_RF_FULL                      (1 << 4)
  66 #define SR_TX_ERR                       (1 << 5)
  67 #define SR_DCOL                         (1 << 6)
  68
  69 struct dw_spi_reg {
  70         u32     ctrl0;
  71         u32     ctrl1;
  72         u32     ssienr;
  73         u32     mwcr;
  74         u32     ser;
  75         u32     baudr;
  76         u32     txfltr;
  77         u32     rxfltr;
  78         u32     txflr;
  79         u32     rxflr;
  80         u32     sr;
  81         u32     imr;
  82         u32     isr;
  83         u32     risr;
  84         u32     txoicr;
  85         u32     rxoicr;
  86         u32     rxuicr;
  87         u32     msticr;
  88         u32     icr;
  89         u32     dmacr;
  90         u32     dmatdlr;
  91         u32     dmardlr;
  92         u32     idr;
  93         u32     version;
  94
  95         /* Currently operates as 32 bits, though only the low 16 bits matter */
  96         u32     dr;
  97 } __packed;
  98
  99 #define dw_readl(dw, name)              __raw_readl(&(dw)->name)
 100 #define dw_writel(dw, name, val)        __raw_writel((val), &(dw)->name)
 101
 102 /* Default use SPI0 register for mrst, we will detect Penwell and use SPI1 */
 103 static unsigned long mrst_spi_paddr = MRST_REGBASE_SPI0;
 104
 105 static u32 *pclk_spi0;
 106 /* Always contains an accessible address, start with 0 */
 107 static struct dw_spi_reg *pspi;
 108
 109 static struct kmsg_dumper dw_dumper;
 110 static int dumper_registered;
 111
 112 static void dw_kmsg_dump(struct kmsg_dumper *dumper,
 113                          enum kmsg_dump_reason reason)
 114 {
 115         static char line[1024];
 116         size_t len;
 117
 118         /* When run to this, we'd better re-init the HW */
 119         mrst_early_console_init();
 120
 121         while (kmsg_dump_get_line(dumper, true, line, sizeof(line), &len))
 122                 early_mrst_console.write(&early_mrst_console, line, len);
 123 }
 124
 125 /* Set the ratio rate to 115200, 8n1, IRQ disabled */
 126 static void max3110_write_config(void)
 127 {
 128         u16 config;
 129
 130         config = 0xc001;
 131         dw_writel(pspi, dr, config);
 132 }
 133
 134 /* Translate char to a eligible word and send to max3110 */
 135 static void max3110_write_data(char c)
 136 {
 137         u16 data;
 138
 139         data = 0x8000 | c;
 140         dw_writel(pspi, dr, data);
 141 }
 142
 143 void mrst_early_console_init(void)
 144 {
 145         u32 ctrlr0 = 0;
 146         u32 spi0_cdiv;
 147         u32 freq; /* Freqency info only need be searched once */
 148
 149         /* Base clk is 100 MHz, the actual clk = 100M / (clk_divider + 1) */
 150         pclk_spi0 = (void *)set_fixmap_offset_nocache(FIX_EARLYCON_MEM_BASE,
 151                                                         MRST_CLK_SPI0_REG);
 152         spi0_cdiv = ((*pclk_spi0) & 0xe00) >> 9;
 153         freq = 100000000 / (spi0_cdiv + 1);
 154
 155         if (mrst_identify_cpu() == MRST_CPU_CHIP_PENWELL)
 156                 mrst_spi_paddr = MRST_REGBASE_SPI1;
 157
 158         pspi = (void *)set_fixmap_offset_nocache(FIX_EARLYCON_MEM_BASE,
 159                                                 mrst_spi_paddr);
 160
 161         /* Disable SPI controller */
 162         dw_writel(pspi, ssienr, 0);
 163
 164         /* Set control param, 8 bits, transmit only mode */
 165         ctrlr0 = dw_readl(pspi, ctrl0);
 166
 167         ctrlr0 &= 0xfcc0;
 168         ctrlr0 |= 0xf | (SPI_FRF_SPI << SPI_FRF_OFFSET)
 169                       | (SPI_TMOD_TO << SPI_TMOD_OFFSET);
 170         dw_writel(pspi, ctrl0, ctrlr0);
 171
 172         /*
 173          * Change the spi0 clk to comply with 115200 bps, use 100000 to
 174          * calculate the clk dividor to make the clock a little slower
 175          * than real baud rate.
 176          */
 177         dw_writel(pspi, baudr, freq/100000);
 178
 179         /* Disable all INT for early phase */
 180         dw_writel(pspi, imr, 0x0);
 181
 182         /* Set the cs to spi-uart */
 183         dw_writel(pspi, ser, 0x2);
 184
 185         /* Enable the HW, the last step for HW init */
 186         dw_writel(pspi, ssienr, 0x1);
 187
 188         /* Set the default configuration */
 189         max3110_write_config();
 190
 191         /* Register the kmsg dumper */
 192         if (!dumper_registered) {
 193                 dw_dumper.dump = dw_kmsg_dump;
 194                 kmsg_dump_register(&dw_dumper);
 195                 dumper_registered = 1;
 196         }
 197 }
 198
 199 /* Slave select should be called in the read/write function */
 200 static void early_mrst_spi_putc(char c)
 201 {
 202         unsigned int timeout;
 203         u32 sr;
 204
 205         timeout = MRST_SPI_TIMEOUT;
 206         /* Early putc needs to make sure the TX FIFO is not full */
 207         while (--timeout) {
 208                 sr = dw_readl(pspi, sr);
 209                 if (!(sr & SR_TF_NOT_FULL))
 210                         cpu_relax();
 211                 else
 212                         break;
 213         }
 214
 215         if (!timeout)
 216                 pr_warn("MRST earlycon: timed out\n");
 217         else
 218                 max3110_write_data(c);
 219 }
 220
 221 /* Early SPI only uses polling mode */
 222 static void early_mrst_spi_write(struct console *con, const char *str,
 223                                         unsigned n)
 224 {
 225         int i;
 226
 227         for (i = 0; i < n && *str; i++) {
 228                 if (*str == '\n')
 229                         early_mrst_spi_putc('\r');
 230                 early_mrst_spi_putc(*str);
 231                 str++;
 232         }
 233 }
 234
 235 struct console early_mrst_console = {
 236         .name =         "earlymrst",
 237         .write =        early_mrst_spi_write,
 238         .flags =        CON_PRINTBUFFER,
 239         .index =        -1,
 240 };
 241
 242 /*
 243  * Following is the early console based on Medfield HSU (High
 244  * Speed UART) device.
 245  */
 246 #define HSU_PORT_BASE           0xffa28080
 247
 248 static void __iomem *phsu;
 249
 250 void hsu_early_console_init(const char *s)
 251 {
 252         unsigned long paddr, port = 0;
 253         u8 lcr;
 254
 255         /*
 256          * Select the early HSU console port if specified by user in the
 257          * kernel command line.
 258          */
 259         if (*s && !kstrtoul(s, 10, &port))
 260                 port = clamp_val(port, 0, 2);
 261
 262         paddr = HSU_PORT_BASE + port * 0x80;
 263         phsu = (void *)set_fixmap_offset_nocache(FIX_EARLYCON_MEM_BASE, paddr);
 264
 265         /* Disable FIFO */
 266         writeb(0x0, phsu + UART_FCR);
 267
 268         /* Set to default 115200 bps, 8n1 */
 269         lcr = readb(phsu + UART_LCR);
 270         writeb((0x80 | lcr), phsu + UART_LCR);
 271         writeb(0x18, phsu + UART_DLL);
 272         writeb(lcr,  phsu + UART_LCR);
 273         writel(0x3600, phsu + UART_MUL*4);
 274
 275         writeb(0x8, phsu + UART_MCR);
 276         writeb(0x7, phsu + UART_FCR);
 277         writeb(0x3, phsu + UART_LCR);
 278
 279         /* Clear IRQ status */
 280         readb(phsu + UART_LSR);
 281         readb(phsu + UART_RX);
 282         readb(phsu + UART_IIR);
 283         readb(phsu + UART_MSR);
 284
 285         /* Enable FIFO */
 286         writeb(0x7, phsu + UART_FCR);
 287 }
 288
 289 #define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
 290
 291 static void early_hsu_putc(char ch)
 292 {
 293         unsigned int timeout = 10000; /* 10ms */
 294         u8 status;
 295
 296         while (--timeout) {
 297                 status = readb(phsu + UART_LSR);
 298                 if (status & BOTH_EMPTY)
 299                         break;
 300                 udelay(1);
 301         }
 302
 303         /* Only write the char when there was no timeout */
 304         if (timeout)
 305                 writeb(ch, phsu + UART_TX);
 306 }
 307
 308 static void early_hsu_write(struct console *con, const char *str, unsigned n)
 309 {
 310         int i;
 311
 312         for (i = 0; i < n && *str; i++) {
 313                 if (*str == '\n')
 314                         early_hsu_putc('\r');
 315                 early_hsu_putc(*str);
 316                 str++;
 317         }
 318 }
 319
 320 struct console early_hsu_console = {
 321         .name =         "earlyhsu",
 322         .write =        early_hsu_write,
 323         .flags =        CON_PRINTBUFFER,
 324         .index =        -1,
 325 };