drivers/serial/serial_ar933x.c

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