drivers/serial/serial_mtk.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * MediaTek High-speed UART driver
   4  *
   5  * Copyright (C) 2018 MediaTek Inc.
   6  * Author: Weijie Gao <weijie.gao@mediatek.com>
   7  */
   8
   9 #include <clk.h>
  10 #include <common.h>
  11 #include <div64.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <serial.h>
  15 #include <watchdog.h>
  16 #include <asm/io.h>
  17 #include <asm/types.h>
  18
  19 struct mtk_serial_regs {
  20         u32 rbr;
  21         u32 ier;
  22         u32 fcr;
  23         u32 lcr;
  24         u32 mcr;
  25         u32 lsr;
  26         u32 msr;
  27         u32 spr;
  28         u32 mdr1;
  29         u32 highspeed;
  30         u32 sample_count;
  31         u32 sample_point;
  32         u32 fracdiv_l;
  33         u32 fracdiv_m;
  34         u32 escape_en;
  35         u32 guard;
  36         u32 rx_sel;
  37 };
  38
  39 #define thr rbr
  40 #define iir fcr
  41 #define dll rbr
  42 #define dlm ier
  43
  44 #define UART_LCR_WLS_8  0x03            /* 8 bit character length */
  45 #define UART_LCR_DLAB   0x80            /* Divisor latch access bit */
  46
  47 #define UART_LSR_DR     0x01            /* Data ready */
  48 #define UART_LSR_THRE   0x20            /* Xmit holding register empty */
  49 #define UART_LSR_TEMT   0x40            /* Xmitter empty */
  50
  51 #define UART_MCR_DTR    0x01            /* DTR   */
  52 #define UART_MCR_RTS    0x02            /* RTS   */
  53
  54 #define UART_FCR_FIFO_EN        0x01    /* Fifo enable */
  55 #define UART_FCR_RXSR           0x02    /* Receiver soft reset */
  56 #define UART_FCR_TXSR           0x04    /* Transmitter soft reset */
  57
  58 #define UART_MCRVAL (UART_MCR_DTR | \
  59                      UART_MCR_RTS)
  60
  61 /* Clear & enable FIFOs */
  62 #define UART_FCRVAL (UART_FCR_FIFO_EN | \
  63                      UART_FCR_RXSR |    \
  64                      UART_FCR_TXSR)
  65
  66 /* the data is correct if the real baud is within 3%. */
  67 #define BAUD_ALLOW_MAX(baud)    ((baud) + (baud) * 3 / 100)
  68 #define BAUD_ALLOW_MIX(baud)    ((baud) - (baud) * 3 / 100)
  69
  70 struct mtk_serial_priv {
  71         struct mtk_serial_regs __iomem *regs;
  72         u32 clock;
  73 };
  74
  75 static void _mtk_serial_setbrg(struct mtk_serial_priv *priv, int baud)
  76 {
  77         bool support_clk12m_baud115200;
  78         u32 quot, samplecount, realbaud;
  79
  80         if ((baud <= 115200) && (priv->clock == 12000000))
  81                 support_clk12m_baud115200 = true;
  82         else
  83                 support_clk12m_baud115200 = false;
  84
  85         if (baud <= 115200) {
  86                 writel(0, &priv->regs->highspeed);
  87                 quot = DIV_ROUND_CLOSEST(priv->clock, 16 * baud);
  88
  89                 if (support_clk12m_baud115200) {
  90                         writel(3, &priv->regs->highspeed);
  91                         quot = DIV_ROUND_CLOSEST(priv->clock, 256 * baud);
  92                         if (quot == 0)
  93                                 quot = 1;
  94
  95                         samplecount = DIV_ROUND_CLOSEST(priv->clock,
  96                                                         quot * baud);
  97                         if (samplecount != 0) {
  98                                 realbaud = priv->clock / samplecount / quot;
  99                                 if ((realbaud > BAUD_ALLOW_MAX(baud)) ||
 100                                     (realbaud < BAUD_ALLOW_MIX(baud))) {
 101                                         pr_info("baud %d can't be handled\n",
 102                                                 baud);
 103                                 }
 104                         } else {
 105                                 pr_info("samplecount is 0\n");
 106                         }
 107                 }
 108         } else if (baud <= 576000) {
 109                 writel(2, &priv->regs->highspeed);
 110
 111                 /* Set to next lower baudrate supported */
 112                 if ((baud == 500000) || (baud == 576000))
 113                         baud = 460800;
 114                 quot = DIV_ROUND_UP(priv->clock, 4 * baud);
 115         } else {
 116                 writel(3, &priv->regs->highspeed);
 117                 quot = DIV_ROUND_UP(priv->clock, 256 * baud);
 118         }
 119
 120         /* set divisor */
 121         writel(UART_LCR_WLS_8 | UART_LCR_DLAB, &priv->regs->lcr);
 122         writel(quot & 0xff, &priv->regs->dll);
 123         writel((quot >> 8) & 0xff, &priv->regs->dlm);
 124         writel(UART_LCR_WLS_8, &priv->regs->lcr);
 125
 126         if (baud > 460800) {
 127                 u32 tmp;
 128
 129                 tmp = DIV_ROUND_CLOSEST(priv->clock, quot * baud);
 130                 writel(tmp - 1, &priv->regs->sample_count);
 131                 writel((tmp - 2) >> 1, &priv->regs->sample_point);
 132         } else {
 133                 writel(0, &priv->regs->sample_count);
 134                 writel(0xff, &priv->regs->sample_point);
 135         }
 136
 137         if (support_clk12m_baud115200) {
 138                 writel(samplecount - 1, &priv->regs->sample_count);
 139                 writel((samplecount - 2) >> 1, &priv->regs->sample_point);
 140         }
 141 }
 142
 143 static int mtk_serial_setbrg(struct udevice *dev, int baudrate)
 144 {
 145         struct mtk_serial_priv *priv = dev_get_priv(dev);
 146
 147         _mtk_serial_setbrg(priv, baudrate);
 148
 149         return 0;
 150 }
 151
 152 static int mtk_serial_putc(struct udevice *dev, const char ch)
 153 {
 154         struct mtk_serial_priv *priv = dev_get_priv(dev);
 155
 156         if (!(readl(&priv->regs->lsr) & UART_LSR_THRE))
 157                 return -EAGAIN;
 158
 159         writel(ch, &priv->regs->thr);
 160
 161         if (ch == '\n')
 162                 WATCHDOG_RESET();
 163
 164         return 0;
 165 }
 166
 167 static int mtk_serial_getc(struct udevice *dev)
 168 {
 169         struct mtk_serial_priv *priv = dev_get_priv(dev);
 170
 171         if (!(readl(&priv->regs->lsr) & UART_LSR_DR))
 172                 return -EAGAIN;
 173
 174         return readl(&priv->regs->rbr);
 175 }
 176
 177 static int mtk_serial_pending(struct udevice *dev, bool input)
 178 {
 179         struct mtk_serial_priv *priv = dev_get_priv(dev);
 180
 181         if (input)
 182                 return (readl(&priv->regs->lsr) & UART_LSR_DR) ? 1 : 0;
 183         else
 184                 return (readl(&priv->regs->lsr) & UART_LSR_THRE) ? 0 : 1;
 185 }
 186
 187 static int mtk_serial_probe(struct udevice *dev)
 188 {
 189         struct mtk_serial_priv *priv = dev_get_priv(dev);
 190
 191         /* Disable interrupt */
 192         writel(0, &priv->regs->ier);
 193
 194         writel(UART_MCRVAL, &priv->regs->mcr);
 195         writel(UART_FCRVAL, &priv->regs->fcr);
 196
 197         return 0;
 198 }
 199
 200 static int mtk_serial_ofdata_to_platdata(struct udevice *dev)
 201 {
 202         struct mtk_serial_priv *priv = dev_get_priv(dev);
 203         fdt_addr_t addr;
 204         struct clk clk;
 205         int err;
 206
 207         addr = dev_read_addr(dev);
 208         if (addr == FDT_ADDR_T_NONE)
 209                 return -EINVAL;
 210
 211         priv->regs = map_physmem(addr, 0, MAP_NOCACHE);
 212
 213         err = clk_get_by_index(dev, 0, &clk);
 214         if (!err) {
 215                 err = clk_get_rate(&clk);
 216                 if (!IS_ERR_VALUE(err))
 217                         priv->clock = err;
 218         } else if (err != -ENOENT && err != -ENODEV && err != -ENOSYS) {
 219                 debug("mtk_serial: failed to get clock\n");
 220                 return err;
 221         }
 222
 223         if (!priv->clock)
 224                 priv->clock = dev_read_u32_default(dev, "clock-frequency", 0);
 225
 226         if (!priv->clock) {
 227                 debug("mtk_serial: clock not defined\n");
 228                 return -EINVAL;
 229         }
 230
 231         return 0;
 232 }
 233
 234 static const struct dm_serial_ops mtk_serial_ops = {
 235         .putc = mtk_serial_putc,
 236         .pending = mtk_serial_pending,
 237         .getc = mtk_serial_getc,
 238         .setbrg = mtk_serial_setbrg,
 239 };
 240
 241 static const struct udevice_id mtk_serial_ids[] = {
 242         { .compatible = "mediatek,hsuart" },
 243         { .compatible = "mediatek,mt6577-uart" },
 244         { }
 245 };
 246
 247 U_BOOT_DRIVER(serial_mtk) = {
 248         .name = "serial_mtk",
 249         .id = UCLASS_SERIAL,
 250         .of_match = mtk_serial_ids,
 251         .ofdata_to_platdata = mtk_serial_ofdata_to_platdata,
 252         .priv_auto_alloc_size = sizeof(struct mtk_serial_priv),
 253         .probe = mtk_serial_probe,
 254         .ops = &mtk_serial_ops,
 255         .flags = DM_FLAG_PRE_RELOC,
 256 };
 257
 258 #ifdef CONFIG_DEBUG_UART_MTK
 259
 260 #include <debug_uart.h>
 261
 262 static inline void _debug_uart_init(void)
 263 {
 264         struct mtk_serial_priv priv;
 265
 266         priv.regs = (void *) CONFIG_DEBUG_UART_BASE;
 267         priv.clock = CONFIG_DEBUG_UART_CLOCK;
 268
 269         writel(0, &priv.regs->ier);
 270         writel(UART_MCRVAL, &priv.regs->mcr);
 271         writel(UART_FCRVAL, &priv.regs->fcr);
 272
 273         _mtk_serial_setbrg(&priv, CONFIG_BAUDRATE);
 274 }
 275
 276 static inline void _debug_uart_putc(int ch)
 277 {
 278         struct mtk_serial_regs __iomem *regs =
 279                 (void *) CONFIG_DEBUG_UART_BASE;
 280
 281         while (!(readl(&regs->lsr) & UART_LSR_THRE))
 282                 ;
 283
 284         writel(ch, &regs->thr);
 285 }
 286
 287 DEBUG_UART_FUNCS
 288
 289 #endif