wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 1 | /* |
| 2 | * COM1 NS16550 support |
Stefan Roese | a47a12b | 2010-04-15 16:07:28 +0200 | [diff] [blame] | 3 | * originally from linux source (arch/powerpc/boot/ns16550.c) |
Jean-Christophe PLAGNIOL-VILLARD | 6d0f6bc | 2008-10-16 15:01:15 +0200 | [diff] [blame] | 4 | * modified to use CONFIG_SYS_ISA_MEM and new defines |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 5 | */ |
| 6 | |
Simon Glass | fa54eb1 | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 7 | #include <common.h> |
Paul Burton | 50fce1d | 2016-09-08 07:47:29 +0100 | [diff] [blame] | 8 | #include <clk.h> |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 9 | #include <dm.h> |
| 10 | #include <errno.h> |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 11 | #include <ns16550.h> |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 12 | #include <serial.h> |
Ladislav Michl | a1b322a | 2010-02-01 23:34:25 +0100 | [diff] [blame] | 13 | #include <watchdog.h> |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 14 | #include <linux/types.h> |
| 15 | #include <asm/io.h> |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 16 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 17 | DECLARE_GLOBAL_DATA_PTR; |
| 18 | |
Detlev Zundel | 200779e | 2009-04-03 11:53:01 +0200 | [diff] [blame] | 19 | #define UART_LCRVAL UART_LCR_8N1 /* 8 data, 1 stop, no parity */ |
| 20 | #define UART_MCRVAL (UART_MCR_DTR | \ |
| 21 | UART_MCR_RTS) /* RTS/DTR */ |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 22 | |
| 23 | #ifndef CONFIG_DM_SERIAL |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 24 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 25 | #define serial_out(x, y) outb(x, (ulong)y) |
| 26 | #define serial_in(y) inb((ulong)y) |
Dave Aldridge | 79df120 | 2011-09-01 22:47:14 +0000 | [diff] [blame] | 27 | #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE > 0) |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 28 | #define serial_out(x, y) out_be32(y, x) |
| 29 | #define serial_in(y) in_be32(y) |
Dave Aldridge | 79df120 | 2011-09-01 22:47:14 +0000 | [diff] [blame] | 30 | #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE < 0) |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 31 | #define serial_out(x, y) out_le32(y, x) |
| 32 | #define serial_in(y) in_le32(y) |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 33 | #else |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 34 | #define serial_out(x, y) writeb(x, y) |
| 35 | #define serial_in(y) readb(y) |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 36 | #endif |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 37 | #endif /* !CONFIG_DM_SERIAL */ |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 38 | |
Khoronzhuk, Ivan | 7c38764 | 2014-07-16 00:59:25 +0300 | [diff] [blame] | 39 | #if defined(CONFIG_SOC_KEYSTONE) |
Vitaly Andrianov | ef509b9 | 2014-04-04 13:16:53 -0400 | [diff] [blame] | 40 | #define UART_REG_VAL_PWREMU_MGMT_UART_DISABLE 0 |
| 41 | #define UART_REG_VAL_PWREMU_MGMT_UART_ENABLE ((1 << 14) | (1 << 13) | (1 << 0)) |
Karicheri, Muralidharan | d57dee5 | 2014-04-09 15:38:46 -0400 | [diff] [blame] | 42 | #undef UART_MCRVAL |
| 43 | #ifdef CONFIG_SERIAL_HW_FLOW_CONTROL |
| 44 | #define UART_MCRVAL (UART_MCR_RTS | UART_MCR_AFE) |
| 45 | #else |
| 46 | #define UART_MCRVAL (UART_MCR_RTS) |
| 47 | #endif |
Vitaly Andrianov | ef509b9 | 2014-04-04 13:16:53 -0400 | [diff] [blame] | 48 | #endif |
| 49 | |
Prafulla Wadaskar | a160ea0 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 50 | #ifndef CONFIG_SYS_NS16550_IER |
| 51 | #define CONFIG_SYS_NS16550_IER 0x00 |
| 52 | #endif /* CONFIG_SYS_NS16550_IER */ |
| 53 | |
Simon Glass | 363e6da | 2015-02-27 22:06:26 -0700 | [diff] [blame] | 54 | static inline void serial_out_shift(void *addr, int shift, int value) |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 55 | { |
| 56 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
| 57 | outb(value, (ulong)addr); |
Bernhard Messerklinger | 78b7d37 | 2018-02-15 09:02:26 +0100 | [diff] [blame] | 58 | #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_LITTLE_ENDIAN) |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 59 | out_le32(addr, value); |
| 60 | #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_BIG_ENDIAN) |
| 61 | out_be32(addr, value); |
Simon Glass | 9091400 | 2015-05-12 14:55:02 -0600 | [diff] [blame] | 62 | #elif defined(CONFIG_SYS_NS16550_MEM32) |
| 63 | writel(value, addr); |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 64 | #elif defined(CONFIG_SYS_BIG_ENDIAN) |
| 65 | writeb(value, addr + (1 << shift) - 1); |
| 66 | #else |
| 67 | writeb(value, addr); |
| 68 | #endif |
| 69 | } |
| 70 | |
Simon Glass | 363e6da | 2015-02-27 22:06:26 -0700 | [diff] [blame] | 71 | static inline int serial_in_shift(void *addr, int shift) |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 72 | { |
| 73 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
| 74 | return inb((ulong)addr); |
Bernhard Messerklinger | 78b7d37 | 2018-02-15 09:02:26 +0100 | [diff] [blame] | 75 | #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_LITTLE_ENDIAN) |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 76 | return in_le32(addr); |
| 77 | #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_BIG_ENDIAN) |
| 78 | return in_be32(addr); |
Simon Glass | 9091400 | 2015-05-12 14:55:02 -0600 | [diff] [blame] | 79 | #elif defined(CONFIG_SYS_NS16550_MEM32) |
| 80 | return readl(addr); |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 81 | #elif defined(CONFIG_SYS_BIG_ENDIAN) |
Axel Lin | 20379c1 | 2015-02-28 15:55:36 +0800 | [diff] [blame] | 82 | return readb(addr + (1 << shift) - 1); |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 83 | #else |
| 84 | return readb(addr); |
| 85 | #endif |
| 86 | } |
| 87 | |
Marek Vasut | fa4ce72 | 2016-05-25 02:13:03 +0200 | [diff] [blame] | 88 | #ifdef CONFIG_DM_SERIAL |
| 89 | |
| 90 | #ifndef CONFIG_SYS_NS16550_CLK |
| 91 | #define CONFIG_SYS_NS16550_CLK 0 |
| 92 | #endif |
| 93 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 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; |
Paul Burton | df8ec55 | 2016-05-17 07:43:26 +0100 | [diff] [blame] | 100 | addr = (unsigned char *)plat->base + offset; |
| 101 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 102 | /* |
| 103 | * As far as we know it doesn't make sense to support selection of |
| 104 | * these options at run-time, so use the existing CONFIG options. |
| 105 | */ |
Michal Simek | 59b35dd | 2016-02-16 16:17:49 +0100 | [diff] [blame] | 106 | serial_out_shift(addr + plat->reg_offset, plat->reg_shift, value); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | static int ns16550_readb(NS16550_t port, int offset) |
| 110 | { |
| 111 | struct ns16550_platdata *plat = port->plat; |
| 112 | unsigned char *addr; |
| 113 | |
| 114 | offset *= 1 << plat->reg_shift; |
Paul Burton | df8ec55 | 2016-05-17 07:43:26 +0100 | [diff] [blame] | 115 | addr = (unsigned char *)plat->base + offset; |
Simon Glass | 7657167 | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 116 | |
Michal Simek | 59b35dd | 2016-02-16 16:17:49 +0100 | [diff] [blame] | 117 | return serial_in_shift(addr + plat->reg_offset, plat->reg_shift); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 118 | } |
| 119 | |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 120 | static u32 ns16550_getfcr(NS16550_t port) |
| 121 | { |
| 122 | struct ns16550_platdata *plat = port->plat; |
| 123 | |
| 124 | return plat->fcr; |
| 125 | } |
| 126 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 127 | /* We can clean these up once everything is moved to driver model */ |
| 128 | #define serial_out(value, addr) \ |
Simon Glass | 363e6da | 2015-02-27 22:06:26 -0700 | [diff] [blame] | 129 | ns16550_writeb(com_port, \ |
| 130 | (unsigned char *)addr - (unsigned char *)com_port, value) |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 131 | #define serial_in(addr) \ |
Simon Glass | 363e6da | 2015-02-27 22:06:26 -0700 | [diff] [blame] | 132 | ns16550_readb(com_port, \ |
| 133 | (unsigned char *)addr - (unsigned char *)com_port) |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 134 | #else |
| 135 | static u32 ns16550_getfcr(NS16550_t port) |
| 136 | { |
Heiko Schocher | 17fa032 | 2017-01-18 08:05:49 +0100 | [diff] [blame] | 137 | return UART_FCR_DEFVAL; |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 138 | } |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 139 | #endif |
| 140 | |
Marek Vasut | 03c6f17 | 2016-05-25 02:13:16 +0200 | [diff] [blame] | 141 | int ns16550_calc_divisor(NS16550_t port, int clock, int baudrate) |
Simon Glass | fa54eb1 | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 142 | { |
| 143 | const unsigned int mode_x_div = 16; |
| 144 | |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 145 | return DIV_ROUND_CLOSEST(clock, mode_x_div * baudrate); |
| 146 | } |
| 147 | |
Simon Glass | 8bbe33c | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 148 | static void NS16550_setbrg(NS16550_t com_port, int baud_divisor) |
| 149 | { |
| 150 | serial_out(UART_LCR_BKSE | UART_LCRVAL, &com_port->lcr); |
| 151 | serial_out(baud_divisor & 0xff, &com_port->dll); |
| 152 | serial_out((baud_divisor >> 8) & 0xff, &com_port->dlm); |
| 153 | serial_out(UART_LCRVAL, &com_port->lcr); |
| 154 | } |
| 155 | |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 156 | void NS16550_init(NS16550_t com_port, int baud_divisor) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 157 | { |
Gregoire Gentil | 956a8ba | 2014-11-10 11:04:10 -0800 | [diff] [blame] | 158 | #if (defined(CONFIG_SPL_BUILD) && \ |
| 159 | (defined(CONFIG_OMAP34XX) || defined(CONFIG_OMAP44XX))) |
Manfred Huber | fd2aeac | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 160 | /* |
Gregoire Gentil | 956a8ba | 2014-11-10 11:04:10 -0800 | [diff] [blame] | 161 | * On some OMAP3/OMAP4 devices when UART3 is configured for boot mode |
| 162 | * before SPL starts only THRE bit is set. We have to empty the |
| 163 | * transmitter before initialization starts. |
Manfred Huber | fd2aeac | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 164 | */ |
| 165 | if ((serial_in(&com_port->lsr) & (UART_LSR_TEMT | UART_LSR_THRE)) |
| 166 | == UART_LSR_THRE) { |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 167 | if (baud_divisor != -1) |
| 168 | NS16550_setbrg(com_port, baud_divisor); |
Manfred Huber | fd2aeac | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 169 | serial_out(0, &com_port->mdr1); |
| 170 | } |
| 171 | #endif |
| 172 | |
Scott Wood | cb55b33 | 2012-09-18 18:19:05 -0500 | [diff] [blame] | 173 | while (!(serial_in(&com_port->lsr) & UART_LSR_TEMT)) |
| 174 | ; |
| 175 | |
Prafulla Wadaskar | a160ea0 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 176 | serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier); |
Tom Rini | 89024dd | 2017-05-12 22:33:16 -0400 | [diff] [blame] | 177 | #if defined(CONFIG_ARCH_OMAP2PLUS) |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 178 | serial_out(0x7, &com_port->mdr1); /* mode select reset TL16C750*/ |
wdenk | 945af8d | 2003-07-16 21:53:01 +0000 | [diff] [blame] | 179 | #endif |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 180 | serial_out(UART_MCRVAL, &com_port->mcr); |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 181 | serial_out(ns16550_getfcr(com_port), &com_port->fcr); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 182 | if (baud_divisor != -1) |
| 183 | NS16550_setbrg(com_port, baud_divisor); |
Tom Rini | 89024dd | 2017-05-12 22:33:16 -0400 | [diff] [blame] | 184 | #if defined(CONFIG_ARCH_OMAP2PLUS) || defined(CONFIG_SOC_DA8XX) |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 185 | /* /16 is proper to hit 115200 with 48MHz */ |
| 186 | serial_out(0, &com_port->mdr1); |
Tom Rini | 89024dd | 2017-05-12 22:33:16 -0400 | [diff] [blame] | 187 | #endif |
Khoronzhuk, Ivan | 7c38764 | 2014-07-16 00:59:25 +0300 | [diff] [blame] | 188 | #if defined(CONFIG_SOC_KEYSTONE) |
Vitaly Andrianov | ef509b9 | 2014-04-04 13:16:53 -0400 | [diff] [blame] | 189 | serial_out(UART_REG_VAL_PWREMU_MGMT_UART_ENABLE, &com_port->regC); |
| 190 | #endif |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 191 | } |
| 192 | |
Ron Madrid | f5675aa | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 193 | #ifndef CONFIG_NS16550_MIN_FUNCTIONS |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 194 | void NS16550_reinit(NS16550_t com_port, int baud_divisor) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 195 | { |
Prafulla Wadaskar | a160ea0 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 196 | serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier); |
Simon Glass | 8bbe33c | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 197 | NS16550_setbrg(com_port, 0); |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 198 | serial_out(UART_MCRVAL, &com_port->mcr); |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 199 | serial_out(ns16550_getfcr(com_port), &com_port->fcr); |
Simon Glass | 8bbe33c | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 200 | NS16550_setbrg(com_port, baud_divisor); |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 201 | } |
Ron Madrid | f5675aa | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 202 | #endif /* CONFIG_NS16550_MIN_FUNCTIONS */ |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 203 | |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 204 | void NS16550_putc(NS16550_t com_port, char c) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 205 | { |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 206 | while ((serial_in(&com_port->lsr) & UART_LSR_THRE) == 0) |
| 207 | ; |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 208 | serial_out(c, &com_port->thr); |
Stefan Roese | 1a2d9b3 | 2010-10-12 09:39:45 +0200 | [diff] [blame] | 209 | |
| 210 | /* |
| 211 | * Call watchdog_reset() upon newline. This is done here in putc |
| 212 | * since the environment code uses a single puts() to print the complete |
| 213 | * environment upon "printenv". So we can't put this watchdog call |
| 214 | * in puts(). |
| 215 | */ |
| 216 | if (c == '\n') |
| 217 | WATCHDOG_RESET(); |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 218 | } |
| 219 | |
Ron Madrid | f5675aa | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 220 | #ifndef CONFIG_NS16550_MIN_FUNCTIONS |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 221 | char NS16550_getc(NS16550_t com_port) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 222 | { |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 223 | while ((serial_in(&com_port->lsr) & UART_LSR_DR) == 0) { |
Marek Vasut | f204138 | 2012-09-15 10:25:19 +0200 | [diff] [blame] | 224 | #if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_USB_TTY) |
wdenk | 232c150 | 2004-03-12 00:14:09 +0000 | [diff] [blame] | 225 | extern void usbtty_poll(void); |
| 226 | usbtty_poll(); |
| 227 | #endif |
Ladislav Michl | a1b322a | 2010-02-01 23:34:25 +0100 | [diff] [blame] | 228 | WATCHDOG_RESET(); |
wdenk | 232c150 | 2004-03-12 00:14:09 +0000 | [diff] [blame] | 229 | } |
Graeme Russ | 167cdad | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 230 | return serial_in(&com_port->rbr); |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 231 | } |
| 232 | |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 233 | int NS16550_tstc(NS16550_t com_port) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 234 | { |
Simon Glass | f8df9d0 | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 235 | return (serial_in(&com_port->lsr) & UART_LSR_DR) != 0; |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 236 | } |
| 237 | |
Ron Madrid | f5675aa | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 238 | #endif /* CONFIG_NS16550_MIN_FUNCTIONS */ |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 239 | |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 240 | #ifdef CONFIG_DEBUG_UART_NS16550 |
| 241 | |
| 242 | #include <debug_uart.h> |
| 243 | |
Simon Glass | 97b0597 | 2015-10-18 19:51:23 -0600 | [diff] [blame] | 244 | static inline void _debug_uart_init(void) |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 245 | { |
| 246 | struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE; |
| 247 | int baud_divisor; |
| 248 | |
| 249 | /* |
| 250 | * We copy the code from above because it is already horribly messy. |
| 251 | * Trying to refactor to nicely remove the duplication doesn't seem |
| 252 | * feasible. The better fix is to move all users of this driver to |
| 253 | * driver model. |
| 254 | */ |
Marek Vasut | 03c6f17 | 2016-05-25 02:13:16 +0200 | [diff] [blame] | 255 | baud_divisor = ns16550_calc_divisor(com_port, CONFIG_DEBUG_UART_CLOCK, |
| 256 | CONFIG_BAUDRATE); |
Simon Glass | 6e780c7 | 2015-06-23 15:39:06 -0600 | [diff] [blame] | 257 | serial_dout(&com_port->ier, CONFIG_SYS_NS16550_IER); |
| 258 | serial_dout(&com_port->mcr, UART_MCRVAL); |
Heiko Schocher | 17fa032 | 2017-01-18 08:05:49 +0100 | [diff] [blame] | 259 | serial_dout(&com_port->fcr, UART_FCR_DEFVAL); |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 260 | |
Simon Glass | 6e780c7 | 2015-06-23 15:39:06 -0600 | [diff] [blame] | 261 | serial_dout(&com_port->lcr, UART_LCR_BKSE | UART_LCRVAL); |
| 262 | serial_dout(&com_port->dll, baud_divisor & 0xff); |
| 263 | serial_dout(&com_port->dlm, (baud_divisor >> 8) & 0xff); |
| 264 | serial_dout(&com_port->lcr, UART_LCRVAL); |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | static inline void _debug_uart_putc(int ch) |
| 268 | { |
| 269 | struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE; |
| 270 | |
Simon Glass | 6e780c7 | 2015-06-23 15:39:06 -0600 | [diff] [blame] | 271 | while (!(serial_din(&com_port->lsr) & UART_LSR_THRE)) |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 272 | ; |
Simon Glass | 6e780c7 | 2015-06-23 15:39:06 -0600 | [diff] [blame] | 273 | serial_dout(&com_port->thr, ch); |
Simon Glass | 21d0043 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | DEBUG_UART_FUNCS |
| 277 | |
| 278 | #endif |
| 279 | |
Lokesh Vutla | a52cf08 | 2017-04-22 15:57:25 +0530 | [diff] [blame] | 280 | #ifdef CONFIG_DEBUG_UART_OMAP |
| 281 | |
| 282 | #include <debug_uart.h> |
| 283 | |
| 284 | static inline void _debug_uart_init(void) |
| 285 | { |
| 286 | struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE; |
| 287 | int baud_divisor; |
| 288 | |
| 289 | baud_divisor = ns16550_calc_divisor(com_port, CONFIG_DEBUG_UART_CLOCK, |
| 290 | CONFIG_BAUDRATE); |
| 291 | serial_dout(&com_port->ier, CONFIG_SYS_NS16550_IER); |
| 292 | serial_dout(&com_port->mdr1, 0x7); |
| 293 | serial_dout(&com_port->mcr, UART_MCRVAL); |
| 294 | serial_dout(&com_port->fcr, UART_FCR_DEFVAL); |
| 295 | |
| 296 | serial_dout(&com_port->lcr, UART_LCR_BKSE | UART_LCRVAL); |
| 297 | serial_dout(&com_port->dll, baud_divisor & 0xff); |
| 298 | serial_dout(&com_port->dlm, (baud_divisor >> 8) & 0xff); |
| 299 | serial_dout(&com_port->lcr, UART_LCRVAL); |
| 300 | serial_dout(&com_port->mdr1, 0x0); |
| 301 | } |
| 302 | |
| 303 | static inline void _debug_uart_putc(int ch) |
| 304 | { |
| 305 | struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE; |
| 306 | |
| 307 | while (!(serial_din(&com_port->lsr) & UART_LSR_THRE)) |
| 308 | ; |
| 309 | serial_dout(&com_port->thr, ch); |
| 310 | } |
| 311 | |
| 312 | DEBUG_UART_FUNCS |
| 313 | |
| 314 | #endif |
| 315 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 316 | #ifdef CONFIG_DM_SERIAL |
| 317 | static int ns16550_serial_putc(struct udevice *dev, const char ch) |
| 318 | { |
| 319 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 320 | |
| 321 | if (!(serial_in(&com_port->lsr) & UART_LSR_THRE)) |
| 322 | return -EAGAIN; |
| 323 | serial_out(ch, &com_port->thr); |
| 324 | |
| 325 | /* |
| 326 | * Call watchdog_reset() upon newline. This is done here in putc |
| 327 | * since the environment code uses a single puts() to print the complete |
| 328 | * environment upon "printenv". So we can't put this watchdog call |
| 329 | * in puts(). |
| 330 | */ |
| 331 | if (ch == '\n') |
| 332 | WATCHDOG_RESET(); |
| 333 | |
| 334 | return 0; |
| 335 | } |
| 336 | |
| 337 | static int ns16550_serial_pending(struct udevice *dev, bool input) |
| 338 | { |
| 339 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 340 | |
| 341 | if (input) |
Mario Six | 4dbf9be | 2018-01-15 11:09:49 +0100 | [diff] [blame] | 342 | return (serial_in(&com_port->lsr) & UART_LSR_DR) ? 1 : 0; |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 343 | else |
Mario Six | 4dbf9be | 2018-01-15 11:09:49 +0100 | [diff] [blame] | 344 | return (serial_in(&com_port->lsr) & UART_LSR_THRE) ? 0 : 1; |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 345 | } |
| 346 | |
| 347 | static int ns16550_serial_getc(struct udevice *dev) |
| 348 | { |
Stefan Roese | 7fded0c | 2017-08-16 17:37:15 +0200 | [diff] [blame] | 349 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 350 | |
| 351 | if (!(serial_in(&com_port->lsr) & UART_LSR_DR)) |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 352 | return -EAGAIN; |
| 353 | |
Stefan Roese | 7fded0c | 2017-08-16 17:37:15 +0200 | [diff] [blame] | 354 | return serial_in(&com_port->rbr); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | static int ns16550_serial_setbrg(struct udevice *dev, int baudrate) |
| 358 | { |
| 359 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 360 | struct ns16550_platdata *plat = com_port->plat; |
| 361 | int clock_divisor; |
| 362 | |
| 363 | clock_divisor = ns16550_calc_divisor(com_port, plat->clock, baudrate); |
| 364 | |
| 365 | NS16550_setbrg(com_port, clock_divisor); |
| 366 | |
| 367 | return 0; |
| 368 | } |
| 369 | |
| 370 | int ns16550_serial_probe(struct udevice *dev) |
| 371 | { |
| 372 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 373 | |
Simon Glass | 11c1a87 | 2014-10-22 21:37:05 -0600 | [diff] [blame] | 374 | com_port->plat = dev_get_platdata(dev); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 375 | NS16550_init(com_port, -1); |
| 376 | |
| 377 | return 0; |
| 378 | } |
| 379 | |
Marek Vasut | 79fd928 | 2016-12-01 02:06:30 +0100 | [diff] [blame] | 380 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
| 381 | enum { |
| 382 | PORT_NS16550 = 0, |
Marek Vasut | 0b060ee | 2016-12-01 02:06:31 +0100 | [diff] [blame] | 383 | PORT_JZ4780, |
Marek Vasut | 79fd928 | 2016-12-01 02:06:30 +0100 | [diff] [blame] | 384 | }; |
| 385 | #endif |
| 386 | |
Simon Glass | b2927fb | 2016-07-04 11:58:23 -0600 | [diff] [blame] | 387 | #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA) |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 388 | int ns16550_serial_ofdata_to_platdata(struct udevice *dev) |
| 389 | { |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 390 | struct ns16550_platdata *plat = dev->platdata; |
Marek Vasut | 0b060ee | 2016-12-01 02:06:31 +0100 | [diff] [blame] | 391 | const u32 port_type = dev_get_driver_data(dev); |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 392 | fdt_addr_t addr; |
Masahiro Yamada | 021abf6 | 2016-09-26 20:45:27 +0900 | [diff] [blame] | 393 | struct clk clk; |
| 394 | int err; |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 395 | |
Bin Meng | 3db886a | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 396 | /* try Processor Local Bus device first */ |
Simon Glass | db9f8f6 | 2017-06-12 06:21:56 -0600 | [diff] [blame] | 397 | addr = dev_read_addr(dev); |
Simon Glass | fcc0a87 | 2015-11-29 13:17:54 -0700 | [diff] [blame] | 398 | #if defined(CONFIG_PCI) && defined(CONFIG_DM_PCI) |
Bin Meng | 3db886a | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 399 | if (addr == FDT_ADDR_T_NONE) { |
| 400 | /* then try pci device */ |
| 401 | struct fdt_pci_addr pci_addr; |
| 402 | u32 bar; |
| 403 | int ret; |
| 404 | |
| 405 | /* we prefer to use a memory-mapped register */ |
Simon Glass | e160f7d | 2017-01-17 16:52:55 -0700 | [diff] [blame] | 406 | ret = fdtdec_get_pci_addr(gd->fdt_blob, dev_of_offset(dev), |
Bin Meng | 3db886a | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 407 | FDT_PCI_SPACE_MEM32, "reg", |
| 408 | &pci_addr); |
| 409 | if (ret) { |
| 410 | /* try if there is any i/o-mapped register */ |
| 411 | ret = fdtdec_get_pci_addr(gd->fdt_blob, |
Simon Glass | e160f7d | 2017-01-17 16:52:55 -0700 | [diff] [blame] | 412 | dev_of_offset(dev), |
Bin Meng | 3db886a | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 413 | FDT_PCI_SPACE_IO, |
| 414 | "reg", &pci_addr); |
| 415 | if (ret) |
| 416 | return ret; |
| 417 | } |
| 418 | |
Simon Glass | fcc0a87 | 2015-11-29 13:17:54 -0700 | [diff] [blame] | 419 | ret = fdtdec_get_pci_bar32(dev, &pci_addr, &bar); |
Bin Meng | 3db886a | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 420 | if (ret) |
| 421 | return ret; |
| 422 | |
| 423 | addr = bar; |
| 424 | } |
| 425 | #endif |
| 426 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 427 | if (addr == FDT_ADDR_T_NONE) |
| 428 | return -EINVAL; |
| 429 | |
Paul Burton | df8ec55 | 2016-05-17 07:43:26 +0100 | [diff] [blame] | 430 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
Simon Glass | 167efe0 | 2014-10-22 21:37:04 -0600 | [diff] [blame] | 431 | plat->base = addr; |
Paul Burton | df8ec55 | 2016-05-17 07:43:26 +0100 | [diff] [blame] | 432 | #else |
| 433 | plat->base = (unsigned long)map_physmem(addr, 0, MAP_NOCACHE); |
| 434 | #endif |
| 435 | |
Philipp Tomsich | 3d40479 | 2017-06-07 18:46:02 +0200 | [diff] [blame] | 436 | plat->reg_offset = dev_read_u32_default(dev, "reg-offset", 0); |
| 437 | plat->reg_shift = dev_read_u32_default(dev, "reg-shift", 0); |
Paul Burton | 50fce1d | 2016-09-08 07:47:29 +0100 | [diff] [blame] | 438 | |
| 439 | err = clk_get_by_index(dev, 0, &clk); |
| 440 | if (!err) { |
| 441 | err = clk_get_rate(&clk); |
| 442 | if (!IS_ERR_VALUE(err)) |
| 443 | plat->clock = err; |
Alexandre Courbot | ab895d6 | 2016-09-30 17:37:00 +0900 | [diff] [blame] | 444 | } else if (err != -ENOENT && err != -ENODEV && err != -ENOSYS) { |
Paul Burton | 50fce1d | 2016-09-08 07:47:29 +0100 | [diff] [blame] | 445 | debug("ns16550 failed to get clock\n"); |
| 446 | return err; |
| 447 | } |
| 448 | |
| 449 | if (!plat->clock) |
Philipp Tomsich | 3d40479 | 2017-06-07 18:46:02 +0200 | [diff] [blame] | 450 | plat->clock = dev_read_u32_default(dev, "clock-frequency", |
| 451 | CONFIG_SYS_NS16550_CLK); |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 452 | if (!plat->clock) { |
| 453 | debug("ns16550 clock not defined\n"); |
| 454 | return -EINVAL; |
| 455 | } |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 456 | |
Heiko Schocher | 17fa032 | 2017-01-18 08:05:49 +0100 | [diff] [blame] | 457 | plat->fcr = UART_FCR_DEFVAL; |
Marek Vasut | 0b060ee | 2016-12-01 02:06:31 +0100 | [diff] [blame] | 458 | if (port_type == PORT_JZ4780) |
| 459 | plat->fcr |= UART_FCR_UME; |
Marek Vasut | 65f8380 | 2016-12-01 02:06:29 +0100 | [diff] [blame] | 460 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 461 | return 0; |
| 462 | } |
Simon Glass | 11c1a87 | 2014-10-22 21:37:05 -0600 | [diff] [blame] | 463 | #endif |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 464 | |
| 465 | const struct dm_serial_ops ns16550_serial_ops = { |
| 466 | .putc = ns16550_serial_putc, |
| 467 | .pending = ns16550_serial_pending, |
| 468 | .getc = ns16550_serial_getc, |
| 469 | .setbrg = ns16550_serial_setbrg, |
| 470 | }; |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 471 | |
Alexandru Gagniuc | 6f8c351 | 2017-03-27 12:54:19 -0700 | [diff] [blame] | 472 | #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA) |
Thomas Chou | cc4228f | 2015-12-14 20:45:09 +0800 | [diff] [blame] | 473 | /* |
| 474 | * Please consider existing compatible strings before adding a new |
| 475 | * one to keep this table compact. Or you may add a generic "ns16550" |
| 476 | * compatible string to your dts. |
| 477 | */ |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 478 | static const struct udevice_id ns16550_serial_ids[] = { |
Marek Vasut | 79fd928 | 2016-12-01 02:06:30 +0100 | [diff] [blame] | 479 | { .compatible = "ns16550", .data = PORT_NS16550 }, |
| 480 | { .compatible = "ns16550a", .data = PORT_NS16550 }, |
Marek Vasut | 0b060ee | 2016-12-01 02:06:31 +0100 | [diff] [blame] | 481 | { .compatible = "ingenic,jz4780-uart", .data = PORT_JZ4780 }, |
Marek Vasut | 79fd928 | 2016-12-01 02:06:30 +0100 | [diff] [blame] | 482 | { .compatible = "nvidia,tegra20-uart", .data = PORT_NS16550 }, |
| 483 | { .compatible = "snps,dw-apb-uart", .data = PORT_NS16550 }, |
| 484 | { .compatible = "ti,omap2-uart", .data = PORT_NS16550 }, |
| 485 | { .compatible = "ti,omap3-uart", .data = PORT_NS16550 }, |
| 486 | { .compatible = "ti,omap4-uart", .data = PORT_NS16550 }, |
| 487 | { .compatible = "ti,am3352-uart", .data = PORT_NS16550 }, |
| 488 | { .compatible = "ti,am4372-uart", .data = PORT_NS16550 }, |
| 489 | { .compatible = "ti,dra742-uart", .data = PORT_NS16550 }, |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 490 | {} |
| 491 | }; |
Alexandru Gagniuc | 6f8c351 | 2017-03-27 12:54:19 -0700 | [diff] [blame] | 492 | #endif /* OF_CONTROL && !OF_PLATDATA */ |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 493 | |
Simon Glass | b7e2983 | 2015-12-13 21:36:59 -0700 | [diff] [blame] | 494 | #if CONFIG_IS_ENABLED(SERIAL_PRESENT) |
Alexandru Gagniuc | 6f8c351 | 2017-03-27 12:54:19 -0700 | [diff] [blame] | 495 | |
| 496 | /* TODO(sjg@chromium.org): Integrate this into a macro like CONFIG_IS_ENABLED */ |
| 497 | #if !defined(CONFIG_TPL_BUILD) || defined(CONFIG_TPL_DM_SERIAL) |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 498 | U_BOOT_DRIVER(ns16550_serial) = { |
| 499 | .name = "ns16550_serial", |
| 500 | .id = UCLASS_SERIAL, |
Alexandru Gagniuc | 6f8c351 | 2017-03-27 12:54:19 -0700 | [diff] [blame] | 501 | #if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA) |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 502 | .of_match = ns16550_serial_ids, |
| 503 | .ofdata_to_platdata = ns16550_serial_ofdata_to_platdata, |
| 504 | .platdata_auto_alloc_size = sizeof(struct ns16550_platdata), |
| 505 | #endif |
| 506 | .priv_auto_alloc_size = sizeof(struct NS16550), |
| 507 | .probe = ns16550_serial_probe, |
| 508 | .ops = &ns16550_serial_ops, |
Simon Glass | b7e5a64 | 2015-12-04 08:58:38 -0700 | [diff] [blame] | 509 | .flags = DM_FLAG_PRE_RELOC, |
Thomas Chou | 8e62d32 | 2015-11-19 21:48:05 +0800 | [diff] [blame] | 510 | }; |
Simon Glass | b7e2983 | 2015-12-13 21:36:59 -0700 | [diff] [blame] | 511 | #endif |
Alexandru Gagniuc | 6f8c351 | 2017-03-27 12:54:19 -0700 | [diff] [blame] | 512 | #endif /* SERIAL_PRESENT */ |
| 513 | |
Simon Glass | 12e431b | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 514 | #endif /* CONFIG_DM_SERIAL */ |