xref: /openbmc/u-boot/drivers/serial/ns16550.c (revision 9ee16897)
1 /*
2  * COM1 NS16550 support
3  * originally from linux source (arch/powerpc/boot/ns16550.c)
4  * modified to use CONFIG_SYS_ISA_MEM and new defines
5  */
6 
7 #include <common.h>
8 #include <dm.h>
9 #include <errno.h>
10 #include <fdtdec.h>
11 #include <mapmem.h>
12 #include <ns16550.h>
13 #include <serial.h>
14 #include <watchdog.h>
15 #include <linux/types.h>
16 #include <asm/io.h>
17 
18 DECLARE_GLOBAL_DATA_PTR;
19 
20 #define UART_LCRVAL UART_LCR_8N1		/* 8 data, 1 stop, no parity */
21 #define UART_MCRVAL (UART_MCR_DTR | \
22 		     UART_MCR_RTS)		/* RTS/DTR */
23 #define UART_FCRVAL (UART_FCR_FIFO_EN |	\
24 		     UART_FCR_RXSR |	\
25 		     UART_FCR_TXSR)		/* Clear & enable FIFOs */
26 
27 #ifndef CONFIG_DM_SERIAL
28 #ifdef CONFIG_SYS_NS16550_PORT_MAPPED
29 #define serial_out(x, y)	outb(x, (ulong)y)
30 #define serial_in(y)		inb((ulong)y)
31 #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE > 0)
32 #define serial_out(x, y)	out_be32(y, x)
33 #define serial_in(y)		in_be32(y)
34 #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE < 0)
35 #define serial_out(x, y)	out_le32(y, x)
36 #define serial_in(y)		in_le32(y)
37 #else
38 #define serial_out(x, y)	writeb(x, y)
39 #define serial_in(y)		readb(y)
40 #endif
41 #endif /* !CONFIG_DM_SERIAL */
42 
43 #if defined(CONFIG_SOC_KEYSTONE)
44 #define UART_REG_VAL_PWREMU_MGMT_UART_DISABLE   0
45 #define UART_REG_VAL_PWREMU_MGMT_UART_ENABLE ((1 << 14) | (1 << 13) | (1 << 0))
46 #undef UART_MCRVAL
47 #ifdef CONFIG_SERIAL_HW_FLOW_CONTROL
48 #define UART_MCRVAL             (UART_MCR_RTS | UART_MCR_AFE)
49 #else
50 #define UART_MCRVAL             (UART_MCR_RTS)
51 #endif
52 #endif
53 
54 #ifndef CONFIG_SYS_NS16550_IER
55 #define CONFIG_SYS_NS16550_IER  0x00
56 #endif /* CONFIG_SYS_NS16550_IER */
57 
58 #ifdef CONFIG_DM_SERIAL
59 
60 static inline void serial_out_shift(void *addr, int shift, int value)
61 {
62 #ifdef CONFIG_SYS_NS16550_PORT_MAPPED
63 	outb(value, (ulong)addr);
64 #elif defined(CONFIG_SYS_NS16550_MEM32) && !defined(CONFIG_SYS_BIG_ENDIAN)
65 	out_le32(addr, value);
66 #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_BIG_ENDIAN)
67 	out_be32(addr, value);
68 #elif defined(CONFIG_SYS_NS16550_MEM32)
69 	writel(value, addr);
70 #elif defined(CONFIG_SYS_BIG_ENDIAN)
71 	writeb(value, addr + (1 << shift) - 1);
72 #else
73 	writeb(value, addr);
74 #endif
75 }
76 
77 static inline int serial_in_shift(void *addr, int shift)
78 {
79 #ifdef CONFIG_SYS_NS16550_PORT_MAPPED
80 	return inb((ulong)addr);
81 #elif defined(CONFIG_SYS_NS16550_MEM32) && !defined(CONFIG_SYS_BIG_ENDIAN)
82 	return in_le32(addr);
83 #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_BIG_ENDIAN)
84 	return in_be32(addr);
85 #elif defined(CONFIG_SYS_NS16550_MEM32)
86 	return readl(addr);
87 #elif defined(CONFIG_SYS_BIG_ENDIAN)
88 	return readb(addr + (1 << shift) - 1);
89 #else
90 	return readb(addr);
91 #endif
92 }
93 
94 static void ns16550_writeb(NS16550_t port, int offset, int value)
95 {
96 	struct ns16550_platdata *plat = port->plat;
97 	unsigned char *addr;
98 
99 	offset *= 1 << plat->reg_shift;
100 	addr = map_sysmem(plat->base, 0) + offset;
101 	/*
102 	 * As far as we know it doesn't make sense to support selection of
103 	 * these options at run-time, so use the existing CONFIG options.
104 	 */
105 	serial_out_shift(addr, plat->reg_shift, value);
106 }
107 
108 static int ns16550_readb(NS16550_t port, int offset)
109 {
110 	struct ns16550_platdata *plat = port->plat;
111 	unsigned char *addr;
112 
113 	offset *= 1 << plat->reg_shift;
114 	addr = map_sysmem(plat->base, 0) + offset;
115 
116 	return serial_in_shift(addr, plat->reg_shift);
117 }
118 
119 /* We can clean these up once everything is moved to driver model */
120 #define serial_out(value, addr)	\
121 	ns16550_writeb(com_port, \
122 		(unsigned char *)addr - (unsigned char *)com_port, value)
123 #define serial_in(addr) \
124 	ns16550_readb(com_port, \
125 		(unsigned char *)addr - (unsigned char *)com_port)
126 #endif
127 
128 static inline int calc_divisor(NS16550_t port, int clock, int baudrate)
129 {
130 	const unsigned int mode_x_div = 16;
131 
132 	return DIV_ROUND_CLOSEST(clock, mode_x_div * baudrate);
133 }
134 
135 int ns16550_calc_divisor(NS16550_t port, int clock, int baudrate)
136 {
137 #ifdef CONFIG_OMAP1510
138 	/* If can't cleanly clock 115200 set div to 1 */
139 	if ((clock == 12000000) && (baudrate == 115200)) {
140 		port->osc_12m_sel = OSC_12M_SEL;  /* enable 6.5 * divisor */
141 		return 1;			/* return 1 for base divisor */
142 	}
143 	port->osc_12m_sel = 0;			/* clear if previsouly set */
144 #endif
145 
146 	return calc_divisor(port, clock, baudrate);
147 }
148 
149 static void NS16550_setbrg(NS16550_t com_port, int baud_divisor)
150 {
151 	serial_out(UART_LCR_BKSE | UART_LCRVAL, &com_port->lcr);
152 	serial_out(baud_divisor & 0xff, &com_port->dll);
153 	serial_out((baud_divisor >> 8) & 0xff, &com_port->dlm);
154 	serial_out(UART_LCRVAL, &com_port->lcr);
155 }
156 
157 void NS16550_init(NS16550_t com_port, int baud_divisor)
158 {
159 #if (defined(CONFIG_SPL_BUILD) && \
160 		(defined(CONFIG_OMAP34XX) || defined(CONFIG_OMAP44XX)))
161 	/*
162 	 * On some OMAP3/OMAP4 devices when UART3 is configured for boot mode
163 	 * before SPL starts only THRE bit is set. We have to empty the
164 	 * transmitter before initialization starts.
165 	 */
166 	if ((serial_in(&com_port->lsr) & (UART_LSR_TEMT | UART_LSR_THRE))
167 	     == UART_LSR_THRE) {
168 		if (baud_divisor != -1)
169 			NS16550_setbrg(com_port, baud_divisor);
170 		serial_out(0, &com_port->mdr1);
171 	}
172 #endif
173 
174 	while (!(serial_in(&com_port->lsr) & UART_LSR_TEMT))
175 		;
176 
177 	serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier);
178 #if defined(CONFIG_OMAP) || defined(CONFIG_AM33XX) || \
179 			defined(CONFIG_TI81XX) || defined(CONFIG_AM43XX)
180 	serial_out(0x7, &com_port->mdr1);	/* mode select reset TL16C750*/
181 #endif
182 	serial_out(UART_MCRVAL, &com_port->mcr);
183 	serial_out(UART_FCRVAL, &com_port->fcr);
184 	if (baud_divisor != -1)
185 		NS16550_setbrg(com_port, baud_divisor);
186 #if defined(CONFIG_OMAP) || \
187 	defined(CONFIG_AM33XX) || defined(CONFIG_SOC_DA8XX) || \
188 	defined(CONFIG_TI81XX) || defined(CONFIG_AM43XX)
189 
190 	/* /16 is proper to hit 115200 with 48MHz */
191 	serial_out(0, &com_port->mdr1);
192 #endif /* CONFIG_OMAP */
193 #if defined(CONFIG_SOC_KEYSTONE)
194 	serial_out(UART_REG_VAL_PWREMU_MGMT_UART_ENABLE, &com_port->regC);
195 #endif
196 }
197 
198 #ifndef CONFIG_NS16550_MIN_FUNCTIONS
199 void NS16550_reinit(NS16550_t com_port, int baud_divisor)
200 {
201 	serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier);
202 	NS16550_setbrg(com_port, 0);
203 	serial_out(UART_MCRVAL, &com_port->mcr);
204 	serial_out(UART_FCRVAL, &com_port->fcr);
205 	NS16550_setbrg(com_port, baud_divisor);
206 }
207 #endif /* CONFIG_NS16550_MIN_FUNCTIONS */
208 
209 void NS16550_putc(NS16550_t com_port, char c)
210 {
211 	while ((serial_in(&com_port->lsr) & UART_LSR_THRE) == 0)
212 		;
213 	serial_out(c, &com_port->thr);
214 
215 	/*
216 	 * Call watchdog_reset() upon newline. This is done here in putc
217 	 * since the environment code uses a single puts() to print the complete
218 	 * environment upon "printenv". So we can't put this watchdog call
219 	 * in puts().
220 	 */
221 	if (c == '\n')
222 		WATCHDOG_RESET();
223 }
224 
225 #ifndef CONFIG_NS16550_MIN_FUNCTIONS
226 char NS16550_getc(NS16550_t com_port)
227 {
228 	while ((serial_in(&com_port->lsr) & UART_LSR_DR) == 0) {
229 #if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_USB_TTY)
230 		extern void usbtty_poll(void);
231 		usbtty_poll();
232 #endif
233 		WATCHDOG_RESET();
234 	}
235 	return serial_in(&com_port->rbr);
236 }
237 
238 int NS16550_tstc(NS16550_t com_port)
239 {
240 	return (serial_in(&com_port->lsr) & UART_LSR_DR) != 0;
241 }
242 
243 #endif /* CONFIG_NS16550_MIN_FUNCTIONS */
244 
245 #ifdef CONFIG_DEBUG_UART_NS16550
246 
247 #include <debug_uart.h>
248 
249 #define serial_dout(reg, value)	\
250 	serial_out_shift((char *)com_port + \
251 		((char *)reg - (char *)com_port) * \
252 			(1 << CONFIG_DEBUG_UART_SHIFT), \
253 		CONFIG_DEBUG_UART_SHIFT, value)
254 #define serial_din(reg) \
255 	serial_in_shift((char *)com_port + \
256 		((char *)reg - (char *)com_port) * \
257 			(1 << CONFIG_DEBUG_UART_SHIFT), \
258 		CONFIG_DEBUG_UART_SHIFT)
259 
260 void debug_uart_init(void)
261 {
262 	struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE;
263 	int baud_divisor;
264 
265 	/*
266 	 * We copy the code from above because it is already horribly messy.
267 	 * Trying to refactor to nicely remove the duplication doesn't seem
268 	 * feasible. The better fix is to move all users of this driver to
269 	 * driver model.
270 	 */
271 	baud_divisor = calc_divisor(com_port, CONFIG_DEBUG_UART_CLOCK,
272 				    CONFIG_BAUDRATE);
273 	serial_dout(&com_port->ier, CONFIG_SYS_NS16550_IER);
274 	serial_dout(&com_port->mcr, UART_MCRVAL);
275 	serial_dout(&com_port->fcr, UART_FCRVAL);
276 
277 	serial_dout(&com_port->lcr, UART_LCR_BKSE | UART_LCRVAL);
278 	serial_dout(&com_port->dll, baud_divisor & 0xff);
279 	serial_dout(&com_port->dlm, (baud_divisor >> 8) & 0xff);
280 	serial_dout(&com_port->lcr, UART_LCRVAL);
281 }
282 
283 static inline void _debug_uart_putc(int ch)
284 {
285 	struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE;
286 
287 	while (!(serial_din(&com_port->lsr) & UART_LSR_THRE))
288 		;
289 	serial_dout(&com_port->thr, ch);
290 }
291 
292 DEBUG_UART_FUNCS
293 
294 #endif
295 
296 #ifdef CONFIG_DM_SERIAL
297 static int ns16550_serial_putc(struct udevice *dev, const char ch)
298 {
299 	struct NS16550 *const com_port = dev_get_priv(dev);
300 
301 	if (!(serial_in(&com_port->lsr) & UART_LSR_THRE))
302 		return -EAGAIN;
303 	serial_out(ch, &com_port->thr);
304 
305 	/*
306 	 * Call watchdog_reset() upon newline. This is done here in putc
307 	 * since the environment code uses a single puts() to print the complete
308 	 * environment upon "printenv". So we can't put this watchdog call
309 	 * in puts().
310 	 */
311 	if (ch == '\n')
312 		WATCHDOG_RESET();
313 
314 	return 0;
315 }
316 
317 static int ns16550_serial_pending(struct udevice *dev, bool input)
318 {
319 	struct NS16550 *const com_port = dev_get_priv(dev);
320 
321 	if (input)
322 		return serial_in(&com_port->lsr) & UART_LSR_DR ? 1 : 0;
323 	else
324 		return serial_in(&com_port->lsr) & UART_LSR_THRE ? 0 : 1;
325 }
326 
327 static int ns16550_serial_getc(struct udevice *dev)
328 {
329 	struct NS16550 *const com_port = dev_get_priv(dev);
330 
331 	if (!(serial_in(&com_port->lsr) & UART_LSR_DR))
332 		return -EAGAIN;
333 
334 	return serial_in(&com_port->rbr);
335 }
336 
337 static int ns16550_serial_setbrg(struct udevice *dev, int baudrate)
338 {
339 	struct NS16550 *const com_port = dev_get_priv(dev);
340 	struct ns16550_platdata *plat = com_port->plat;
341 	int clock_divisor;
342 
343 	clock_divisor = ns16550_calc_divisor(com_port, plat->clock, baudrate);
344 
345 	NS16550_setbrg(com_port, clock_divisor);
346 
347 	return 0;
348 }
349 
350 int ns16550_serial_probe(struct udevice *dev)
351 {
352 	struct NS16550 *const com_port = dev_get_priv(dev);
353 
354 	com_port->plat = dev_get_platdata(dev);
355 	NS16550_init(com_port, -1);
356 
357 	return 0;
358 }
359 
360 #if CONFIG_IS_ENABLED(OF_CONTROL)
361 int ns16550_serial_ofdata_to_platdata(struct udevice *dev)
362 {
363 	struct ns16550_platdata *plat = dev->platdata;
364 	fdt_addr_t addr;
365 
366 	/* try Processor Local Bus device first */
367 	addr = dev_get_addr(dev);
368 #ifdef CONFIG_PCI
369 	if (addr == FDT_ADDR_T_NONE) {
370 		/* then try pci device */
371 		struct fdt_pci_addr pci_addr;
372 		u32 bar;
373 		int ret;
374 
375 		/* we prefer to use a memory-mapped register */
376 		ret = fdtdec_get_pci_addr(gd->fdt_blob, dev->of_offset,
377 					  FDT_PCI_SPACE_MEM32, "reg",
378 					  &pci_addr);
379 		if (ret) {
380 			/* try if there is any i/o-mapped register */
381 			ret = fdtdec_get_pci_addr(gd->fdt_blob,
382 						  dev->of_offset,
383 						  FDT_PCI_SPACE_IO,
384 						  "reg", &pci_addr);
385 			if (ret)
386 				return ret;
387 		}
388 
389 		ret = fdtdec_get_pci_bar32(gd->fdt_blob, dev->of_offset,
390 					   &pci_addr, &bar);
391 		if (ret)
392 			return ret;
393 
394 		addr = bar;
395 	}
396 #endif
397 
398 	if (addr == FDT_ADDR_T_NONE)
399 		return -EINVAL;
400 
401 	plat->base = addr;
402 	plat->reg_shift = fdtdec_get_int(gd->fdt_blob, dev->of_offset,
403 					 "reg-shift", 1);
404 
405 	return 0;
406 }
407 #endif
408 
409 const struct dm_serial_ops ns16550_serial_ops = {
410 	.putc = ns16550_serial_putc,
411 	.pending = ns16550_serial_pending,
412 	.getc = ns16550_serial_getc,
413 	.setbrg = ns16550_serial_setbrg,
414 };
415 #endif /* CONFIG_DM_SERIAL */
416