// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
 *
 * Author: Wyon Bi <bivvy.bi@rock-chips.com>
 */

#include <linux/clk.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/clk-provider.h>
#include <linux/reset-controller.h>
#include <linux/mfd/rk628.h>
#include <dt-bindings/reset/rk628-rgu.h>
#include <dt-bindings/clock/rk628-cgu.h>

#include "clk-regmap.h"

#define RK628_PLL(_id, _name, _parent_name, _reg, _flags) \
	PLL(_id, _name, _parent_name, _reg, 13, 12, 10, _flags)

#define REG(x)			((x) + 0xc0000)

#define CRU_CPLL_CON0		REG(0x0000)
#define CRU_CPLL_CON1		REG(0x0004)
#define CRU_CPLL_CON2		REG(0x0008)
#define CRU_CPLL_CON3		REG(0x000c)
#define CRU_CPLL_CON4		REG(0x0010)
#define CRU_GPLL_CON0		REG(0x0020)
#define CRU_GPLL_CON1		REG(0x0024)
#define CRU_GPLL_CON2		REG(0x0028)
#define CRU_GPLL_CON3		REG(0x002c)
#define CRU_GPLL_CON4		REG(0x0030)
#define CRU_MODE_CON		REG(0x0060)
#define CRU_CLKSEL_CON00	REG(0x0080)
#define CRU_CLKSEL_CON01	REG(0x0084)
#define CRU_CLKSEL_CON02	REG(0x0088)
#define CRU_CLKSEL_CON03	REG(0x008c)
#define CRU_CLKSEL_CON04	REG(0x0090)
#define CRU_CLKSEL_CON05	REG(0x0094)
#define CRU_CLKSEL_CON06	REG(0x0098)
#define CRU_CLKSEL_CON07	REG(0x009c)
#define CRU_CLKSEL_CON08	REG(0x00a0)
#define CRU_CLKSEL_CON09	REG(0x00a4)
#define CRU_CLKSEL_CON10	REG(0x00a8)
#define CRU_CLKSEL_CON11	REG(0x00ac)
#define CRU_CLKSEL_CON12	REG(0x00b0)
#define CRU_CLKSEL_CON13	REG(0x00b4)
#define CRU_CLKSEL_CON14	REG(0x00b8)
#define CRU_CLKSEL_CON15	REG(0x00bc)
#define CRU_CLKSEL_CON16	REG(0x00c0)
#define CRU_CLKSEL_CON17	REG(0x00c4)
#define CRU_CLKSEL_CON18	REG(0x00c8)
#define CRU_CLKSEL_CON20	REG(0x00d0)
#define CRU_CLKSEL_CON21	REG(0x00d4)
#define CRU_GATE_CON00		REG(0x0180)
#define CRU_GATE_CON01		REG(0x0184)
#define CRU_GATE_CON02		REG(0x0188)
#define CRU_GATE_CON03		REG(0x018c)
#define CRU_GATE_CON04		REG(0x0190)
#define CRU_GATE_CON05		REG(0x0194)
#define CRU_SOFTRST_CON00	REG(0x0200)
#define CRU_SOFTRST_CON01	REG(0x0204)
#define CRU_SOFTRST_CON02	REG(0x0208)
#define CRU_SOFTRST_CON04	REG(0x0210)
#define CRU_MAX_REGISTER	CRU_SOFTRST_CON04

#define reset_to_cru(_rst) container_of(_rst, struct rk628_cru, rcdev)

struct rk628_cru {
	struct device *dev;
	struct rk628 *parent;
	struct regmap *regmap;
	struct reset_controller_dev rcdev;
	struct clk_onecell_data clk_data;
};

#define CNAME(x) "rk628_" x

#define PNAME(x) static const char *const x[]

PNAME(mux_cpll_osc_p) = { CNAME("xin_osc0_func"), CNAME("clk_cpll") };
PNAME(mux_gpll_osc_p) = { CNAME("xin_osc0_func"), CNAME("clk_gpll") };
PNAME(mux_cpll_gpll_mux_p) = { CNAME("clk_cpll_mux"), CNAME("clk_gpll_mux") };
PNAME(mux_mclk_i2s_8ch_p) = { CNAME("clk_i2s_8ch_src"),
			      CNAME("clk_i2s_8ch_frac"), CNAME("i2s_mclkin"),
			      CNAME("xin_osc0_half") };
PNAME(mux_i2s_mclkout_p) = { CNAME("mclk_i2s_8ch"), CNAME("xin_osc0_half") };
PNAME(mux_clk_testout_p) = { CNAME("xin_osc0_func"), CNAME("xin_osc0_half"),
			     CNAME("clk_gpll"), CNAME("clk_gpll_mux"),
			     CNAME("clk_cpll"), CNAME("clk_gpll_mux"),
			     CNAME("pclk_logic"), CNAME("sclk_vop"),
			     CNAME("mclk_i2s_8ch"), CNAME("i2s_mclkout"),
			     CNAME("dummy"), CNAME("clk_hdmirx_aud"),
			     CNAME("clk_hdmirx_cec"), CNAME("clk_imodet"),
			     CNAME("clk_txesc"), CNAME("clk_gpio_db0") };

static const struct clk_pll_data rk628_clk_plls[] = {
	RK628_PLL(CGU_CLK_CPLL, CNAME("clk_cpll"), CNAME("xin_osc0_func"),
		  CRU_CPLL_CON0,
		  0),
	RK628_PLL(CGU_CLK_GPLL, CNAME("clk_gpll"), CNAME("xin_osc0_func"),
		  CRU_GPLL_CON0,
		  0),
};

static const struct clk_mux_data rk628_clk_muxes[] = {
	MUX(CGU_CLK_CPLL_MUX, CNAME("clk_cpll_mux"), mux_cpll_osc_p,
	    CRU_MODE_CON, 0, 1,
	    0),
	MUX(CGU_CLK_GPLL_MUX, CNAME("clk_gpll_mux"), mux_gpll_osc_p,
	    CRU_MODE_CON, 2, 1,
	    CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT),
};

static const struct clk_gate_data rk628_clk_gates[] = {
	GATE(CGU_PCLK_GPIO0, CNAME("pclk_gpio0"), CNAME("pclk_logic"),
	     CRU_GATE_CON01, 0,
	     0),
	GATE(CGU_PCLK_GPIO1, CNAME("pclk_gpio1"), CNAME("pclk_logic"),
	     CRU_GATE_CON01, 1,
	     0),
	GATE(CGU_PCLK_GPIO2, CNAME("pclk_gpio2"), CNAME("pclk_logic"),
	     CRU_GATE_CON01, 2,
	     0),
	GATE(CGU_PCLK_GPIO3, CNAME("pclk_gpio3"), CNAME("pclk_logic"),
	     CRU_GATE_CON01, 3,
	     0),

	GATE(CGU_PCLK_TXPHY_CON, CNAME("pclk_txphy_con"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 3,
	     CLK_IGNORE_UNUSED),
	GATE(CGU_PCLK_EFUSE, CNAME("pclk_efuse"), CNAME("pclk_logic"),
	     CRU_GATE_CON00, 5,
	     0),
	GATE(0, CNAME("pclk_i2c2apb"), CNAME("pclk_logic"),
	     CRU_GATE_CON00, 3,
	     CLK_IGNORE_UNUSED),
	GATE(0, CNAME("pclk_cru"), CNAME("pclk_logic"),
	     CRU_GATE_CON00, 1,
	     CLK_IGNORE_UNUSED),
	GATE(0, CNAME("pclk_adapter"), CNAME("pclk_logic"),
	     CRU_GATE_CON00, 7,
	     CLK_IGNORE_UNUSED),
	GATE(0, CNAME("pclk_regfile"), CNAME("pclk_logic"),
	     CRU_GATE_CON00, 2,
	     CLK_IGNORE_UNUSED),
	GATE(CGU_PCLK_DSI0, CNAME("pclk_dsi0"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 6,
	     0),
	GATE(CGU_PCLK_DSI1, CNAME("pclk_dsi1"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 7,
	     0),
	GATE(CGU_PCLK_CSI, CNAME("pclk_csi"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 8,
	     0),
	GATE(CGU_PCLK_HDMITX, CNAME("pclk_hdmitx"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 4,
	     0),
	GATE(CGU_PCLK_RXPHY, CNAME("pclk_rxphy"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 0,
	     0),
	GATE(CGU_PCLK_HDMIRX, CNAME("pclk_hdmirx"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 2,
	     0),
	GATE(CGU_PCLK_GVIHOST, CNAME("pclk_gvihost"), CNAME("pclk_logic"),
	     CRU_GATE_CON02, 5,
	     0),
	GATE(CGU_CLK_CFG_DPHY0, CNAME("clk_cfg_dphy0"), CNAME("xin_osc0_func"),
	     CRU_GATE_CON02, 13,
	     0),
	GATE(CGU_CLK_CFG_DPHY1, CNAME("clk_cfg_dphy1"), CNAME("xin_osc0_func"),
	     CRU_GATE_CON02, 14,
	     0),
	GATE(CGU_CLK_TXESC, CNAME("clk_txesc"), CNAME("xin_osc0_func"),
	     CRU_GATE_CON02, 12,
	     0),
};

static const struct clk_composite_data rk628_clk_composites[] = {
	COMPOSITE(CGU_CLK_IMODET, CNAME("clk_imodet"), mux_cpll_gpll_mux_p,
		  CRU_CLKSEL_CON05, 5, 1,
		  CRU_CLKSEL_CON05, 0, 5,
		  CRU_GATE_CON02, 11,
		  0),
	COMPOSITE(CGU_CLK_HDMIRX_AUD, CNAME("clk_hdmirx_aud"),
		  mux_cpll_gpll_mux_p,
		  CRU_CLKSEL_CON05, 15, 1,
		  CRU_CLKSEL_CON05, 6, 8,
		  CRU_GATE_CON02, 10,
		  CLK_SET_RATE_NO_REPARENT | CLK_SET_RATE_PARENT),
	COMPOSITE_FRAC_NOMUX(CGU_CLK_HDMIRX_CEC, CNAME("clk_hdmirx_cec"),
			     CNAME("xin_osc0_func"),
			     CRU_CLKSEL_CON12,
			     CRU_GATE_CON01, 15,
			     0),
	COMPOSITE_FRAC(CGU_CLK_RX_READ, CNAME("clk_rx_read"),
		       mux_cpll_gpll_mux_p,
		       CRU_CLKSEL_CON02, 8, 1,
		       CRU_CLKSEL_CON14,
		       CRU_GATE_CON00, 11,
		       0),
	COMPOSITE_FRAC(CGU_SCLK_VOP, CNAME("sclk_vop"), mux_cpll_gpll_mux_p,
		       CRU_CLKSEL_CON02, 9, 1,
		       CRU_CLKSEL_CON13,
		       CRU_GATE_CON00, 13,
		       CLK_SET_RATE_NO_REPARENT),
	COMPOSITE(CGU_PCLK_LOGIC, CNAME("pclk_logic"), mux_cpll_gpll_mux_p,
		  CRU_CLKSEL_CON00, 7, 1,
		  CRU_CLKSEL_CON00, 0, 5,
		  CRU_GATE_CON00, 0,
		  0),
	COMPOSITE_NOMUX(CGU_CLK_GPIO_DB0, CNAME("clk_gpio_db0"),
			CNAME("xin_osc0_func"),
			CRU_CLKSEL_CON08, 0, 10,
			CRU_GATE_CON01, 4,
			0),
	COMPOSITE_NOMUX(CGU_CLK_GPIO_DB1, CNAME("clk_gpio_db1"),
			CNAME("xin_osc0_func"),
			CRU_CLKSEL_CON09, 0, 10,
			CRU_GATE_CON01, 5,
			0),
	COMPOSITE_NOMUX(CGU_CLK_GPIO_DB2, CNAME("clk_gpio_db2"),
			CNAME("xin_osc0_func"),
			CRU_CLKSEL_CON10, 0, 10,
			CRU_GATE_CON01, 6,
			0),
	COMPOSITE_NOMUX(CGU_CLK_GPIO_DB3, CNAME("clk_gpio_db3"),
			CNAME("xin_osc0_func"),
			CRU_CLKSEL_CON11, 0, 10,
			CRU_GATE_CON01, 7,
			0),
	COMPOSITE(CGU_CLK_I2S_8CH_SRC, CNAME("clk_i2s_8ch_src"),
		  mux_cpll_gpll_mux_p,
		  CRU_CLKSEL_CON03, 13, 1,
		  CRU_CLKSEL_CON03, 8, 5,
		  CRU_GATE_CON03, 9,
		  0),
	COMPOSITE_FRAC_NOMUX(CGU_CLK_I2S_8CH_FRAC, CNAME("clk_i2s_8ch_frac"),
			     CNAME("clk_i2s_8ch_src"),
			     CRU_CLKSEL_CON04,
			     CRU_GATE_CON03, 10,
			     0),
	COMPOSITE_NODIV(CGU_MCLK_I2S_8CH, CNAME("mclk_i2s_8ch"),
			mux_mclk_i2s_8ch_p,
			CRU_CLKSEL_CON03, 14, 2,
			CRU_GATE_CON03, 11,
			CLK_SET_RATE_PARENT),
	COMPOSITE_NODIV(CGU_I2S_MCLKOUT, CNAME("i2s_mclkout"),
			mux_i2s_mclkout_p,
			CRU_CLKSEL_CON03, 7, 1,
			CRU_GATE_CON03, 12,
			CLK_SET_RATE_PARENT),
	COMPOSITE(CGU_BT1120DEC, CNAME("clk_bt1120dec"), mux_cpll_gpll_mux_p,
		  CRU_CLKSEL_CON02, 7, 1,
		  CRU_CLKSEL_CON02, 0, 5,
		  CRU_GATE_CON00, 12,
		  0),
	COMPOSITE(CGU_CLK_TESTOUT, CNAME("clk_testout"), mux_clk_testout_p,
		  CRU_CLKSEL_CON06, 0, 4,
		  CRU_CLKSEL_CON06, 8, 6,
		  CRU_GATE_CON04, 7,
		  0),
};

static void rk628_clk_add_lookup(struct rk628_cru *cru, struct clk *clk,
				 unsigned int id)
{
	if (cru->clk_data.clks && id)
		cru->clk_data.clks[id] = clk;
}

static void rk628_clk_register_muxes(struct rk628_cru *cru)
{
	struct clk *clk;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(rk628_clk_muxes); i++) {
		const struct clk_mux_data *data = &rk628_clk_muxes[i];

		clk = devm_clk_regmap_register_mux(cru->dev, data->name,
						   data->parent_names,
						   data->num_parents,
						   cru->regmap, data->reg,
						   data->shift, data->width,
						   data->flags);
		if (IS_ERR(clk)) {
			dev_err(cru->dev, "failed to register clock %s\n",
				data->name);
			continue;
		}

		rk628_clk_add_lookup(cru, clk, data->id);
	}
}

static void rk628_clk_register_gates(struct rk628_cru *cru)
{
	struct clk *clk;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(rk628_clk_gates); i++) {
		const struct clk_gate_data *data = &rk628_clk_gates[i];

		clk = devm_clk_regmap_register_gate(cru->dev, data->name,
						    data->parent_name,
						    cru->regmap,
						    data->reg, data->shift,
						    data->flags);
		if (IS_ERR(clk)) {
			dev_err(cru->dev, "failed to register clock %s\n",
				data->name);
			continue;
		}

		rk628_clk_add_lookup(cru, clk, data->id);
	}
}

static void rk628_clk_register_composites(struct rk628_cru *cru)
{
	struct clk *clk;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(rk628_clk_composites); i++) {
		const struct clk_composite_data *data =
					&rk628_clk_composites[i];

		clk = devm_clk_regmap_register_composite(cru->dev, data->name,
							 data->parent_names,
							 data->num_parents,
							 cru->regmap,
							 data->mux_reg,
							 data->mux_shift,
							 data->mux_width,
							 data->div_reg,
							 data->div_shift,
							 data->div_width,
							 data->div_flags,
							 data->gate_reg,
							 data->gate_shift,
							 data->flags);
		if (IS_ERR(clk)) {
			dev_err(cru->dev, "failed to register clock %s\n",
				data->name);
			continue;
		}

		rk628_clk_add_lookup(cru, clk, data->id);
	}
}

static void rk628_clk_register_plls(struct rk628_cru *cru)
{
	struct clk *clk;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(rk628_clk_plls); i++) {
		const struct clk_pll_data *data = &rk628_clk_plls[i];

		clk = devm_clk_regmap_register_pll(cru->dev, data->name,
						   data->parent_name,
						   cru->regmap,
						   data->reg,
						   data->pd_shift,
						   data->dsmpd_shift,
						   data->lock_shift,
						   data->flags);
		if (IS_ERR(clk)) {
			dev_err(cru->dev, "failed to register clock %s\n",
				data->name);
			continue;
		}

		rk628_clk_add_lookup(cru, clk, data->id);
	}
}

struct rk628_rgu_data {
	unsigned int id;
	unsigned int reg;
	unsigned int bit;
};

#define RSTGEN(_id, _reg, _bit)	\
	{	\
		.id = (_id),	\
		.reg = (_reg),	\
		.bit = (_bit),	\
	}

static const struct rk628_rgu_data rk628_rgu_data[] = {
	RSTGEN(RGU_LOGIC,	CRU_SOFTRST_CON00,  0),
	RSTGEN(RGU_CRU,		CRU_SOFTRST_CON00,  1),
	RSTGEN(RGU_REGFILE,	CRU_SOFTRST_CON00,  2),
	RSTGEN(RGU_I2C2APB,	CRU_SOFTRST_CON00,  3),
	RSTGEN(RGU_EFUSE,	CRU_SOFTRST_CON00,  5),
	RSTGEN(RGU_ADAPTER,	CRU_SOFTRST_CON00,  7),
	RSTGEN(RGU_CLK_RX,	CRU_SOFTRST_CON00, 11),
	RSTGEN(RGU_BT1120DEC,	CRU_SOFTRST_CON00, 12),
	RSTGEN(RGU_VOP,		CRU_SOFTRST_CON00, 13),

	RSTGEN(RGU_GPIO0,	CRU_SOFTRST_CON01,  0),
	RSTGEN(RGU_GPIO1,	CRU_SOFTRST_CON01,  1),
	RSTGEN(RGU_GPIO2,	CRU_SOFTRST_CON01,  2),
	RSTGEN(RGU_GPIO3,	CRU_SOFTRST_CON01,  3),
	RSTGEN(RGU_GPIO_DB0,	CRU_SOFTRST_CON01,  4),
	RSTGEN(RGU_GPIO_DB1,	CRU_SOFTRST_CON01,  5),
	RSTGEN(RGU_GPIO_DB2,	CRU_SOFTRST_CON01,  6),
	RSTGEN(RGU_GPIO_DB3,	CRU_SOFTRST_CON01,  7),

	RSTGEN(RGU_RXPHY,	CRU_SOFTRST_CON02,  0),
	RSTGEN(RGU_HDMIRX,	CRU_SOFTRST_CON02,  2),
	RSTGEN(RGU_TXPHY_CON,	CRU_SOFTRST_CON02,  3),
	RSTGEN(RGU_HDMITX,	CRU_SOFTRST_CON02,  4),
	RSTGEN(RGU_GVIHOST,	CRU_SOFTRST_CON02,  5),
	RSTGEN(RGU_DSI0,	CRU_SOFTRST_CON02,  6),
	RSTGEN(RGU_DSI1,	CRU_SOFTRST_CON02,  7),
	RSTGEN(RGU_CSI,		CRU_SOFTRST_CON02,  8),
	RSTGEN(RGU_TXDATA,	CRU_SOFTRST_CON02,  9),
	RSTGEN(RGU_DECODER,	CRU_SOFTRST_CON02, 10),
	RSTGEN(RGU_ENCODER,	CRU_SOFTRST_CON02, 11),
	RSTGEN(RGU_HDMIRX_PON,	CRU_SOFTRST_CON02, 12),
	RSTGEN(RGU_TXBYTEHS,	CRU_SOFTRST_CON02, 13),
	RSTGEN(RGU_TXESC,	CRU_SOFTRST_CON02, 14),
};

static int rk628_rgu_update(struct rk628_cru *cru, unsigned long id, int assert)
{
	const struct rk628_rgu_data *data = &rk628_rgu_data[id];

	return regmap_write(cru->regmap, data->reg,
			    BIT(data->bit + 16) | (assert << data->bit));
}

static int rk628_rgu_assert(struct reset_controller_dev *rcdev,
			    unsigned long id)
{
	struct rk628_cru *cru = reset_to_cru(rcdev);

	return rk628_rgu_update(cru, id, 1);
}

static int rk628_rgu_deassert(struct reset_controller_dev *rcdev,
			      unsigned long id)
{
	struct rk628_cru *cru = reset_to_cru(rcdev);

	return rk628_rgu_update(cru, id, 0);
}

static struct reset_control_ops rk628_rgu_ops = {
	.assert = rk628_rgu_assert,
	.deassert = rk628_rgu_deassert,
};

static int rk628_reset_controller_register(struct rk628_cru *cru)
{
	struct device *dev = cru->dev;

	cru->rcdev.owner = THIS_MODULE;
	cru->rcdev.nr_resets =  ARRAY_SIZE(rk628_rgu_data);
	cru->rcdev.of_node = dev->of_node;
	cru->rcdev.ops = &rk628_rgu_ops;

	return devm_reset_controller_register(dev, &cru->rcdev);
}

static const struct regmap_range rk628_cru_readable_ranges[] = {
	regmap_reg_range(CRU_CPLL_CON0, CRU_CPLL_CON4),
	regmap_reg_range(CRU_GPLL_CON0, CRU_GPLL_CON4),
	regmap_reg_range(CRU_MODE_CON, CRU_MODE_CON),
	regmap_reg_range(CRU_CLKSEL_CON00, CRU_CLKSEL_CON21),
	regmap_reg_range(CRU_GATE_CON00, CRU_GATE_CON05),
	regmap_reg_range(CRU_SOFTRST_CON00, CRU_SOFTRST_CON04),
};

static const struct regmap_access_table rk628_cru_readable_table = {
	.yes_ranges     = rk628_cru_readable_ranges,
	.n_yes_ranges   = ARRAY_SIZE(rk628_cru_readable_ranges),
};

static const struct regmap_config rk628_cru_regmap_config = {
	.name = "cru",
	.reg_bits = 32,
	.val_bits = 32,
	.reg_stride = 4,
	.max_register = CRU_MAX_REGISTER,
	.reg_format_endian = REGMAP_ENDIAN_LITTLE,
	.val_format_endian = REGMAP_ENDIAN_LITTLE,
	.rd_table = &rk628_cru_readable_table,
};

static void rk628_cru_init(struct rk628_cru *cru)
{
	u32 val = 0;
	u8 mcu_mode;

	regmap_read(cru->parent->grf, GRF_SYSTEM_STATUS0, &val);
	mcu_mode = (val & I2C_ONLY_FLAG) ? 0 : 1;
	if (mcu_mode)
		return;

	/* clock switch and first set gpll almost 99MHz */
	regmap_write(cru->regmap, CRU_GPLL_CON0, 0xffff701d);
	usleep_range(1000, 1100);
	/* set clk_gpll_mux from gpll */
	regmap_write(cru->regmap, CRU_MODE_CON, 0xffff0004);
	usleep_range(1000, 1100);
	/* set pclk_logic from clk_gpll_mux and set pclk div 4 */
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff0080);
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff0083);
	/* set cpll almost 400MHz */
	regmap_write(cru->regmap, CRU_CPLL_CON0, 0xffff3063);
	usleep_range(1000, 1100);
	/* set clk_cpll_mux from clk_cpll */
	regmap_write(cru->regmap, CRU_MODE_CON, 0xffff0005);
	/* set pclk use cpll, now div is 4 */
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff0003);
	/* set pclk use cpll, now div is 12 */
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff000b);
	/* gpll 983.04MHz */
	regmap_write(cru->regmap, CRU_GPLL_CON0, 0xffff1028);
	usleep_range(1000, 1100);
	/* set pclk use gpll, nuw div is 0xb */
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff008b);
	/* set cpll 1188MHz */
	regmap_write(cru->regmap, CRU_CPLL_CON0, 0xffff1063);
	usleep_range(1000, 1100);
	/* set pclk use cpll, and set pclk 99MHz */
	regmap_write(cru->regmap, CRU_CLKSEL_CON00, 0xff000b);
}

static int rk628_cru_probe(struct platform_device *pdev)
{
	struct rk628 *rk628 = dev_get_drvdata(pdev->dev.parent);
	struct device *dev = &pdev->dev;
	struct rk628_cru *cru;
	struct clk **clk_table;
	unsigned int i;
	int ret;

	cru = devm_kzalloc(dev, sizeof(*cru), GFP_KERNEL);
	if (!cru)
		return -ENOMEM;

	cru->dev = dev;
	cru->parent = rk628;
	platform_set_drvdata(pdev, cru);

	cru->regmap = devm_regmap_init_i2c(rk628->client,
					   &rk628_cru_regmap_config);
	if (IS_ERR(cru->regmap)) {
		ret = PTR_ERR(cru->regmap);
		dev_err(dev, "failed to allocate register map: %d\n", ret);
		return ret;
	}

	rk628_cru_init(cru);

	clk_table = devm_kcalloc(dev, CGU_NR_CLKS, sizeof(struct clk *),
				 GFP_KERNEL);
	if (!clk_table)
		return -ENOMEM;

	for (i = 0; i < CGU_NR_CLKS; i++)
		clk_table[i] = ERR_PTR(-ENOENT);

	cru->clk_data.clks = clk_table;
	cru->clk_data.clk_num = CGU_NR_CLKS;

	rk628_clk_register_plls(cru);
	rk628_clk_register_muxes(cru);
	rk628_clk_register_gates(cru);
	rk628_clk_register_composites(cru);
	rk628_reset_controller_register(cru);

	clk_prepare_enable(clk_table[CGU_PCLK_LOGIC]);

	return of_clk_add_provider(dev->of_node, of_clk_src_onecell_get,
				   &cru->clk_data);
}

static int rk628_cru_remove(struct platform_device *pdev)
{
	of_clk_del_provider(pdev->dev.of_node);

	return 0;
}

static const struct of_device_id rk628_cru_of_match[] = {
	{ .compatible = "rockchip,rk628-cru", },
	{},
};
MODULE_DEVICE_TABLE(of, rk628_cru_of_match);

static struct platform_driver rk628_cru_driver = {
	.driver = {
		.name = "rk628-cru",
		.of_match_table = of_match_ptr(rk628_cru_of_match),
	},
	.probe	= rk628_cru_probe,
	.remove = rk628_cru_remove,
};
module_platform_driver(rk628_cru_driver);

MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>");
MODULE_DESCRIPTION("Rockchip RK628 CRU driver");
MODULE_LICENSE("GPL v2");