src/cpu/ti/am335x/uart.c

   1 /*
   2  * Copyright 2013 Google Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <stdlib.h>
  16 #include <types.h>
  17 #include <console/uart.h>
  18 #include <arch/io.h>
  19 #include <boot/coreboot_tables.h>
  20 #include <cpu/ti/am335x/uart.h>
  21
  22 #define EFR_ENHANCED_EN         (1 << 4)
  23 #define FCR_FIFO_EN             (1 << 0)
  24 #define MCR_TCR_TLR             (1 << 6)
  25 #define SYSC_SOFTRESET          (1 << 1)
  26 #define SYSS_RESETDONE          (1 << 0)
  27
  28 #define LSR_RXFIFOE             (1 << 0)
  29 #define LSR_TXFIFOE             (1 << 5)
  30
  31 /*
  32  * Initialise the serial port with the given baudrate divisor. The settings
  33  * are always 8 data bits, no parity, 1 stop bit, no start bits.
  34  */
  35 static void am335x_uart_init(struct am335x_uart *uart, uint16_t div)
  36 {
  37         uint16_t lcr_orig, efr_orig, mcr_orig;
  38
  39         /* reset the UART */
  40         write16(&uart->sysc, uart->sysc | SYSC_SOFTRESET);
  41         while (!(read16(&uart->syss) & SYSS_RESETDONE))
  42                 ;
  43
  44         /* 1. switch to register config mode B */
  45         lcr_orig = read16(&uart->lcr);
  46         write16(&uart->lcr, 0xbf);
  47
  48         /*
  49          * 2. Set EFR ENHANCED_EN bit. To access this bit, registers must
  50          * be in TCR_TLR submode, meaning EFR[4] = 1 and MCR[6] = 1.
  51          */
  52         efr_orig = read16(&uart->efr);
  53         write16(&uart->efr, efr_orig | EFR_ENHANCED_EN);
  54
  55         /* 3. Switch to register config mode A */
  56         write16(&uart->lcr, 0x80);
  57
  58         /* 4. Enable register submode TCR_TLR to access the UARTi.UART_TLR */
  59         mcr_orig = read16(&uart->mcr);
  60         write16(&uart->mcr, mcr_orig | MCR_TCR_TLR);
  61
  62         /* 5. Enable the FIFO. For now we'll ignore FIFO triggers and DMA */
  63         write16(&uart->fcr, FCR_FIFO_EN);
  64
  65         /* 6. Switch to configuration mode B */
  66         write16(&uart->lcr, 0xbf);
  67         /* Skip steps 7 and 8 (setting up FIFO triggers for DMA) */
  68
  69         /* 9. Restore original EFR value */
  70         write16(&uart->efr, efr_orig);
  71
  72         /* 10. Switch to config mode A */
  73         write16(&uart->lcr, 0x80);
  74
  75         /* 11. Restore original MCR value */
  76         write16(&uart->mcr, mcr_orig);
  77
  78         /* 12. Restore original LCR value */
  79         write16(&uart->lcr, lcr_orig);
  80
  81         /* Protocol, baud rate and interrupt settings */
  82
  83         /* 1. Disable UART access to DLL and DLH registers */
  84         write16(&uart->mdr1, read16(&uart->mdr1) | 0x7);
  85
  86         /* 2. Switch to config mode B */
  87         write16(&uart->lcr, 0xbf);
  88
  89         /* 3. Enable access to IER[7:4] */
  90         write16(&uart->efr, efr_orig | EFR_ENHANCED_EN);
  91
  92         /* 4. Switch to operational mode */
  93         write16(&uart->lcr, 0x0);
  94
  95         /* 5. Clear IER */
  96         write16(&uart->ier, 0x0);
  97
  98         /* 6. Switch to config mode B */
  99         write16(&uart->lcr, 0xbf);
 100
 101         /* 7. Set dll and dlh to the desired values (table 19-25) */
 102         write16(&uart->dlh, (div >> 8));
 103         write16(&uart->dll, (div & 0xff));
 104
 105         /* 8. Switch to operational mode to access ier */
 106         write16(&uart->lcr, 0x0);
 107
 108         /* 9. Clear ier to disable all interrupts */
 109         write16(&uart->ier, 0x0);
 110
 111         /* 10. Switch to config mode B */
 112         write16(&uart->lcr, 0xbf);
 113
 114         /* 11. Restore efr */
 115         write16(&uart->efr, efr_orig);
 116
 117         /* 12. Set protocol formatting 8n1 (8 bit data, no parity, 1 stop bit) */
 118         write16(&uart->lcr, 0x3);
 119
 120         /* 13. Load the new UART mode */
 121         write16(&uart->mdr1, 0x0);
 122 }
 123
 124 /*
 125  * Read a single byte from the serial port. Returns 1 on success, 0
 126  * otherwise. When the function is successful, the character read is
 127  * written into its argument c.
 128  */
 129 static unsigned char am335x_uart_rx_byte(struct am335x_uart *uart)
 130 {
 131         while (!(read16(&uart->lsr) & LSR_RXFIFOE));
 132
 133         return read8(&uart->rhr);
 134 }
 135
 136 /*
 137  * Output a single byte to the serial port.
 138  */
 139 static void am335x_uart_tx_byte(struct am335x_uart *uart, unsigned char data)
 140 {
 141         while (!(read16(&uart->lsr) & LSR_TXFIFOE));
 142
 143         return write8(&uart->thr, data);
 144 }
 145
 146 unsigned int uart_platform_refclk(void)
 147 {
 148         return 48000000;
 149 }
 150
 151 uintptr_t uart_platform_base(int idx)
 152 {
 153         const unsigned int bases[] = {
 154                 0x44e09000, 0x48022000, 0x48024000,
 155                 0x481a6000, 0x481a8000, 0x481aa000
 156         };
 157         if (idx < ARRAY_SIZE(bases))
 158                 return bases[idx];
 159         return 0;
 160 }
 161
 162 void uart_init(int idx)
 163 {
 164         struct am335x_uart *uart = uart_platform_baseptr(idx);
 165         uint16_t div = (uint16_t) uart_baudrate_divisor(
 166                 default_baudrate(), uart_platform_refclk(), 16);
 167         am335x_uart_init(uart, div);
 168 }
 169
 170 unsigned char uart_rx_byte(int idx)
 171 {
 172         struct am335x_uart *uart = uart_platform_baseptr(idx);
 173         return am335x_uart_rx_byte(uart);
 174 }
 175
 176 void uart_tx_byte(int idx, unsigned char data)
 177 {
 178         struct am335x_uart *uart = uart_platform_baseptr(idx);
 179         am335x_uart_tx_byte(uart, data);
 180 }
 181
 182 void uart_tx_flush(int idx)
 183 {
 184 }
 185
 186 #ifndef __PRE_RAM__
 187 void uart_fill_lb(void *data)
 188 {
 189         struct lb_serial serial;
 190         serial.type = LB_SERIAL_TYPE_MEMORY_MAPPED;
 191         serial.baseaddr = uart_platform_base(CONFIG_UART_FOR_CONSOLE);
 192         serial.baud = default_baudrate();
 193         serial.regwidth = 2;
 194         lb_add_serial(&serial, data);
 195
 196         lb_add_console(LB_TAG_CONSOLE_SERIAL8250MEM, data);
 197 }
 198 #endif