]> git.sur5r.net Git - u-boot/blob - drivers/serial/serial_zynq.c
c09aa271b5c38c405a3f7a9269c6be0e83d4df07
[u-boot] / drivers / serial / serial_zynq.c
1 /*
2  * Copyright (C) 2012 Michal Simek <monstr@monstr.eu>
3  * Copyright (C) 2011-2012 Xilinx, Inc. All rights reserved.
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <watchdog.h>
26 #include <asm/io.h>
27 #include <linux/compiler.h>
28 #include <serial.h>
29
30 #define ZYNQ_UART_SR_TXFULL     0x00000010 /* TX FIFO full */
31 #define ZYNQ_UART_SR_RXEMPTY    0x00000002 /* RX FIFO empty */
32
33 #define ZYNQ_UART_CR_TX_EN      0x00000010 /* TX enabled */
34 #define ZYNQ_UART_CR_RX_EN      0x00000004 /* RX enabled */
35 #define ZYNQ_UART_CR_TXRST      0x00000002 /* TX logic reset */
36 #define ZYNQ_UART_CR_RXRST      0x00000001 /* RX logic reset */
37
38 #define ZYNQ_UART_MR_PARITY_NONE        0x00000020  /* No parity mode */
39
40 /* Some clock/baud constants */
41 #define ZYNQ_UART_BDIV  15 /* Default/reset BDIV value */
42 #define ZYNQ_UART_BASECLK       3125000L /* master / (bdiv + 1) */
43
44 struct uart_zynq {
45         u32 control; /* Control Register [8:0] */
46         u32 mode; /* Mode Register [10:0] */
47         u32 reserved1[4];
48         u32 baud_rate_gen; /* Baud Rate Generator [15:0] */
49         u32 reserved2[4];
50         u32 channel_sts; /* Channel Status [11:0] */
51         u32 tx_rx_fifo; /* FIFO [15:0] or [7:0] */
52         u32 baud_rate_divider; /* Baud Rate Divider [7:0] */
53 };
54
55 static struct uart_zynq *uart_zynq_ports[2] = {
56 #ifdef CONFIG_ZYNQ_SERIAL_BASEADDR0
57         [0] = (struct uart_zynq *)CONFIG_ZYNQ_SERIAL_BASEADDR0,
58 #endif
59 #ifdef CONFIG_ZYNQ_SERIAL_BASEADDR1
60         [1] = (struct uart_zynq *)CONFIG_ZYNQ_SERIAL_BASEADDR1,
61 #endif
62 };
63
64 struct uart_zynq_params {
65         u32 baudrate;
66         u32 clock;
67 };
68
69 static struct uart_zynq_params uart_zynq_ports_param[2] = {
70 #if defined(CONFIG_ZYNQ_SERIAL_BAUDRATE0) && defined(CONFIG_ZYNQ_SERIAL_CLOCK0)
71         [0].baudrate = CONFIG_ZYNQ_SERIAL_BAUDRATE0,
72         [0].clock = CONFIG_ZYNQ_SERIAL_CLOCK0,
73 #endif
74 #if defined(CONFIG_ZYNQ_SERIAL_BAUDRATE1) && defined(CONFIG_ZYNQ_SERIAL_CLOCK1)
75         [1].baudrate = CONFIG_ZYNQ_SERIAL_BAUDRATE1,
76         [1].clock = CONFIG_ZYNQ_SERIAL_CLOCK1,
77 #endif
78 };
79
80 /* Set up the baud rate in gd struct */
81 static void uart_zynq_serial_setbrg(const int port)
82 {
83         /* Calculation results. */
84         unsigned int calc_bauderror, bdiv, bgen;
85         unsigned long calc_baud = 0;
86         unsigned long baud = uart_zynq_ports_param[port].baudrate;
87         unsigned long clock = uart_zynq_ports_param[port].clock;
88         struct uart_zynq *regs = uart_zynq_ports[port];
89
90         /*                master clock
91          * Baud rate = ------------------
92          *              bgen * (bdiv + 1)
93          *
94          * Find acceptable values for baud generation.
95          */
96         for (bdiv = 4; bdiv < 255; bdiv++) {
97                 bgen = clock / (baud * (bdiv + 1));
98                 if (bgen < 2 || bgen > 65535)
99                         continue;
100
101                 calc_baud = clock / (bgen * (bdiv + 1));
102
103                 /*
104                  * Use first calculated baudrate with
105                  * an acceptable (<3%) error
106                  */
107                 if (baud > calc_baud)
108                         calc_bauderror = baud - calc_baud;
109                 else
110                         calc_bauderror = calc_baud - baud;
111                 if (((calc_bauderror * 100) / baud) < 3)
112                         break;
113         }
114
115         writel(bdiv, &regs->baud_rate_divider);
116         writel(bgen, &regs->baud_rate_gen);
117 }
118
119 /* Initialize the UART, with...some settings. */
120 static int uart_zynq_serial_init(const int port)
121 {
122         struct uart_zynq *regs = uart_zynq_ports[port];
123
124         if (!regs)
125                 return -1;
126
127         /* RX/TX enabled & reset */
128         writel(ZYNQ_UART_CR_TX_EN | ZYNQ_UART_CR_RX_EN | ZYNQ_UART_CR_TXRST | \
129                                         ZYNQ_UART_CR_RXRST, &regs->control);
130         writel(ZYNQ_UART_MR_PARITY_NONE, &regs->mode); /* 8 bit, no parity */
131         uart_zynq_serial_setbrg(port);
132
133         return 0;
134 }
135
136 static void uart_zynq_serial_putc(const char c, const int port)
137 {
138         struct uart_zynq *regs = uart_zynq_ports[port];
139
140         while ((readl(&regs->channel_sts) & ZYNQ_UART_SR_TXFULL) != 0)
141                 WATCHDOG_RESET();
142
143         if (c == '\n') {
144                 writel('\r', &regs->tx_rx_fifo);
145                 while ((readl(&regs->channel_sts) & ZYNQ_UART_SR_TXFULL) != 0)
146                         WATCHDOG_RESET();
147         }
148         writel(c, &regs->tx_rx_fifo);
149 }
150
151 static void uart_zynq_serial_puts(const char *s, const int port)
152 {
153         while (*s)
154                 uart_zynq_serial_putc(*s++, port);
155 }
156
157 static int uart_zynq_serial_tstc(const int port)
158 {
159         struct uart_zynq *regs = uart_zynq_ports[port];
160
161         return (readl(&regs->channel_sts) & ZYNQ_UART_SR_RXEMPTY) == 0;
162 }
163
164 static int uart_zynq_serial_getc(const int port)
165 {
166         struct uart_zynq *regs = uart_zynq_ports[port];
167
168         while (!uart_zynq_serial_tstc(port))
169                 WATCHDOG_RESET();
170         return readl(&regs->tx_rx_fifo);
171 }
172
173 /* Multi serial device functions */
174 #define DECLARE_PSSERIAL_FUNCTIONS(port) \
175         int uart_zynq##port##_init(void) \
176                                 { return uart_zynq_serial_init(port); } \
177         void uart_zynq##port##_setbrg(void) \
178                                 { return uart_zynq_serial_setbrg(port); } \
179         int uart_zynq##port##_getc(void) \
180                                 { return uart_zynq_serial_getc(port); } \
181         int uart_zynq##port##_tstc(void) \
182                                 { return uart_zynq_serial_tstc(port); } \
183         void uart_zynq##port##_putc(const char c) \
184                                 { uart_zynq_serial_putc(c, port); } \
185         void uart_zynq##port##_puts(const char *s) \
186                                 { uart_zynq_serial_puts(s, port); }
187
188 /* Serial device descriptor */
189 #define INIT_PSSERIAL_STRUCTURE(port, __name) { \
190           .name   = __name,                     \
191           .start  = uart_zynq##port##_init,     \
192           .stop   = NULL,                       \
193           .setbrg = uart_zynq##port##_setbrg,   \
194           .getc   = uart_zynq##port##_getc,     \
195           .tstc   = uart_zynq##port##_tstc,     \
196           .putc   = uart_zynq##port##_putc,     \
197           .puts   = uart_zynq##port##_puts,     \
198 }
199
200 DECLARE_PSSERIAL_FUNCTIONS(0);
201 struct serial_device uart_zynq_serial0_device =
202         INIT_PSSERIAL_STRUCTURE(0, "ttyPS0");
203 DECLARE_PSSERIAL_FUNCTIONS(1);
204 struct serial_device uart_zynq_serial1_device =
205         INIT_PSSERIAL_STRUCTURE(1, "ttyPS1");
206
207 __weak struct serial_device *default_serial_console(void)
208 {
209         if (uart_zynq_ports[0])
210                 return &uart_zynq_serial0_device;
211         if (uart_zynq_ports[1])
212                 return &uart_zynq_serial1_device;
213
214         return NULL;
215 }
216
217 void zynq_serial_initalize(void)
218 {
219 #ifdef CONFIG_ZYNQ_SERIAL_BASEADDR0
220         serial_register(&uart_zynq_serial0_device);
221 #endif
222 #ifdef CONFIG_ZYNQ_SERIAL_BASEADDR1
223         serial_register(&uart_zynq_serial1_device);
224 #endif
225 }