Quelle  clk-lpc18xx-cgu.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Clk driver for NXP LPC18xx/LPC43xx Clock Generation Unit (CGU)
 *
 * Copyright (C) 2015 Joachim Eastwood <manabian@gmail.com>
 */

#include <linux/clk-provider.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_address.h>

#include <dt-bindings/clock/lpc18xx-cgu.h>

/* Clock Generation Unit (CGU) registers */
#define LPC18XX_CGU_XTAL_OSC_CTRL 0x018
#define LPC18XX_CGU_PLL0USB_STAT 0x01c
#define LPC18XX_CGU_PLL0USB_CTRL 0x020
#define LPC18XX_CGU_PLL0USB_MDIV 0x024
#define LPC18XX_CGU_PLL0USB_NP_DIV 0x028
#define LPC18XX_CGU_PLL0AUDIO_STAT 0x02c
#define LPC18XX_CGU_PLL0AUDIO_CTRL 0x030
#define LPC18XX_CGU_PLL0AUDIO_MDIV 0x034
#define LPC18XX_CGU_PLL0AUDIO_NP_DIV 0x038
#define LPC18XX_CGU_PLL0AUDIO_FRAC 0x03c
#define LPC18XX_CGU_PLL1_STAT  0x040
#define LPC18XX_CGU_PLL1_CTRL  0x044
#define  LPC18XX_PLL1_CTRL_FBSEL BIT(6)
#define  LPC18XX_PLL1_CTRL_DIRECT BIT(7)
#define LPC18XX_CGU_IDIV_CTRL(n) (0x048 + (n) * sizeof(u32))
#define LPC18XX_CGU_BASE_CLK(id) (0x05c + (id) * sizeof(u32))
#define LPC18XX_CGU_PLL_CTRL_OFFSET 0x4

/* PLL0 bits common to both audio and USB PLL */
#define LPC18XX_PLL0_STAT_LOCK  BIT(0)
#define LPC18XX_PLL0_CTRL_PD  BIT(0)
#define LPC18XX_PLL0_CTRL_BYPASS BIT(1)
#define LPC18XX_PLL0_CTRL_DIRECTI BIT(2)
#define LPC18XX_PLL0_CTRL_DIRECTO BIT(3)
#define LPC18XX_PLL0_CTRL_CLKEN  BIT(4)
#define LPC18XX_PLL0_MDIV_MDEC_MASK 0x1ffff
#define LPC18XX_PLL0_MDIV_SELP_SHIFT 17
#define LPC18XX_PLL0_MDIV_SELI_SHIFT 22
#define LPC18XX_PLL0_MSEL_MAX  BIT(15)

/* Register value that gives PLL0 post/pre dividers equal to 1 */
#define LPC18XX_PLL0_NP_DIVS_1  0x00302062

enum {
 CLK_SRC_OSC32,
 CLK_SRC_IRC,
 CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK,
 CLK_SRC_GP_CLKIN,
 CLK_SRC_RESERVED1,
 CLK_SRC_OSC,
 CLK_SRC_PLL0USB,
 CLK_SRC_PLL0AUDIO,
 CLK_SRC_PLL1,
 CLK_SRC_RESERVED2,
 CLK_SRC_RESERVED3,
 CLK_SRC_IDIVA,
 CLK_SRC_IDIVB,
 CLK_SRC_IDIVC,
 CLK_SRC_IDIVD,
 CLK_SRC_IDIVE,
 CLK_SRC_MAX
};

static const char *clk_src_names[CLK_SRC_MAX] = {
 [CLK_SRC_OSC32]  = "osc32",
 [CLK_SRC_IRC]  = "irc",
 [CLK_SRC_ENET_RX_CLK] = "enet_rx_clk",
 [CLK_SRC_ENET_TX_CLK] = "enet_tx_clk",
 [CLK_SRC_GP_CLKIN] = "gp_clkin",
 [CLK_SRC_OSC]  = "osc",
 [CLK_SRC_PLL0USB] = "pll0usb",
 [CLK_SRC_PLL0AUDIO] = "pll0audio",
 [CLK_SRC_PLL1]  = "pll1",
 [CLK_SRC_IDIVA]  = "idiva",
 [CLK_SRC_IDIVB]  = "idivb",
 [CLK_SRC_IDIVC]  = "idivc",
 [CLK_SRC_IDIVD]  = "idivd",
 [CLK_SRC_IDIVE]  = "idive",
};

static const char *clk_base_names[BASE_CLK_MAX] = {
 [BASE_SAFE_CLK]  = "base_safe_clk",
 [BASE_USB0_CLK]  = "base_usb0_clk",
 [BASE_PERIPH_CLK] = "base_periph_clk",
 [BASE_USB1_CLK]  = "base_usb1_clk",
 [BASE_CPU_CLK]  = "base_cpu_clk",
 [BASE_SPIFI_CLK] = "base_spifi_clk",
 [BASE_SPI_CLK]  = "base_spi_clk",
 [BASE_PHY_RX_CLK] = "base_phy_rx_clk",
 [BASE_PHY_TX_CLK] = "base_phy_tx_clk",
 [BASE_APB1_CLK]  = "base_apb1_clk",
 [BASE_APB3_CLK]  = "base_apb3_clk",
 [BASE_LCD_CLK]  = "base_lcd_clk",
 [BASE_ADCHS_CLK] = "base_adchs_clk",
 [BASE_SDIO_CLK]  = "base_sdio_clk",
 [BASE_SSP0_CLK]  = "base_ssp0_clk",
 [BASE_SSP1_CLK]  = "base_ssp1_clk",
 [BASE_UART0_CLK] = "base_uart0_clk",
 [BASE_UART1_CLK] = "base_uart1_clk",
 [BASE_UART2_CLK] = "base_uart2_clk",
 [BASE_UART3_CLK] = "base_uart3_clk",
 [BASE_OUT_CLK]  = "base_out_clk",
 [BASE_AUDIO_CLK] = "base_audio_clk",
 [BASE_CGU_OUT0_CLK] = "base_cgu_out0_clk",
 [BASE_CGU_OUT1_CLK] = "base_cgu_out1_clk",
};

static u32 lpc18xx_cgu_pll0_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL1, CLK_SRC_IDIVA, CLK_SRC_IDIVB, CLK_SRC_IDIVC,
 CLK_SRC_IDIVD, CLK_SRC_IDIVE,
};

static u32 lpc18xx_cgu_pll1_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_IDIVA,
 CLK_SRC_IDIVB, CLK_SRC_IDIVC, CLK_SRC_IDIVD, CLK_SRC_IDIVE,
};

static u32 lpc18xx_cgu_idiva_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1
};

static u32 lpc18xx_cgu_idivbcde_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1, CLK_SRC_IDIVA,
};

static u32 lpc18xx_cgu_base_irc_src_ids[] = {CLK_SRC_IRC};

static u32 lpc18xx_cgu_base_usb0_src_ids[] = {CLK_SRC_PLL0USB};

static u32 lpc18xx_cgu_base_common_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1, CLK_SRC_IDIVA,
 CLK_SRC_IDIVB, CLK_SRC_IDIVC, CLK_SRC_IDIVD, CLK_SRC_IDIVE,
};

static u32 lpc18xx_cgu_base_all_src_ids[] = {
 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1,
 CLK_SRC_IDIVA, CLK_SRC_IDIVB, CLK_SRC_IDIVC,
 CLK_SRC_IDIVD, CLK_SRC_IDIVE,
};

struct lpc18xx_cgu_src_clk_div {
 u8 clk_id;
 u8 n_parents;
 struct clk_divider div;
 struct clk_mux  mux;
 struct clk_gate  gate;
};

#define LPC1XX_CGU_SRC_CLK_DIV(_id, _width, _table) \
{       \
 .clk_id = CLK_SRC_ ##_id,   \
 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
 .div = {     \
  .shift = 2,    \
  .width = _width,   \
 },      \
 .mux = {     \
  .mask = 0x1f,    \
  .shift = 24,    \
  .table = lpc18xx_cgu_ ##_table,  \
 },      \
 .gate = {     \
  .bit_idx = 0,    \
  .flags = CLK_GATE_SET_TO_DISABLE, \
 },      \
}

static struct lpc18xx_cgu_src_clk_div lpc18xx_cgu_src_clk_divs[] = {
 LPC1XX_CGU_SRC_CLK_DIV(IDIVA, 2, idiva_src_ids),
 LPC1XX_CGU_SRC_CLK_DIV(IDIVB, 4, idivbcde_src_ids),
 LPC1XX_CGU_SRC_CLK_DIV(IDIVC, 4, idivbcde_src_ids),
 LPC1XX_CGU_SRC_CLK_DIV(IDIVD, 4, idivbcde_src_ids),
 LPC1XX_CGU_SRC_CLK_DIV(IDIVE, 8, idivbcde_src_ids),
};

struct lpc18xx_cgu_base_clk {
 u8 clk_id;
 u8 n_parents;
 struct clk_mux mux;
 struct clk_gate gate;
};

#define LPC1XX_CGU_BASE_CLK(_id, _table, _flags) \
{       \
 .clk_id = BASE_ ##_id ##_CLK,   \
 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
 .mux = {     \
  .mask = 0x1f,    \
  .shift = 24,    \
  .table = lpc18xx_cgu_ ##_table,  \
  .flags = _flags,   \
 },      \
 .gate = {     \
  .bit_idx = 0,    \
  .flags = CLK_GATE_SET_TO_DISABLE, \
 },      \
}

static struct lpc18xx_cgu_base_clk lpc18xx_cgu_base_clks[] = {
 LPC1XX_CGU_BASE_CLK(SAFE, base_irc_src_ids, CLK_MUX_READ_ONLY),
 LPC1XX_CGU_BASE_CLK(USB0, base_usb0_src_ids,   0),
 LPC1XX_CGU_BASE_CLK(PERIPH, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(USB1, base_all_src_ids,    0),
 LPC1XX_CGU_BASE_CLK(CPU, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(SPIFI, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(SPI, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(PHY_RX, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(PHY_TX, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(APB1, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(APB3, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(LCD, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(ADCHS, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(SDIO, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(SSP0, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(SSP1, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(UART0, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(UART1, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(UART2, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(UART3, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(OUT, base_all_src_ids,    0),
 { /* 21 reserved */ },
 { /* 22 reserved */ },
 { /* 23 reserved */ },
 { /* 24 reserved */ },
 LPC1XX_CGU_BASE_CLK(AUDIO, base_common_src_ids, 0),
 LPC1XX_CGU_BASE_CLK(CGU_OUT0, base_all_src_ids,    0),
 LPC1XX_CGU_BASE_CLK(CGU_OUT1, base_all_src_ids,    0),
};

struct lpc18xx_pll {
 struct  clk_hw hw;
 void __iomem *reg;
 u8  flags;
};

#define to_lpc_pll(hw) container_of(hw, struct lpc18xx_pll, hw)

struct lpc18xx_cgu_pll_clk {
 u8 clk_id;
 u8 n_parents;
 u8 reg_offset;
 struct clk_mux mux;
 struct clk_gate gate;
 struct lpc18xx_pll pll;
 const struct clk_ops *pll_ops;
};

#define LPC1XX_CGU_CLK_PLL(_id, _table, _pll_ops) \
{       \
 .clk_id = CLK_SRC_ ##_id,   \
 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
 .reg_offset = LPC18XX_CGU_ ##_id ##_STAT, \
 .mux = {     \
  .mask = 0x1f,    \
  .shift = 24,    \
  .table = lpc18xx_cgu_ ##_table,  \
 },      \
 .gate = {     \
  .bit_idx = 0,    \
  .flags = CLK_GATE_SET_TO_DISABLE, \
 },      \
 .pll_ops = &lpc18xx_ ##_pll_ops,  \
}

/*
 * PLL0 uses a special register value encoding. The compute functions below
 * are taken or derived from the LPC1850 user manual (section 12.6.3.3).
 */

/* Compute PLL0 multiplier from decoded version */
static u32 lpc18xx_pll0_mdec2msel(u32 x)
{
 int i;

 switch (x) {
 case 0x18003: return 1;
 case 0x10003: return 2;
 default:
  for (i = LPC18XX_PLL0_MSEL_MAX + 1; x != 0x4000 && i > 0; i--)
   x = ((x ^ x >> 14) & 1) | (x << 1 & 0x7fff);
  return i;
 }
}
/* Compute PLL0 decoded multiplier from binary version */
static u32 lpc18xx_pll0_msel2mdec(u32 msel)
{
 u32 i, x = 0x4000;

 switch (msel) {
 case 0: return 0;
 case 1: return 0x18003;
 case 2: return 0x10003;
 default:
  for (i = msel; i <= LPC18XX_PLL0_MSEL_MAX; i++)
   x = ((x ^ x >> 1) & 1) << 14 | (x >> 1 & 0xffff);
  return x;
 }
}

/* Compute PLL0 bandwidth SELI reg from multiplier */
static u32 lpc18xx_pll0_msel2seli(u32 msel)
{
 u32 tmp;

 if (msel > 16384) return 1;
 if (msel >  8192) return 2;
 if (msel >  2048) return 4;
 if (msel >=  501) return 8;
 if (msel >=   60) {
  tmp = 1024 / (msel + 9);
  return ((1024 == (tmp * (msel + 9))) == 0) ? tmp * 4 : (tmp + 1) * 4;
 }

 return (msel & 0x3c) + 4;
}

/* Compute PLL0 bandwidth SELP reg from multiplier */
static u32 lpc18xx_pll0_msel2selp(u32 msel)
{
 if (msel < 60)
  return (msel >> 1) + 1;

 return 31;
}

static unsigned long lpc18xx_pll0_recalc_rate(struct clk_hw *hw,
           unsigned long parent_rate)
{
 struct lpc18xx_pll *pll = to_lpc_pll(hw);
 u32 ctrl, mdiv, msel, npdiv;

 ctrl = readl(pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
 mdiv = readl(pll->reg + LPC18XX_CGU_PLL0USB_MDIV);
 npdiv = readl(pll->reg + LPC18XX_CGU_PLL0USB_NP_DIV);

 if (ctrl & LPC18XX_PLL0_CTRL_BYPASS)
  return parent_rate;

 if (npdiv != LPC18XX_PLL0_NP_DIVS_1) {
  pr_warn("%s: pre/post dividers not supported\n", __func__);
  return 0;
 }

 msel = lpc18xx_pll0_mdec2msel(mdiv & LPC18XX_PLL0_MDIV_MDEC_MASK);
 if (msel)
  return 2 * msel * parent_rate;

 pr_warn("%s: unable to calculate rate\n", __func__);

 return 0;
}

static int lpc18xx_pll0_determine_rate(struct clk_hw *hw,
           struct clk_rate_request *req)
{
 unsigned long m;

 if (req->best_parent_rate < req->rate) {
  pr_warn("%s: pll dividers not supported\n", __func__);
  return -EINVAL;
 }

 m = DIV_ROUND_UP_ULL(req->best_parent_rate, req->rate * 2);
 if (m == 0 || m > LPC18XX_PLL0_MSEL_MAX) {
  pr_warn("%s: unable to support rate %lu\n", __func__, req->rate);
  return -EINVAL;
 }

 req->rate = 2 * req->best_parent_rate * m;

 return 0;
}

static int lpc18xx_pll0_set_rate(struct clk_hw *hw, unsigned long rate,
     unsigned long parent_rate)
{
 struct lpc18xx_pll *pll = to_lpc_pll(hw);
 u32 ctrl, stat, m;
 int retry = 3;

 if (parent_rate < rate) {
  pr_warn("%s: pll dividers not supported\n", __func__);
  return -EINVAL;
 }

 m = DIV_ROUND_UP_ULL(parent_rate, rate * 2);
 if (m == 0 || m > LPC18XX_PLL0_MSEL_MAX) {
  pr_warn("%s: unable to support rate %lu\n", __func__, rate);
  return -EINVAL;
 }

 m  = lpc18xx_pll0_msel2mdec(m);
 m |= lpc18xx_pll0_msel2selp(m) << LPC18XX_PLL0_MDIV_SELP_SHIFT;
 m |= lpc18xx_pll0_msel2seli(m) << LPC18XX_PLL0_MDIV_SELI_SHIFT;

 /* Power down PLL, disable clk output and dividers */
 ctrl = readl(pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
 ctrl |= LPC18XX_PLL0_CTRL_PD;
 ctrl &= ~(LPC18XX_PLL0_CTRL_BYPASS | LPC18XX_PLL0_CTRL_DIRECTI |
    LPC18XX_PLL0_CTRL_DIRECTO | LPC18XX_PLL0_CTRL_CLKEN);
 writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);

 /* Configure new PLL settings */
 writel(m, pll->reg + LPC18XX_CGU_PLL0USB_MDIV);
 writel(LPC18XX_PLL0_NP_DIVS_1, pll->reg + LPC18XX_CGU_PLL0USB_NP_DIV);

 /* Power up PLL and wait for lock */
 ctrl &= ~LPC18XX_PLL0_CTRL_PD;
 writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
 do {
  udelay(10);
  stat = readl(pll->reg + LPC18XX_CGU_PLL0USB_STAT);
  if (stat & LPC18XX_PLL0_STAT_LOCK) {
   ctrl |= LPC18XX_PLL0_CTRL_CLKEN;
   writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);

   return 0;
  }
 } while (retry--);

 pr_warn("%s: unable to lock pll\n", __func__);

 return -EINVAL;
}

static const struct clk_ops lpc18xx_pll0_ops = {
 .recalc_rate = lpc18xx_pll0_recalc_rate,
 .determine_rate = lpc18xx_pll0_determine_rate,
 .set_rate = lpc18xx_pll0_set_rate,
};

static unsigned long lpc18xx_pll1_recalc_rate(struct clk_hw *hw,
           unsigned long parent_rate)
{
 struct lpc18xx_pll *pll = to_lpc_pll(hw);
 u16 msel, nsel, psel;
 bool direct, fbsel;
 u32 ctrl;

 ctrl = readl(pll->reg + LPC18XX_CGU_PLL1_CTRL);

 direct = (ctrl & LPC18XX_PLL1_CTRL_DIRECT) ? true : false;
 fbsel = (ctrl & LPC18XX_PLL1_CTRL_FBSEL) ? true : false;

 msel = ((ctrl >> 16) & 0xff) + 1;
 nsel = ((ctrl >> 12) & 0x3) + 1;

 if (direct || fbsel)
  return msel * (parent_rate / nsel);

 psel = (ctrl >>  8) & 0x3;
 psel = 1 << psel;

 return (msel / (2 * psel)) * (parent_rate / nsel);
}

static const struct clk_ops lpc18xx_pll1_ops = {
 .recalc_rate = lpc18xx_pll1_recalc_rate,
};

static int lpc18xx_cgu_gate_enable(struct clk_hw *hw)
{
 return clk_gate_ops.enable(hw);
}

static void lpc18xx_cgu_gate_disable(struct clk_hw *hw)
{
 clk_gate_ops.disable(hw);
}

static int lpc18xx_cgu_gate_is_enabled(struct clk_hw *hw)
{
 const struct clk_hw *parent;

 /*
 * The consumer of base clocks needs know if the
 * base clock is really enabled before it can be
 * accessed. It is therefore necessary to verify
 * this all the way up.
 */
 parent = clk_hw_get_parent(hw);
 if (!parent)
  return 0;

 if (!clk_hw_is_enabled(parent))
  return 0;

 return clk_gate_ops.is_enabled(hw);
}

static const struct clk_ops lpc18xx_gate_ops = {
 .enable = lpc18xx_cgu_gate_enable,
 .disable = lpc18xx_cgu_gate_disable,
 .is_enabled = lpc18xx_cgu_gate_is_enabled,
};

static struct lpc18xx_cgu_pll_clk lpc18xx_cgu_src_clk_plls[] = {
 LPC1XX_CGU_CLK_PLL(PLL0USB, pll0_src_ids, pll0_ops),
 LPC1XX_CGU_CLK_PLL(PLL0AUDIO, pll0_src_ids, pll0_ops),
 LPC1XX_CGU_CLK_PLL(PLL1, pll1_src_ids, pll1_ops),
};

static void lpc18xx_fill_parent_names(const char **parent, const u32 *id, int size)
{
 int i;

 for (i = 0; i < size; i++)
  parent[i] = clk_src_names[id[i]];
}

static struct clk *lpc18xx_cgu_register_div(struct lpc18xx_cgu_src_clk_div *clk,
         void __iomem *base, int n)
{
 void __iomem *reg = base + LPC18XX_CGU_IDIV_CTRL(n);
 const char *name = clk_src_names[clk->clk_id];
 const char *parents[CLK_SRC_MAX];

 clk->div.reg = reg;
 clk->mux.reg = reg;
 clk->gate.reg = reg;

 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);

 return clk_register_composite(NULL, name, parents, clk->n_parents,
          &clk->mux.hw, &clk_mux_ops,
          &clk->div.hw, &clk_divider_ops,
          &clk->gate.hw, &lpc18xx_gate_ops, 0);
}


static struct clk *lpc18xx_register_base_clk(struct lpc18xx_cgu_base_clk *clk,
          void __iomem *reg_base, int n)
{
 void __iomem *reg = reg_base + LPC18XX_CGU_BASE_CLK(n);
 const char *name = clk_base_names[clk->clk_id];
 const char *parents[CLK_SRC_MAX];

 if (clk->n_parents == 0)
  return ERR_PTR(-ENOENT);

 clk->mux.reg = reg;
 clk->gate.reg = reg;

 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);

 /* SAFE_CLK can not be turned off */
 if (n == BASE_SAFE_CLK)
  return clk_register_composite(NULL, name, parents, clk->n_parents,
           &clk->mux.hw, &clk_mux_ops,
           NULL, NULL, NULL, NULL, 0);

 return clk_register_composite(NULL, name, parents, clk->n_parents,
          &clk->mux.hw, &clk_mux_ops,
          NULL,  NULL,
          &clk->gate.hw, &lpc18xx_gate_ops, 0);
}


static struct clk *lpc18xx_cgu_register_pll(struct lpc18xx_cgu_pll_clk *clk,
         void __iomem *base)
{
 const char *name = clk_src_names[clk->clk_id];
 const char *parents[CLK_SRC_MAX];

 clk->pll.reg  = base;
 clk->mux.reg  = base + clk->reg_offset + LPC18XX_CGU_PLL_CTRL_OFFSET;
 clk->gate.reg = base + clk->reg_offset + LPC18XX_CGU_PLL_CTRL_OFFSET;

 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);

 return clk_register_composite(NULL, name, parents, clk->n_parents,
          &clk->mux.hw, &clk_mux_ops,
          &clk->pll.hw, clk->pll_ops,
          &clk->gate.hw, &lpc18xx_gate_ops, 0);
}

static void __init lpc18xx_cgu_register_source_clks(struct device_node *np,
          void __iomem *base)
{
 const char *parents[CLK_SRC_MAX];
 struct clk *clk;
 int i;

 /* Register the internal 12 MHz RC oscillator (IRC) */
 clk = clk_register_fixed_rate(NULL, clk_src_names[CLK_SRC_IRC],
          NULL, 0, 12000000);
 if (IS_ERR(clk))
  pr_warn("%s: failed to register irc clk\n", __func__);

 /* Register crystal oscillator controller */
 parents[0] = of_clk_get_parent_name(np, 0);
 clk = clk_register_gate(NULL, clk_src_names[CLK_SRC_OSC], parents[0],
    0, base + LPC18XX_CGU_XTAL_OSC_CTRL,
    0, CLK_GATE_SET_TO_DISABLE, NULL);
 if (IS_ERR(clk))
  pr_warn("%s: failed to register osc clk\n", __func__);

 /* Register all PLLs */
 for (i = 0; i < ARRAY_SIZE(lpc18xx_cgu_src_clk_plls); i++) {
  clk = lpc18xx_cgu_register_pll(&lpc18xx_cgu_src_clk_plls[i],
         base);
  if (IS_ERR(clk))
   pr_warn("%s: failed to register pll (%d)\n", __func__, i);
 }

 /* Register all clock dividers A-E */
 for (i = 0; i < ARRAY_SIZE(lpc18xx_cgu_src_clk_divs); i++) {
  clk = lpc18xx_cgu_register_div(&lpc18xx_cgu_src_clk_divs[i],
            base, i);
  if (IS_ERR(clk))
   pr_warn("%s: failed to register div %d\n", __func__, i);
 }
}

static struct clk *clk_base[BASE_CLK_MAX];
static struct clk_onecell_data clk_base_data = {
 .clks = clk_base,
 .clk_num = BASE_CLK_MAX,
};

static void __init lpc18xx_cgu_register_base_clks(void __iomem *reg_base)
{
 int i;

 for (i = BASE_SAFE_CLK; i < BASE_CLK_MAX; i++) {
  clk_base[i] = lpc18xx_register_base_clk(&lpc18xx_cgu_base_clks[i],
       reg_base, i);
  if (IS_ERR(clk_base[i]) && PTR_ERR(clk_base[i]) != -ENOENT)
   pr_warn("%s: register base clk %d failed\n", __func__, i);
 }
}

static void __init lpc18xx_cgu_init(struct device_node *np)
{
 void __iomem *reg_base;

 reg_base = of_iomap(np, 0);
 if (!reg_base) {
  pr_warn("%s: failed to map address range\n", __func__);
  return;
 }

 lpc18xx_cgu_register_source_clks(np, reg_base);
 lpc18xx_cgu_register_base_clks(reg_base);

 of_clk_add_provider(np, of_clk_src_onecell_get, &clk_base_data);
}
CLK_OF_DECLARE(lpc18xx_cgu, "nxp,lpc1850-cgu", lpc18xx_cgu_init);