serial_ar933x.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015-2016 Wills Wang <wills.wang@live.com>
  4. */
  5. #include <common.h>
  6. #include <clock_legacy.h>
  7. #include <dm.h>
  8. #include <div64.h>
  9. #include <errno.h>
  10. #include <serial.h>
  11. #include <asm/io.h>
  12. #include <asm/addrspace.h>
  13. #include <asm/types.h>
  14. #include <dm/pinctrl.h>
  15. #include <mach/ar71xx_regs.h>
  16. #define AR933X_UART_DATA_REG 0x00
  17. #define AR933X_UART_CS_REG 0x04
  18. #define AR933X_UART_CLK_REG 0x08
  19. #define AR933X_UART_DATA_TX_RX_MASK 0xff
  20. #define AR933X_UART_DATA_RX_CSR BIT(8)
  21. #define AR933X_UART_DATA_TX_CSR BIT(9)
  22. #define AR933X_UART_CS_IF_MODE_S 2
  23. #define AR933X_UART_CS_IF_MODE_M 0x3
  24. #define AR933X_UART_CS_IF_MODE_DTE 1
  25. #define AR933X_UART_CS_IF_MODE_DCE 2
  26. #define AR933X_UART_CS_TX_RDY_ORIDE BIT(7)
  27. #define AR933X_UART_CS_RX_RDY_ORIDE BIT(8)
  28. #define AR933X_UART_CLK_STEP_M 0xffff
  29. #define AR933X_UART_CLK_SCALE_M 0xfff
  30. #define AR933X_UART_CLK_SCALE_S 16
  31. #define AR933X_UART_CLK_STEP_S 0
  32. struct ar933x_serial_priv {
  33. void __iomem *regs;
  34. };
  35. /*
  36. * Baudrate algorithm come from Linux/drivers/tty/serial/ar933x_uart.c
  37. * baudrate = (clk / (scale + 1)) * (step * (1 / 2^17))
  38. */
  39. static u32 ar933x_serial_get_baud(u32 clk, u32 scale, u32 step)
  40. {
  41. u64 t;
  42. u32 div;
  43. div = (2 << 16) * (scale + 1);
  44. t = clk;
  45. t *= step;
  46. t += (div / 2);
  47. do_div(t, div);
  48. return t;
  49. }
  50. static void ar933x_serial_get_scale_step(u32 clk, u32 baud,
  51. u32 *scale, u32 *step)
  52. {
  53. u32 tscale, baudrate;
  54. long min_diff;
  55. *scale = 0;
  56. *step = 0;
  57. min_diff = baud;
  58. for (tscale = 0; tscale < AR933X_UART_CLK_SCALE_M; tscale++) {
  59. u64 tstep;
  60. int diff;
  61. tstep = baud * (tscale + 1);
  62. tstep *= (2 << 16);
  63. do_div(tstep, clk);
  64. if (tstep > AR933X_UART_CLK_STEP_M)
  65. break;
  66. baudrate = ar933x_serial_get_baud(clk, tscale, tstep);
  67. diff = abs(baudrate - baud);
  68. if (diff < min_diff) {
  69. min_diff = diff;
  70. *scale = tscale;
  71. *step = tstep;
  72. }
  73. }
  74. }
  75. static int ar933x_serial_setbrg(struct udevice *dev, int baudrate)
  76. {
  77. struct ar933x_serial_priv *priv = dev_get_priv(dev);
  78. u32 val, scale, step;
  79. val = get_serial_clock();
  80. ar933x_serial_get_scale_step(val, baudrate, &scale, &step);
  81. val = (scale & AR933X_UART_CLK_SCALE_M)
  82. << AR933X_UART_CLK_SCALE_S;
  83. val |= (step & AR933X_UART_CLK_STEP_M)
  84. << AR933X_UART_CLK_STEP_S;
  85. writel(val, priv->regs + AR933X_UART_CLK_REG);
  86. return 0;
  87. }
  88. static int ar933x_serial_putc(struct udevice *dev, const char c)
  89. {
  90. struct ar933x_serial_priv *priv = dev_get_priv(dev);
  91. u32 data;
  92. data = readl(priv->regs + AR933X_UART_DATA_REG);
  93. if (!(data & AR933X_UART_DATA_TX_CSR))
  94. return -EAGAIN;
  95. data = (u32)c | AR933X_UART_DATA_TX_CSR;
  96. writel(data, priv->regs + AR933X_UART_DATA_REG);
  97. return 0;
  98. }
  99. static int ar933x_serial_getc(struct udevice *dev)
  100. {
  101. struct ar933x_serial_priv *priv = dev_get_priv(dev);
  102. u32 data;
  103. data = readl(priv->regs + AR933X_UART_DATA_REG);
  104. if (!(data & AR933X_UART_DATA_RX_CSR))
  105. return -EAGAIN;
  106. writel(AR933X_UART_DATA_RX_CSR, priv->regs + AR933X_UART_DATA_REG);
  107. return data & AR933X_UART_DATA_TX_RX_MASK;
  108. }
  109. static int ar933x_serial_pending(struct udevice *dev, bool input)
  110. {
  111. struct ar933x_serial_priv *priv = dev_get_priv(dev);
  112. u32 data;
  113. data = readl(priv->regs + AR933X_UART_DATA_REG);
  114. if (input)
  115. return (data & AR933X_UART_DATA_RX_CSR) ? 1 : 0;
  116. else
  117. return (data & AR933X_UART_DATA_TX_CSR) ? 0 : 1;
  118. }
  119. static int ar933x_serial_probe(struct udevice *dev)
  120. {
  121. struct ar933x_serial_priv *priv = dev_get_priv(dev);
  122. fdt_addr_t addr;
  123. u32 val;
  124. addr = devfdt_get_addr(dev);
  125. if (addr == FDT_ADDR_T_NONE)
  126. return -EINVAL;
  127. priv->regs = map_physmem(addr, AR933X_UART_SIZE,
  128. MAP_NOCACHE);
  129. /*
  130. * UART controller configuration:
  131. * - no DMA
  132. * - no interrupt
  133. * - DCE mode
  134. * - no flow control
  135. * - set RX ready oride
  136. * - set TX ready oride
  137. */
  138. val = (AR933X_UART_CS_IF_MODE_DCE << AR933X_UART_CS_IF_MODE_S) |
  139. AR933X_UART_CS_TX_RDY_ORIDE | AR933X_UART_CS_RX_RDY_ORIDE;
  140. writel(val, priv->regs + AR933X_UART_CS_REG);
  141. return 0;
  142. }
  143. static const struct dm_serial_ops ar933x_serial_ops = {
  144. .putc = ar933x_serial_putc,
  145. .pending = ar933x_serial_pending,
  146. .getc = ar933x_serial_getc,
  147. .setbrg = ar933x_serial_setbrg,
  148. };
  149. static const struct udevice_id ar933x_serial_ids[] = {
  150. { .compatible = "qca,ar9330-uart" },
  151. { }
  152. };
  153. U_BOOT_DRIVER(serial_ar933x) = {
  154. .name = "serial_ar933x",
  155. .id = UCLASS_SERIAL,
  156. .of_match = ar933x_serial_ids,
  157. .priv_auto_alloc_size = sizeof(struct ar933x_serial_priv),
  158. .probe = ar933x_serial_probe,
  159. .ops = &ar933x_serial_ops,
  160. };
  161. #ifdef CONFIG_DEBUG_UART_AR933X
  162. #include <debug_uart.h>
  163. static inline void _debug_uart_init(void)
  164. {
  165. void __iomem *regs = (void *)CONFIG_DEBUG_UART_BASE;
  166. u32 val, scale, step;
  167. /*
  168. * UART controller configuration:
  169. * - no DMA
  170. * - no interrupt
  171. * - DCE mode
  172. * - no flow control
  173. * - set RX ready oride
  174. * - set TX ready oride
  175. */
  176. val = (AR933X_UART_CS_IF_MODE_DCE << AR933X_UART_CS_IF_MODE_S) |
  177. AR933X_UART_CS_TX_RDY_ORIDE | AR933X_UART_CS_RX_RDY_ORIDE;
  178. writel(val, regs + AR933X_UART_CS_REG);
  179. ar933x_serial_get_scale_step(CONFIG_DEBUG_UART_CLOCK,
  180. CONFIG_BAUDRATE, &scale, &step);
  181. val = (scale & AR933X_UART_CLK_SCALE_M)
  182. << AR933X_UART_CLK_SCALE_S;
  183. val |= (step & AR933X_UART_CLK_STEP_M)
  184. << AR933X_UART_CLK_STEP_S;
  185. writel(val, regs + AR933X_UART_CLK_REG);
  186. }
  187. static inline void _debug_uart_putc(int c)
  188. {
  189. void __iomem *regs = (void *)CONFIG_DEBUG_UART_BASE;
  190. u32 data;
  191. do {
  192. data = readl(regs + AR933X_UART_DATA_REG);
  193. } while (!(data & AR933X_UART_DATA_TX_CSR));
  194. data = (u32)c | AR933X_UART_DATA_TX_CSR;
  195. writel(data, regs + AR933X_UART_DATA_REG);
  196. }
  197. DEBUG_UART_FUNCS
  198. #endif