wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 1 | /* |
| 2 | * COM1 NS16550 support |
Stefan Roese | 88fbf93 | 2010-04-15 16:07:28 +0200 | [diff] [blame] | 3 | * originally from linux source (arch/powerpc/boot/ns16550.c) |
Jean-Christophe PLAGNIOL-VILLARD | 0383694 | 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 | e98e01e | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 7 | #include <common.h> |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 8 | #include <dm.h> |
| 9 | #include <errno.h> |
| 10 | #include <fdtdec.h> |
Joe Hershberger | 65b905b | 2015-03-22 17:08:59 -0500 | [diff] [blame] | 11 | #include <mapmem.h> |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 12 | #include <ns16550.h> |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 13 | #include <serial.h> |
Ladislav Michl | cc29442 | 2010-02-01 23:34:25 +0100 | [diff] [blame] | 14 | #include <watchdog.h> |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 15 | #include <linux/types.h> |
| 16 | #include <asm/io.h> |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 17 | |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 18 | DECLARE_GLOBAL_DATA_PTR; |
| 19 | |
Detlev Zundel | 166fb54 | 2009-04-03 11:53:01 +0200 | [diff] [blame] | 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 */ |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 26 | |
| 27 | #ifndef CONFIG_DM_SERIAL |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 28 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
Simon Glass | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 29 | #define serial_out(x, y) outb(x, (ulong)y) |
| 30 | #define serial_in(y) inb((ulong)y) |
Dave Aldridge | a51bebc | 2011-09-01 22:47:14 +0000 | [diff] [blame] | 31 | #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE > 0) |
Simon Glass | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 32 | #define serial_out(x, y) out_be32(y, x) |
| 33 | #define serial_in(y) in_be32(y) |
Dave Aldridge | a51bebc | 2011-09-01 22:47:14 +0000 | [diff] [blame] | 34 | #elif defined(CONFIG_SYS_NS16550_MEM32) && (CONFIG_SYS_NS16550_REG_SIZE < 0) |
Simon Glass | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 35 | #define serial_out(x, y) out_le32(y, x) |
| 36 | #define serial_in(y) in_le32(y) |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 37 | #else |
Simon Glass | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 38 | #define serial_out(x, y) writeb(x, y) |
| 39 | #define serial_in(y) readb(y) |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 40 | #endif |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 41 | #endif /* !CONFIG_DM_SERIAL */ |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 42 | |
Khoronzhuk, Ivan | 8090298 | 2014-07-16 00:59:25 +0300 | [diff] [blame] | 43 | #if defined(CONFIG_SOC_KEYSTONE) |
Vitaly Andrianov | 7bcf4d6 | 2014-04-04 13:16:53 -0400 | [diff] [blame] | 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)) |
Karicheri, Muralidharan | cbc0888 | 2014-04-09 15:38:46 -0400 | [diff] [blame] | 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 |
Vitaly Andrianov | 7bcf4d6 | 2014-04-04 13:16:53 -0400 | [diff] [blame] | 52 | #endif |
| 53 | |
Prafulla Wadaskar | 6621637 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 54 | #ifndef CONFIG_SYS_NS16550_IER |
| 55 | #define CONFIG_SYS_NS16550_IER 0x00 |
| 56 | #endif /* CONFIG_SYS_NS16550_IER */ |
| 57 | |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 58 | #ifdef CONFIG_DM_SERIAL |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 59 | |
Simon Glass | 6aba4fd | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 60 | static inline void serial_out_shift(unsigned char *addr, int shift, int value) |
| 61 | { |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 62 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
Simon Glass | 96e230b | 2014-10-10 07:49:13 -0600 | [diff] [blame] | 63 | outb(value, (ulong)addr); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 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_BIG_ENDIAN) |
Simon Glass | 6aba4fd | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 69 | writeb(value, addr + (1 << shift) - 1); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 70 | #else |
| 71 | writeb(value, addr); |
| 72 | #endif |
| 73 | } |
| 74 | |
Simon Glass | 6aba4fd | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 75 | static inline int serial_in_shift(unsigned char *addr, int shift) |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 76 | { |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 77 | #ifdef CONFIG_SYS_NS16550_PORT_MAPPED |
Simon Glass | 96e230b | 2014-10-10 07:49:13 -0600 | [diff] [blame] | 78 | return inb((ulong)addr); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 79 | #elif defined(CONFIG_SYS_NS16550_MEM32) && !defined(CONFIG_SYS_BIG_ENDIAN) |
| 80 | return in_le32(addr); |
| 81 | #elif defined(CONFIG_SYS_NS16550_MEM32) && defined(CONFIG_SYS_BIG_ENDIAN) |
| 82 | return in_be32(addr); |
| 83 | #elif defined(CONFIG_SYS_BIG_ENDIAN) |
Axel Lin | b5c372d | 2015-02-28 15:55:36 +0800 | [diff] [blame] | 84 | return readb(addr + (1 << shift) - 1); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 85 | #else |
| 86 | return readb(addr); |
| 87 | #endif |
| 88 | } |
| 89 | |
Simon Glass | 6aba4fd | 2015-01-26 18:27:08 -0700 | [diff] [blame] | 90 | static void ns16550_writeb(NS16550_t port, int offset, int value) |
| 91 | { |
| 92 | struct ns16550_platdata *plat = port->plat; |
| 93 | unsigned char *addr; |
| 94 | |
| 95 | offset *= 1 << plat->reg_shift; |
| 96 | addr = map_sysmem(plat->base, 0) + offset; |
| 97 | /* |
| 98 | * As far as we know it doesn't make sense to support selection of |
| 99 | * these options at run-time, so use the existing CONFIG options. |
| 100 | */ |
| 101 | serial_out_shift(addr, plat->reg_shift, value); |
| 102 | } |
| 103 | |
| 104 | static int ns16550_readb(NS16550_t port, int offset) |
| 105 | { |
| 106 | struct ns16550_platdata *plat = port->plat; |
| 107 | unsigned char *addr; |
| 108 | |
| 109 | offset *= 1 << plat->reg_shift; |
| 110 | addr = map_sysmem(plat->base, 0) + offset; |
| 111 | |
| 112 | return serial_in_shift(addr, plat->reg_shift); |
| 113 | } |
| 114 | |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 115 | /* We can clean these up once everything is moved to driver model */ |
| 116 | #define serial_out(value, addr) \ |
| 117 | ns16550_writeb(com_port, addr - (unsigned char *)com_port, value) |
| 118 | #define serial_in(addr) \ |
| 119 | ns16550_readb(com_port, addr - (unsigned char *)com_port) |
| 120 | #endif |
| 121 | |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 122 | static inline int calc_divisor(NS16550_t port, int clock, int baudrate) |
Simon Glass | e98e01e | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 123 | { |
| 124 | const unsigned int mode_x_div = 16; |
| 125 | |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 126 | return DIV_ROUND_CLOSEST(clock, mode_x_div * baudrate); |
| 127 | } |
| 128 | |
| 129 | int ns16550_calc_divisor(NS16550_t port, int clock, int baudrate) |
| 130 | { |
Simon Glass | e98e01e | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 131 | #ifdef CONFIG_OMAP1510 |
| 132 | /* If can't cleanly clock 115200 set div to 1 */ |
| 133 | if ((clock == 12000000) && (baudrate == 115200)) { |
| 134 | port->osc_12m_sel = OSC_12M_SEL; /* enable 6.5 * divisor */ |
| 135 | return 1; /* return 1 for base divisor */ |
| 136 | } |
| 137 | port->osc_12m_sel = 0; /* clear if previsouly set */ |
| 138 | #endif |
| 139 | |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 140 | return calc_divisor(port, clock, baudrate); |
Simon Glass | e98e01e | 2014-09-04 16:27:32 -0600 | [diff] [blame] | 141 | } |
| 142 | |
Simon Glass | c31ebfe | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 143 | static void NS16550_setbrg(NS16550_t com_port, int baud_divisor) |
| 144 | { |
| 145 | serial_out(UART_LCR_BKSE | UART_LCRVAL, &com_port->lcr); |
| 146 | serial_out(baud_divisor & 0xff, &com_port->dll); |
| 147 | serial_out((baud_divisor >> 8) & 0xff, &com_port->dlm); |
| 148 | serial_out(UART_LCRVAL, &com_port->lcr); |
| 149 | } |
| 150 | |
Simon Glass | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 151 | void NS16550_init(NS16550_t com_port, int baud_divisor) |
wdenk | e85390d | 2002-04-01 14:29:03 +0000 | [diff] [blame] | 152 | { |
Gregoire Gentil | 6b05d0a | 2014-11-10 11:04:10 -0800 | [diff] [blame] | 153 | #if (defined(CONFIG_SPL_BUILD) && \ |
| 154 | (defined(CONFIG_OMAP34XX) || defined(CONFIG_OMAP44XX))) |
Manfred Huber | f9b8ae3 | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 155 | /* |
Gregoire Gentil | 6b05d0a | 2014-11-10 11:04:10 -0800 | [diff] [blame] | 156 | * On some OMAP3/OMAP4 devices when UART3 is configured for boot mode |
| 157 | * before SPL starts only THRE bit is set. We have to empty the |
| 158 | * transmitter before initialization starts. |
Manfred Huber | f9b8ae3 | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 159 | */ |
| 160 | if ((serial_in(&com_port->lsr) & (UART_LSR_TEMT | UART_LSR_THRE)) |
| 161 | == UART_LSR_THRE) { |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 162 | if (baud_divisor != -1) |
| 163 | NS16550_setbrg(com_port, baud_divisor); |
Manfred Huber | f9b8ae3 | 2013-03-29 02:52:36 +0000 | [diff] [blame] | 164 | serial_out(0, &com_port->mdr1); |
| 165 | } |
| 166 | #endif |
| 167 | |
Scott Wood | 6c6f061 | 2012-09-18 18:19:05 -0500 | [diff] [blame] | 168 | while (!(serial_in(&com_port->lsr) & UART_LSR_TEMT)) |
| 169 | ; |
| 170 | |
Prafulla Wadaskar | 6621637 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 171 | serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier); |
Tom Rini | fc695e3 | 2013-12-20 11:19:33 -0500 | [diff] [blame] | 172 | #if defined(CONFIG_OMAP) || defined(CONFIG_AM33XX) || \ |
| 173 | defined(CONFIG_TI81XX) || defined(CONFIG_AM43XX) |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 174 | serial_out(0x7, &com_port->mdr1); /* mode select reset TL16C750*/ |
wdenk | 21136db | 2003-07-16 21:53:01 +0000 | [diff] [blame] | 175 | #endif |
Simon Glass | c31ebfe | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 176 | NS16550_setbrg(com_port, 0); |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 177 | serial_out(UART_MCRVAL, &com_port->mcr); |
| 178 | serial_out(UART_FCRVAL, &com_port->fcr); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 179 | if (baud_divisor != -1) |
| 180 | NS16550_setbrg(com_port, baud_divisor); |
Masahiro Yamada | 641e3ce | 2014-07-30 19:11:41 +0900 | [diff] [blame] | 181 | #if defined(CONFIG_OMAP) || \ |
Matt Porter | 7967b1a | 2013-03-15 10:07:09 +0000 | [diff] [blame] | 182 | defined(CONFIG_AM33XX) || defined(CONFIG_SOC_DA8XX) || \ |
TENART Antoine | a6be77c | 2013-07-02 12:05:58 +0200 | [diff] [blame] | 183 | defined(CONFIG_TI81XX) || defined(CONFIG_AM43XX) |
Chandan Nath | 7d74410 | 2011-10-14 02:58:26 +0000 | [diff] [blame] | 184 | |
Simon Glass | dd5497c | 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); |
Mike Frysinger | d0e9786 | 2009-02-11 20:26:52 -0500 | [diff] [blame] | 187 | #endif /* CONFIG_OMAP */ |
Khoronzhuk, Ivan | 8090298 | 2014-07-16 00:59:25 +0300 | [diff] [blame] | 188 | #if defined(CONFIG_SOC_KEYSTONE) |
Vitaly Andrianov | 7bcf4d6 | 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 | dfa028a | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 193 | #ifndef CONFIG_NS16550_MIN_FUNCTIONS |
Simon Glass | dd5497c | 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 | 6621637 | 2010-10-27 21:58:31 +0530 | [diff] [blame] | 196 | serial_out(CONFIG_SYS_NS16550_IER, &com_port->ier); |
Simon Glass | c31ebfe | 2014-09-04 16:27:33 -0600 | [diff] [blame] | 197 | NS16550_setbrg(com_port, 0); |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 198 | serial_out(UART_MCRVAL, &com_port->mcr); |
| 199 | serial_out(UART_FCRVAL, &com_port->fcr); |
Simon Glass | c31ebfe | 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 | dfa028a | 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 | dd5497c | 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 | dd5497c | 2011-10-15 19:14:09 +0000 | [diff] [blame] | 206 | while ((serial_in(&com_port->lsr) & UART_LSR_THRE) == 0) |
| 207 | ; |
Graeme Russ | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 208 | serial_out(c, &com_port->thr); |
Stefan Roese | 57b9988 | 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 | dfa028a | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 220 | #ifndef CONFIG_NS16550_MIN_FUNCTIONS |
Simon Glass | dd5497c | 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 | 14f06e6 | 2010-04-24 00:05:46 +1000 | [diff] [blame] | 223 | while ((serial_in(&com_port->lsr) & UART_LSR_DR) == 0) { |
Marek Vasut | 9e1fca9 | 2012-09-15 10:25:19 +0200 | [diff] [blame] | 224 | #if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_USB_TTY) |
wdenk | 29e7f5a | 2004-03-12 00:14:09 +0000 | [diff] [blame] | 225 | extern void usbtty_poll(void); |
| 226 | usbtty_poll(); |
| 227 | #endif |
Ladislav Michl | cc29442 | 2010-02-01 23:34:25 +0100 | [diff] [blame] | 228 | WATCHDOG_RESET(); |
wdenk | 29e7f5a | 2004-03-12 00:14:09 +0000 | [diff] [blame] | 229 | } |
Graeme Russ | 14f06e6 | 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 | dd5497c | 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 | dd5497c | 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 | dfa028a | 2009-02-18 14:30:44 -0800 | [diff] [blame] | 238 | #endif /* CONFIG_NS16550_MIN_FUNCTIONS */ |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 239 | |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 240 | #ifdef CONFIG_DEBUG_UART_NS16550 |
| 241 | |
| 242 | #include <debug_uart.h> |
| 243 | |
| 244 | void debug_uart_init(void) |
| 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 | */ |
| 255 | baud_divisor = calc_divisor(com_port, CONFIG_DEBUG_UART_CLOCK, |
| 256 | CONFIG_BAUDRATE); |
Simon Glass | 5411129 | 2015-02-27 22:06:25 -0700 | [diff] [blame^] | 257 | baud_divisor = 13; |
| 258 | serial_out_shift(&com_port->ier, CONFIG_DEBUG_UART_SHIFT, |
| 259 | CONFIG_SYS_NS16550_IER); |
| 260 | serial_out_shift(&com_port->mcr, CONFIG_DEBUG_UART_SHIFT, UART_MCRVAL); |
| 261 | serial_out_shift(&com_port->fcr, CONFIG_DEBUG_UART_SHIFT, UART_FCRVAL); |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 262 | |
Simon Glass | 5411129 | 2015-02-27 22:06:25 -0700 | [diff] [blame^] | 263 | serial_out_shift(&com_port->lcr, CONFIG_DEBUG_UART_SHIFT, |
| 264 | UART_LCR_BKSE | UART_LCRVAL); |
| 265 | serial_out_shift(&com_port->dll, CONFIG_DEBUG_UART_SHIFT, |
| 266 | baud_divisor & 0xff); |
| 267 | serial_out_shift(&com_port->dlm, CONFIG_DEBUG_UART_SHIFT, |
| 268 | (baud_divisor >> 8) & 0xff); |
| 269 | serial_out_shift(&com_port->lcr, CONFIG_DEBUG_UART_SHIFT, |
| 270 | UART_LCRVAL); |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 271 | } |
| 272 | |
| 273 | static inline void _debug_uart_putc(int ch) |
| 274 | { |
| 275 | struct NS16550 *com_port = (struct NS16550 *)CONFIG_DEBUG_UART_BASE; |
| 276 | |
| 277 | while (!(serial_in_shift(&com_port->lsr, 0) & UART_LSR_THRE)) |
| 278 | ; |
Simon Glass | 5411129 | 2015-02-27 22:06:25 -0700 | [diff] [blame^] | 279 | serial_out_shift(&com_port->thr, CONFIG_DEBUG_UART_SHIFT, ch); |
Simon Glass | 27afb52 | 2015-01-26 18:27:09 -0700 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | DEBUG_UART_FUNCS |
| 283 | |
| 284 | #endif |
| 285 | |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 286 | #ifdef CONFIG_DM_SERIAL |
| 287 | static int ns16550_serial_putc(struct udevice *dev, const char ch) |
| 288 | { |
| 289 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 290 | |
| 291 | if (!(serial_in(&com_port->lsr) & UART_LSR_THRE)) |
| 292 | return -EAGAIN; |
| 293 | serial_out(ch, &com_port->thr); |
| 294 | |
| 295 | /* |
| 296 | * Call watchdog_reset() upon newline. This is done here in putc |
| 297 | * since the environment code uses a single puts() to print the complete |
| 298 | * environment upon "printenv". So we can't put this watchdog call |
| 299 | * in puts(). |
| 300 | */ |
| 301 | if (ch == '\n') |
| 302 | WATCHDOG_RESET(); |
| 303 | |
| 304 | return 0; |
| 305 | } |
| 306 | |
| 307 | static int ns16550_serial_pending(struct udevice *dev, bool input) |
| 308 | { |
| 309 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 310 | |
| 311 | if (input) |
| 312 | return serial_in(&com_port->lsr) & UART_LSR_DR ? 1 : 0; |
| 313 | else |
| 314 | return serial_in(&com_port->lsr) & UART_LSR_THRE ? 0 : 1; |
| 315 | } |
| 316 | |
| 317 | static int ns16550_serial_getc(struct udevice *dev) |
| 318 | { |
| 319 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 320 | |
Simon Glass | ddb958c | 2014-10-22 21:37:03 -0600 | [diff] [blame] | 321 | if (!(serial_in(&com_port->lsr) & UART_LSR_DR)) |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 322 | return -EAGAIN; |
| 323 | |
| 324 | return serial_in(&com_port->rbr); |
| 325 | } |
| 326 | |
| 327 | static int ns16550_serial_setbrg(struct udevice *dev, int baudrate) |
| 328 | { |
| 329 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 330 | struct ns16550_platdata *plat = com_port->plat; |
| 331 | int clock_divisor; |
| 332 | |
| 333 | clock_divisor = ns16550_calc_divisor(com_port, plat->clock, baudrate); |
| 334 | |
| 335 | NS16550_setbrg(com_port, clock_divisor); |
| 336 | |
| 337 | return 0; |
| 338 | } |
| 339 | |
| 340 | int ns16550_serial_probe(struct udevice *dev) |
| 341 | { |
| 342 | struct NS16550 *const com_port = dev_get_priv(dev); |
| 343 | |
Simon Glass | 3bf04f3 | 2014-10-22 21:37:05 -0600 | [diff] [blame] | 344 | com_port->plat = dev_get_platdata(dev); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 345 | NS16550_init(com_port, -1); |
| 346 | |
| 347 | return 0; |
| 348 | } |
| 349 | |
Simon Glass | 3bf04f3 | 2014-10-22 21:37:05 -0600 | [diff] [blame] | 350 | #ifdef CONFIG_OF_CONTROL |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 351 | int ns16550_serial_ofdata_to_platdata(struct udevice *dev) |
| 352 | { |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 353 | struct ns16550_platdata *plat = dev->platdata; |
| 354 | fdt_addr_t addr; |
| 355 | |
Bin Meng | 0203c1c | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 356 | /* try Processor Local Bus device first */ |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 357 | addr = fdtdec_get_addr(gd->fdt_blob, dev->of_offset, "reg"); |
Bin Meng | 0203c1c | 2014-12-31 16:05:12 +0800 | [diff] [blame] | 358 | #ifdef CONFIG_PCI |
| 359 | if (addr == FDT_ADDR_T_NONE) { |
| 360 | /* then try pci device */ |
| 361 | struct fdt_pci_addr pci_addr; |
| 362 | u32 bar; |
| 363 | int ret; |
| 364 | |
| 365 | /* we prefer to use a memory-mapped register */ |
| 366 | ret = fdtdec_get_pci_addr(gd->fdt_blob, dev->of_offset, |
| 367 | FDT_PCI_SPACE_MEM32, "reg", |
| 368 | &pci_addr); |
| 369 | if (ret) { |
| 370 | /* try if there is any i/o-mapped register */ |
| 371 | ret = fdtdec_get_pci_addr(gd->fdt_blob, |
| 372 | dev->of_offset, |
| 373 | FDT_PCI_SPACE_IO, |
| 374 | "reg", &pci_addr); |
| 375 | if (ret) |
| 376 | return ret; |
| 377 | } |
| 378 | |
| 379 | ret = fdtdec_get_pci_bar32(gd->fdt_blob, dev->of_offset, |
| 380 | &pci_addr, &bar); |
| 381 | if (ret) |
| 382 | return ret; |
| 383 | |
| 384 | addr = bar; |
| 385 | } |
| 386 | #endif |
| 387 | |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 388 | if (addr == FDT_ADDR_T_NONE) |
| 389 | return -EINVAL; |
| 390 | |
Simon Glass | 2546394 | 2014-10-22 21:37:04 -0600 | [diff] [blame] | 391 | plat->base = addr; |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 392 | plat->reg_shift = fdtdec_get_int(gd->fdt_blob, dev->of_offset, |
| 393 | "reg-shift", 1); |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 394 | |
| 395 | return 0; |
| 396 | } |
Simon Glass | 3bf04f3 | 2014-10-22 21:37:05 -0600 | [diff] [blame] | 397 | #endif |
Simon Glass | 79a9da3 | 2014-09-04 16:27:34 -0600 | [diff] [blame] | 398 | |
| 399 | const struct dm_serial_ops ns16550_serial_ops = { |
| 400 | .putc = ns16550_serial_putc, |
| 401 | .pending = ns16550_serial_pending, |
| 402 | .getc = ns16550_serial_getc, |
| 403 | .setbrg = ns16550_serial_setbrg, |
| 404 | }; |
| 405 | #endif /* CONFIG_DM_SERIAL */ |