]>
Commit | Line | Data |
---|---|---|
dd2c9e6a MK |
1 | /* |
2 | * (C) Copyright 2009 SAMSUNG Electronics | |
3 | * Minkyu Kang <mk7.kang@samsung.com> | |
4 | * Heungjun Kim <riverful.kim@samsung.com> | |
5 | * | |
6 | * based on drivers/serial/s3c64xx.c | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (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, MA 02111-1307 USA | |
21 | * | |
22 | */ | |
23 | ||
24 | #include <common.h> | |
25 | #include <asm/io.h> | |
26 | #include <asm/arch/uart.h> | |
27 | #include <asm/arch/clk.h> | |
28 | #include <serial.h> | |
29 | ||
30 | static inline struct s5pc1xx_uart *s5pc1xx_get_base_uart(int dev_index) | |
31 | { | |
32 | u32 offset = dev_index * sizeof(struct s5pc1xx_uart); | |
33 | ||
34 | if (cpu_is_s5pc100()) | |
35 | return (struct s5pc1xx_uart *)(S5PC100_UART_BASE + offset); | |
36 | else | |
37 | return (struct s5pc1xx_uart *)(S5PC110_UART_BASE + offset); | |
38 | } | |
39 | ||
40 | /* | |
41 | * The coefficient, used to calculate the baudrate on S5PC1XX UARTs is | |
42 | * calculated as | |
43 | * C = UBRDIV * 16 + number_of_set_bits_in_UDIVSLOT | |
44 | * however, section 31.6.11 of the datasheet doesn't recomment using 1 for 1, | |
45 | * 3 for 2, ... (2^n - 1) for n, instead, they suggest using these constants: | |
46 | */ | |
47 | static const int udivslot[] = { | |
48 | 0, | |
49 | 0x0080, | |
50 | 0x0808, | |
51 | 0x0888, | |
52 | 0x2222, | |
53 | 0x4924, | |
54 | 0x4a52, | |
55 | 0x54aa, | |
56 | 0x5555, | |
57 | 0xd555, | |
58 | 0xd5d5, | |
59 | 0xddd5, | |
60 | 0xdddd, | |
61 | 0xdfdd, | |
62 | 0xdfdf, | |
63 | 0xffdf, | |
64 | }; | |
65 | ||
66 | void serial_setbrg_dev(const int dev_index) | |
67 | { | |
68 | DECLARE_GLOBAL_DATA_PTR; | |
69 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
70 | u32 pclk = get_pclk(); | |
71 | u32 baudrate = gd->baudrate; | |
72 | u32 val; | |
73 | ||
74 | val = pclk / baudrate; | |
75 | ||
76 | writel(val / 16 - 1, &uart->ubrdiv); | |
f3807374 | 77 | writew(udivslot[val % 16], &uart->udivslot); |
dd2c9e6a MK |
78 | } |
79 | ||
80 | /* | |
81 | * Initialise the serial port with the given baudrate. The settings | |
82 | * are always 8 data bits, no parity, 1 stop bit, no start bits. | |
83 | */ | |
84 | int serial_init_dev(const int dev_index) | |
85 | { | |
86 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
87 | ||
88 | /* reset and enable FIFOs, set triggers to the maximum */ | |
89 | writel(0, &uart->ufcon); | |
90 | writel(0, &uart->umcon); | |
91 | /* 8N1 */ | |
92 | writel(0x3, &uart->ulcon); | |
93 | /* No interrupts, no DMA, pure polling */ | |
94 | writel(0x245, &uart->ucon); | |
95 | ||
96 | serial_setbrg_dev(dev_index); | |
97 | ||
98 | return 0; | |
99 | } | |
100 | ||
94003226 | 101 | static int serial_err_check(const int dev_index, int op) |
dd2c9e6a MK |
102 | { |
103 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
94003226 MK |
104 | unsigned int mask; |
105 | ||
106 | /* | |
107 | * UERSTAT | |
108 | * Break Detect [3] | |
109 | * Frame Err [2] : receive operation | |
110 | * Parity Err [1] : receive operation | |
111 | * Overrun Err [0] : receive operation | |
112 | */ | |
113 | if (op) | |
114 | mask = 0x8; | |
115 | else | |
116 | mask = 0xf; | |
dd2c9e6a | 117 | |
94003226 | 118 | return readl(&uart->uerstat) & mask; |
dd2c9e6a MK |
119 | } |
120 | ||
121 | /* | |
122 | * Read a single byte from the serial port. Returns 1 on success, 0 | |
123 | * otherwise. When the function is succesfull, the character read is | |
124 | * written into its argument c. | |
125 | */ | |
126 | int serial_getc_dev(const int dev_index) | |
127 | { | |
128 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
129 | ||
130 | /* wait for character to arrive */ | |
131 | while (!(readl(&uart->utrstat) & 0x1)) { | |
94003226 | 132 | if (serial_err_check(dev_index, 0)) |
dd2c9e6a MK |
133 | return 0; |
134 | } | |
135 | ||
136 | return (int)(readl(&uart->urxh) & 0xff); | |
137 | } | |
138 | ||
139 | /* | |
140 | * Output a single byte to the serial port. | |
141 | */ | |
142 | void serial_putc_dev(const char c, const int dev_index) | |
143 | { | |
144 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
145 | ||
146 | /* wait for room in the tx FIFO */ | |
147 | while (!(readl(&uart->utrstat) & 0x2)) { | |
94003226 | 148 | if (serial_err_check(dev_index, 1)) |
dd2c9e6a MK |
149 | return; |
150 | } | |
151 | ||
152 | writel(c, &uart->utxh); | |
153 | ||
154 | /* If \n, also do \r */ | |
155 | if (c == '\n') | |
156 | serial_putc('\r'); | |
157 | } | |
158 | ||
159 | /* | |
160 | * Test whether a character is in the RX buffer | |
161 | */ | |
162 | int serial_tstc_dev(const int dev_index) | |
163 | { | |
164 | struct s5pc1xx_uart *const uart = s5pc1xx_get_base_uart(dev_index); | |
165 | ||
166 | return (int)(readl(&uart->utrstat) & 0x1); | |
167 | } | |
168 | ||
169 | void serial_puts_dev(const char *s, const int dev_index) | |
170 | { | |
171 | while (*s) | |
172 | serial_putc_dev(*s++, dev_index); | |
173 | } | |
174 | ||
175 | /* Multi serial device functions */ | |
176 | #define DECLARE_S5P_SERIAL_FUNCTIONS(port) \ | |
177 | int s5p_serial##port##_init(void) { return serial_init_dev(port); } \ | |
178 | void s5p_serial##port##_setbrg(void) { serial_setbrg_dev(port); } \ | |
179 | int s5p_serial##port##_getc(void) { return serial_getc_dev(port); } \ | |
180 | int s5p_serial##port##_tstc(void) { return serial_tstc_dev(port); } \ | |
181 | void s5p_serial##port##_putc(const char c) { serial_putc_dev(c, port); } \ | |
182 | void s5p_serial##port##_puts(const char *s) { serial_puts_dev(s, port); } | |
183 | ||
184 | #define INIT_S5P_SERIAL_STRUCTURE(port, name, bus) { \ | |
185 | name, \ | |
186 | bus, \ | |
187 | s5p_serial##port##_init, \ | |
188 | s5p_serial##port##_setbrg, \ | |
189 | s5p_serial##port##_getc, \ | |
190 | s5p_serial##port##_tstc, \ | |
191 | s5p_serial##port##_putc, \ | |
192 | s5p_serial##port##_puts, } | |
193 | ||
194 | DECLARE_S5P_SERIAL_FUNCTIONS(0); | |
195 | struct serial_device s5pc1xx_serial0_device = | |
196 | INIT_S5P_SERIAL_STRUCTURE(0, "s5pser0", "S5PUART0"); | |
197 | DECLARE_S5P_SERIAL_FUNCTIONS(1); | |
198 | struct serial_device s5pc1xx_serial1_device = | |
199 | INIT_S5P_SERIAL_STRUCTURE(1, "s5pser1", "S5PUART1"); | |
200 | DECLARE_S5P_SERIAL_FUNCTIONS(2); | |
201 | struct serial_device s5pc1xx_serial2_device = | |
202 | INIT_S5P_SERIAL_STRUCTURE(2, "s5pser2", "S5PUART2"); | |
203 | DECLARE_S5P_SERIAL_FUNCTIONS(3); | |
204 | struct serial_device s5pc1xx_serial3_device = | |
205 | INIT_S5P_SERIAL_STRUCTURE(3, "s5pser3", "S5PUART3"); |