pll/edp_pll_28hpm.c - kernel/msm-extra/display-drivers - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
  */

 #define pr_fmt(fmt)	"%s: " fmt, __func__

 #include <linux/kernel.h>
 #include <linux/err.h>
 #include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/iopoll.h>
 #include <linux/clk/msm-clk-provider.h>
 #include <linux/clk/msm-clk.h>
 #include <linux/clk/msm-clock-generic.h>

 #include <dt-bindings/clock/msm-clocks-8974.h>

 #include "pll_drv.h"
 #include "edp_pll.h"

 #define EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG	(0x0)
 #define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG	(0x0004)
 #define EDP_PHY_PLL_UNIPHY_PLL_VCOLPF_CFG	(0x000C)
 #define EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG		(0x0020)
 #define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG	(0x0024)
 #define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG	(0x0028)
 #define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0		(0x0038)
 #define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1		(0x003C)
 #define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2		(0x0040)
 #define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3		(0x0044)
 #define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4		(0x0048)
 #define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0		(0x004C)
 #define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1		(0x0050)
 #define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2		(0x0054)
 #define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3		(0x0058)
 #define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2	(0x0064)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0		(0x006C)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2		(0x0074)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6		(0x0084)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7		(0x0088)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8		(0x008C)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9		(0x0090)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10	(0x0094)
 #define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11	(0x0098)
 #define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0	(0x005C)
 #define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1	(0x0060)

 #define EDP_PLL_POLL_DELAY_US			50
 #define EDP_PLL_POLL_TIMEOUT_US			500

 static const struct clk_ops edp_mainlink_clk_src_ops;
 static struct clk_div_ops fixed_5div_ops; /* null ops */
 static const struct clk_ops edp_pixel_clk_ops;

 static inline struct edp_pll_vco_clk *to_edp_vco_clk(struct clk *clk)
 {
 	return container_of(clk, struct edp_pll_vco_clk, c);
 }

 int edp_div_prepare(struct clk *c)
 {
 	struct div_clk *div = to_div_clk(c);
 	/* Restore the divider's value */
 	return div->ops->set_div(div, div->data.div);
 }

 static int edp_vco_set_rate(struct clk *c, unsigned long vco_rate)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	struct mdss_pll_resources *edp_pll_res = vco->priv;
 	int rc;

 	pr_debug("vco_rate=%d\n", (int)vco_rate);

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("failed to enable edp pll res rc=%d\n", rc);
 		rc =  -EINVAL;
 	}

 	if (vco_rate == 810000000) {
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_VCOLPF_CFG, 0x18);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2, 0x0d);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0, 0x36);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1, 0x69);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2, 0xff);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3, 0x2f);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0, 0x80);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0, 0x12);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2, 0x01);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6, 0x5a);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7, 0x0);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8, 0x60);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9, 0x0);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10, 0x2a);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11, 0x3);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0, 0x10);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1, 0x1a);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG, 0x00);
 	} else if (vco_rate == 1350000000) {
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2, 0x0d);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG, 0x01);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0, 0x36);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1, 0x62);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3, 0x28);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0, 0x80);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0, 0x12);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2, 0x01);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6, 0x5a);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7, 0x0);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8, 0x60);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9, 0x0);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10, 0x46);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11, 0x5);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0, 0x10);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1, 0x1a);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG, 0x00);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG, 0x00);
 	} else {
 		pr_err("rate=%d is NOT supported\n", (int)vco_rate);
 		vco_rate = 0;
 		rc =  -EINVAL;
 	}

 	MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x01);
 	udelay(100);
 	MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x05);
 	udelay(100);
 	MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x07);
 	udelay(100);
 	MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x0f);
 	udelay(100);
 	mdss_pll_resource_enable(edp_pll_res, false);

 	vco->rate = vco_rate;

 	return rc;
 }

 static int edp_pll_ready_poll(struct mdss_pll_resources *edp_pll_res)
 {
 	int cnt;
 	u32 status;

 	cnt = 100;
 	while (cnt--) {
 		udelay(100);
 		status = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0xc0);
 		status &= 0x01;
 		if (status)
 			break;
 	}
 	pr_debug("cnt=%d status=%d\n", cnt, (int)status);

 	if (status)
 		return 1;

 	return 0;
 }

 static int edp_vco_enable(struct clk *c)
 {
 	int i, ready;
 	int rc;
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	struct mdss_pll_resources *edp_pll_res = vco->priv;

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("edp pll resources not available\n");
 		return rc;
 	}

 	for (i = 0; i < 3; i++) {
 		ready = edp_pll_ready_poll(edp_pll_res);
 		if (ready)
 			break;
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x01);
 		udelay(100);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x05);
 		udelay(100);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x07);
 		udelay(100);
 		MDSS_PLL_REG_W(edp_pll_res->pll_base,
 					EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x0f);
 		udelay(100);
 	}

 	if (ready) {
 		pr_debug("EDP PLL lock success\n");
 		edp_pll_res->pll_on = true;
 		rc = 0;
 	} else {
 		pr_err("EDP PLL failed to lock\n");
 		mdss_pll_resource_enable(edp_pll_res, false);
 		rc = -EINVAL;
 	}

 	return rc;
 }

 static void edp_vco_disable(struct clk *c)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	struct mdss_pll_resources *edp_pll_res = vco->priv;

 	if (!edp_pll_res) {
 		pr_err("Invalid input parameter\n");
 		return;
 	}

 	if (!edp_pll_res->pll_on &&
 		mdss_pll_resource_enable(edp_pll_res, true)) {
 		pr_err("edp pll resources not available\n");
 		return;
 	}

 	MDSS_PLL_REG_W(edp_pll_res->pll_base, 0x20, 0x00);

 	edp_pll_res->handoff_resources = false;
 	edp_pll_res->pll_on = false;

 	mdss_pll_resource_enable(edp_pll_res, false);

 	pr_debug("EDP PLL Disabled\n");
 }

 static unsigned long edp_vco_get_rate(struct clk *c)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	struct mdss_pll_resources *edp_pll_res = vco->priv;
 	u32 pll_status, div2;
 	int rc;

 	if (is_gdsc_disabled(edp_pll_res))
 		return 0;

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("edp pll resources not available\n");
 		return rc;
 	}

 	if (vco->rate == 0) {
 		pll_status = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0xc0);
 		if (pll_status & 0x01) {
 			div2 = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0x24);
 			if (div2 & 0x01)
 				vco->rate = 1350000000;
 			else
 				vco->rate = 810000000;
 		}
 	}
 	mdss_pll_resource_enable(edp_pll_res, false);

 	pr_debug("rate=%d\n", (int)vco->rate);

 	return vco->rate;
 }

 static long edp_vco_round_rate(struct clk *c, unsigned long rate)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	unsigned long rrate = -ENOENT;
 	unsigned long *lp;

 	lp = vco->rate_list;
 	while (*lp) {
 		rrate = *lp;
 		if (rate <= rrate)
 			break;
 		lp++;
 	}

 	pr_debug("rrate=%d\n", (int)rrate);

 	return rrate;
 }

 static int edp_vco_prepare(struct clk *c)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);

 	pr_debug("rate=%d\n", (int)vco->rate);

 	return edp_vco_set_rate(c, vco->rate);
 }

 static void edp_vco_unprepare(struct clk *c)
 {
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);

 	pr_debug("rate=%d\n", (int)vco->rate);

 	edp_vco_disable(c);
 }

 static int edp_pll_lock_status(struct mdss_pll_resources *edp_pll_res)
 {
 	u32 status;
 	int pll_locked = 0;
 	int rc;

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("edp pll resources not available\n");
 		return rc;
 	}

 	/* poll for PLL ready status */
 	if (readl_poll_timeout_atomic((edp_pll_res->pll_base + 0xc0),
 			status, ((status & BIT(0)) == 1),
 			EDP_PLL_POLL_DELAY_US,
 			EDP_PLL_POLL_TIMEOUT_US)) {
 		pr_debug("EDP PLL status=%x failed to Lock\n", status);
 		pll_locked = 0;
 	} else {
 		pll_locked = 1;
 	}
 	mdss_pll_resource_enable(edp_pll_res, false);

 	return pll_locked;
 }

 static enum handoff edp_vco_handoff(struct clk *c)
 {
 	enum handoff ret = HANDOFF_DISABLED_CLK;
 	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
 	struct mdss_pll_resources *edp_pll_res = vco->priv;

 	if (is_gdsc_disabled(edp_pll_res))
 		return HANDOFF_DISABLED_CLK;

 	if (mdss_pll_resource_enable(edp_pll_res, true)) {
 		pr_err("edp pll resources not available\n");
 		return ret;
 	}

 	edp_pll_res->handoff_resources = true;

 	if (edp_pll_lock_status(edp_pll_res)) {
 		c->rate = edp_vco_get_rate(c);
 		edp_pll_res->pll_on = true;
 		ret = HANDOFF_ENABLED_CLK;
 	} else {
 		edp_pll_res->handoff_resources = false;
 		mdss_pll_resource_enable(edp_pll_res, false);
 	}

 	pr_debug("done, ret=%d\n", ret);
 	return ret;
 }

 static unsigned long edp_vco_rate_list[] = {
 		810000000, 1350000000, 0};

 struct const clk_ops edp_vco_clk_ops = {
 	.enable = edp_vco_enable,
 	.set_rate = edp_vco_set_rate,
 	.get_rate = edp_vco_get_rate,
 	.round_rate = edp_vco_round_rate,
 	.prepare = edp_vco_prepare,
 	.unprepare = edp_vco_unprepare,
 	.handoff = edp_vco_handoff,
 };

 struct edp_pll_vco_clk edp_vco_clk = {
 	.ref_clk_rate = 19200000,
 	.rate = 0,
 	.rate_list = edp_vco_rate_list,
 	.c = {
 		.dbg_name = "edp_vco_clk",
 		.ops = &edp_vco_clk_ops,
 		CLK_INIT(edp_vco_clk.c),
 	},
 };

 static unsigned long edp_mainlink_get_rate(struct clk *c)
 {
 	struct div_clk *mclk = to_div_clk(c);
 	struct clk *pclk;
 	unsigned long rate = 0;

 	pclk = clk_get_parent(c);

 	if (pclk && pclk->ops->get_rate) {
 		rate = pclk->ops->get_rate(pclk);
 		rate /= mclk->data.div;
 	}

 	pr_debug("rate=%d div=%d\n", (int)rate, mclk->data.div);

 	return rate;
 }


 struct div_clk edp_mainlink_clk_src = {
 	.ops = &fixed_5div_ops,
 	.data = {
 		.div = 5,
 		.min_div = 5,
 		.max_div = 5,
 	},
 	.c = {
 		.parent = &edp_vco_clk.c,
 		.dbg_name = "edp_mainlink_clk_src",
 		.ops = &edp_mainlink_clk_src_ops,
 		.flags = CLKFLAG_NO_RATE_CACHE,
 		CLK_INIT(edp_mainlink_clk_src.c),
 	}
 };

 /*
  * this rate is from pll to clock controller
  * output from pll to CC has two possibilities
  * 1: if mainlink rate is 270M, then 675M
  * 2: if mainlink rate is 162M, then 810M
  */
 static int edp_pixel_set_div(struct div_clk *clk, int div)
 {
 	int rc;
 	struct mdss_pll_resources *edp_pll_res = clk->priv;

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("edp pll resources not available\n");
 		return rc;
 	}

 	pr_debug("div=%d\n", div);
 	MDSS_PLL_REG_W(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG, (div - 1));
 	mdss_pll_resource_enable(edp_pll_res, false);

 	return 0;
 }

 static int edp_pixel_get_div(struct div_clk *clk)
 {
 	int div = 0;
 	int rc;
 	struct mdss_pll_resources *edp_pll_res = clk->priv;

 	if (is_gdsc_disabled(edp_pll_res))
 		return 0;

 	rc = mdss_pll_resource_enable(edp_pll_res, true);
 	if (rc) {
 		pr_err("edp pll resources not available\n");
 		return rc;
 	}

 	div = MDSS_PLL_REG_R(edp_pll_res->pll_base,
 				EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG);
 	mdss_pll_resource_enable(edp_pll_res, false);
 	div &= 0x01;
 	pr_debug("div=%d\n", div);
 	return div + 1;
 }

 static struct clk_div_ops edp_pixel_ops = {
 	.set_div = edp_pixel_set_div,
 	.get_div = edp_pixel_get_div,
 };

 struct div_clk edp_pixel_clk_src = {
 	.data = {
 		.max_div = 2,
 		.min_div = 1,
 	},
 	.ops = &edp_pixel_ops,
 	.c = {
 		.parent = &edp_vco_clk.c,
 		.dbg_name = "edp_pixel_clk_src",
 		.ops = &edp_pixel_clk_ops,
 		.flags = CLKFLAG_NO_RATE_CACHE,
 		CLK_INIT(edp_pixel_clk_src.c),
 	},
 };

 static struct clk_lookup mdss_edp_pllcc_8974[] = {
 	CLK_LOOKUP("edp_pixel_src", edp_pixel_clk_src.c,
 						"fd8c0000.qcom,mmsscc-mdss"),
 	CLK_LOOKUP("edp_mainlink_src", edp_mainlink_clk_src.c,
 						"fd8c0000.qcom,mmsscc-mdss"),
 };

 int edp_pll_clock_register(struct platform_device *pdev,
 				struct mdss_pll_resources *pll_res)
 {
 	int rc = -ENOTSUPP;

 	/* Set client data to div and vco clocks */
 	edp_pixel_clk_src.priv = pll_res;
 	edp_mainlink_clk_src.priv = pll_res;
 	edp_vco_clk.priv = pll_res;

 	/* Set clock operation for mainlink and pixel clock */
 	edp_mainlink_clk_src_ops = clk_ops_div;
 	edp_mainlink_clk_src_ops.get_parent = clk_get_parent;
 	edp_mainlink_clk_src_ops.get_rate = edp_mainlink_get_rate;

 	edp_pixel_clk_ops = clk_ops_slave_div;
 	edp_pixel_clk_ops.prepare = edp_div_prepare;

 	rc = of_msm_clock_register(pdev->dev.of_node, mdss_edp_pllcc_8974,
 					 ARRAY_SIZE(mdss_edp_pllcc_8974));
 	if (rc) {
 		pr_err("Clock register failed rc=%d\n", rc);
 		rc = -EPROBE_DEFER;
 	}

 	return rc;
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
	*/

	#define pr_fmt(fmt) "%s: " fmt, __func__

	#include <linux/kernel.h>
	#include <linux/err.h>
	#include <linux/delay.h>
	#include <linux/clk.h>
	#include <linux/iopoll.h>
	#include <linux/clk/msm-clk-provider.h>
	#include <linux/clk/msm-clk.h>
	#include <linux/clk/msm-clock-generic.h>

	#include <dt-bindings/clock/msm-clocks-8974.h>

	#include "pll_drv.h"
	#include "edp_pll.h"

	#define EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG (0x0)
	#define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG (0x0004)
	#define EDP_PHY_PLL_UNIPHY_PLL_VCOLPF_CFG (0x000C)
	#define EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG (0x0020)
	#define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG (0x0024)
	#define EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG (0x0028)
	#define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0 (0x0038)
	#define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1 (0x003C)
	#define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2 (0x0040)
	#define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3 (0x0044)
	#define EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4 (0x0048)
	#define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0 (0x004C)
	#define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1 (0x0050)
	#define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2 (0x0054)
	#define EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3 (0x0058)
	#define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2 (0x0064)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0 (0x006C)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2 (0x0074)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6 (0x0084)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7 (0x0088)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8 (0x008C)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9 (0x0090)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10 (0x0094)
	#define EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11 (0x0098)
	#define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0 (0x005C)
	#define EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1 (0x0060)

	#define EDP_PLL_POLL_DELAY_US 50
	#define EDP_PLL_POLL_TIMEOUT_US 500

	static const struct clk_ops edp_mainlink_clk_src_ops;
	static struct clk_div_ops fixed_5div_ops; /* null ops */
	static const struct clk_ops edp_pixel_clk_ops;

	static inline struct edp_pll_vco_clk to_edp_vco_clk(struct clk clk)
	{
	return container_of(clk, struct edp_pll_vco_clk, c);
	}

	int edp_div_prepare(struct clk *c)
	{
	struct div_clk *div = to_div_clk(c);
	/* Restore the divider's value */
	return div->ops->set_div(div, div->data.div);
	}

	static int edp_vco_set_rate(struct clk *c, unsigned long vco_rate)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	struct mdss_pll_resources *edp_pll_res = vco->priv;
	int rc;

	pr_debug("vco_rate=%d\n", (int)vco_rate);

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("failed to enable edp pll res rc=%d\n", rc);
	rc = -EINVAL;
	}

	if (vco_rate == 810000000) {
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_VCOLPF_CFG, 0x18);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2, 0x0d);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0, 0x36);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1, 0x69);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2, 0xff);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3, 0x2f);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0, 0x80);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0, 0x12);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2, 0x01);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6, 0x5a);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7, 0x0);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8, 0x60);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9, 0x0);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10, 0x2a);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11, 0x3);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0, 0x10);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1, 0x1a);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG, 0x00);
	} else if (vco_rate == 1350000000) {
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG2, 0x0d);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_REFCLK_CFG, 0x01);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG0, 0x36);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG1, 0x62);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG2, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG3, 0x28);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SDM_CFG4, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG0, 0x80);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG1, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG2, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_SSC_CFG3, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG0, 0x12);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG2, 0x01);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG6, 0x5a);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG7, 0x0);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG8, 0x60);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG9, 0x0);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG10, 0x46);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_CAL_CFG11, 0x5);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG0, 0x10);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_LKDET_CFG1, 0x1a);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV1_CFG, 0x00);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV3_CFG, 0x00);
	} else {
	pr_err("rate=%d is NOT supported\n", (int)vco_rate);
	vco_rate = 0;
	rc = -EINVAL;
	}

	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x01);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x05);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x07);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x0f);
	udelay(100);
	mdss_pll_resource_enable(edp_pll_res, false);

	vco->rate = vco_rate;

	return rc;
	}

	static int edp_pll_ready_poll(struct mdss_pll_resources *edp_pll_res)
	{
	int cnt;
	u32 status;

	cnt = 100;
	while (cnt--) {
	udelay(100);
	status = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0xc0);
	status &= 0x01;
	if (status)
	break;
	}
	pr_debug("cnt=%d status=%d\n", cnt, (int)status);

	if (status)
	return 1;

	return 0;
	}

	static int edp_vco_enable(struct clk *c)
	{
	int i, ready;
	int rc;
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	struct mdss_pll_resources *edp_pll_res = vco->priv;

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("edp pll resources not available\n");
	return rc;
	}

	for (i = 0; i < 3; i++) {
	ready = edp_pll_ready_poll(edp_pll_res);
	if (ready)
	break;
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x01);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x05);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x07);
	udelay(100);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_GLB_CFG, 0x0f);
	udelay(100);
	}

	if (ready) {
	pr_debug("EDP PLL lock success\n");
	edp_pll_res->pll_on = true;
	rc = 0;
	} else {
	pr_err("EDP PLL failed to lock\n");
	mdss_pll_resource_enable(edp_pll_res, false);
	rc = -EINVAL;
	}

	return rc;
	}

	static void edp_vco_disable(struct clk *c)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	struct mdss_pll_resources *edp_pll_res = vco->priv;

	if (!edp_pll_res) {
	pr_err("Invalid input parameter\n");
	return;
	}

	if (!edp_pll_res->pll_on &&
	mdss_pll_resource_enable(edp_pll_res, true)) {
	pr_err("edp pll resources not available\n");
	return;
	}

	MDSS_PLL_REG_W(edp_pll_res->pll_base, 0x20, 0x00);

	edp_pll_res->handoff_resources = false;
	edp_pll_res->pll_on = false;

	mdss_pll_resource_enable(edp_pll_res, false);

	pr_debug("EDP PLL Disabled\n");
	}

	static unsigned long edp_vco_get_rate(struct clk *c)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	struct mdss_pll_resources *edp_pll_res = vco->priv;
	u32 pll_status, div2;
	int rc;

	if (is_gdsc_disabled(edp_pll_res))
	return 0;

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("edp pll resources not available\n");
	return rc;
	}

	if (vco->rate == 0) {
	pll_status = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0xc0);
	if (pll_status & 0x01) {
	div2 = MDSS_PLL_REG_R(edp_pll_res->pll_base, 0x24);
	if (div2 & 0x01)
	vco->rate = 1350000000;
	else
	vco->rate = 810000000;
	}
	}
	mdss_pll_resource_enable(edp_pll_res, false);

	pr_debug("rate=%d\n", (int)vco->rate);

	return vco->rate;
	}

	static long edp_vco_round_rate(struct clk *c, unsigned long rate)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	unsigned long rrate = -ENOENT;
	unsigned long *lp;

	lp = vco->rate_list;
	while (*lp) {
	rrate = *lp;
	if (rate <= rrate)
	break;
	lp++;
	}

	pr_debug("rrate=%d\n", (int)rrate);

	return rrate;
	}

	static int edp_vco_prepare(struct clk *c)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);

	pr_debug("rate=%d\n", (int)vco->rate);

	return edp_vco_set_rate(c, vco->rate);
	}

	static void edp_vco_unprepare(struct clk *c)
	{
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);

	pr_debug("rate=%d\n", (int)vco->rate);

	edp_vco_disable(c);
	}

	static int edp_pll_lock_status(struct mdss_pll_resources *edp_pll_res)
	{
	u32 status;
	int pll_locked = 0;
	int rc;

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("edp pll resources not available\n");
	return rc;
	}

	/* poll for PLL ready status */
	if (readl_poll_timeout_atomic((edp_pll_res->pll_base + 0xc0),
	status, ((status & BIT(0)) == 1),
	EDP_PLL_POLL_DELAY_US,
	EDP_PLL_POLL_TIMEOUT_US)) {
	pr_debug("EDP PLL status=%x failed to Lock\n", status);
	pll_locked = 0;
	} else {
	pll_locked = 1;
	}
	mdss_pll_resource_enable(edp_pll_res, false);

	return pll_locked;
	}

	static enum handoff edp_vco_handoff(struct clk *c)
	{
	enum handoff ret = HANDOFF_DISABLED_CLK;
	struct edp_pll_vco_clk *vco = to_edp_vco_clk(c);
	struct mdss_pll_resources *edp_pll_res = vco->priv;

	if (is_gdsc_disabled(edp_pll_res))
	return HANDOFF_DISABLED_CLK;

	if (mdss_pll_resource_enable(edp_pll_res, true)) {
	pr_err("edp pll resources not available\n");
	return ret;
	}

	edp_pll_res->handoff_resources = true;

	if (edp_pll_lock_status(edp_pll_res)) {
	c->rate = edp_vco_get_rate(c);
	edp_pll_res->pll_on = true;
	ret = HANDOFF_ENABLED_CLK;
	} else {
	edp_pll_res->handoff_resources = false;
	mdss_pll_resource_enable(edp_pll_res, false);
	}

	pr_debug("done, ret=%d\n", ret);
	return ret;
	}

	static unsigned long edp_vco_rate_list[] = {
	810000000, 1350000000, 0};

	struct const clk_ops edp_vco_clk_ops = {
	.enable = edp_vco_enable,
	.set_rate = edp_vco_set_rate,
	.get_rate = edp_vco_get_rate,
	.round_rate = edp_vco_round_rate,
	.prepare = edp_vco_prepare,
	.unprepare = edp_vco_unprepare,
	.handoff = edp_vco_handoff,
	};

	struct edp_pll_vco_clk edp_vco_clk = {
	.ref_clk_rate = 19200000,
	.rate = 0,
	.rate_list = edp_vco_rate_list,
	.c = {
	.dbg_name = "edp_vco_clk",
	.ops = &edp_vco_clk_ops,
	CLK_INIT(edp_vco_clk.c),
	},
	};

	static unsigned long edp_mainlink_get_rate(struct clk *c)
	{
	struct div_clk *mclk = to_div_clk(c);
	struct clk *pclk;
	unsigned long rate = 0;

	pclk = clk_get_parent(c);

	if (pclk && pclk->ops->get_rate) {
	rate = pclk->ops->get_rate(pclk);
	rate /= mclk->data.div;
	}

	pr_debug("rate=%d div=%d\n", (int)rate, mclk->data.div);

	return rate;
	}


	struct div_clk edp_mainlink_clk_src = {
	.ops = &fixed_5div_ops,
	.data = {
	.div = 5,
	.min_div = 5,
	.max_div = 5,
	},
	.c = {
	.parent = &edp_vco_clk.c,
	.dbg_name = "edp_mainlink_clk_src",
	.ops = &edp_mainlink_clk_src_ops,
	.flags = CLKFLAG_NO_RATE_CACHE,
	CLK_INIT(edp_mainlink_clk_src.c),
	}
	};

	/*
	* this rate is from pll to clock controller
	* output from pll to CC has two possibilities
	* 1: if mainlink rate is 270M, then 675M
	* 2: if mainlink rate is 162M, then 810M
	*/
	static int edp_pixel_set_div(struct div_clk *clk, int div)
	{
	int rc;
	struct mdss_pll_resources *edp_pll_res = clk->priv;

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("edp pll resources not available\n");
	return rc;
	}

	pr_debug("div=%d\n", div);
	MDSS_PLL_REG_W(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG, (div - 1));
	mdss_pll_resource_enable(edp_pll_res, false);

	return 0;
	}

	static int edp_pixel_get_div(struct div_clk *clk)
	{
	int div = 0;
	int rc;
	struct mdss_pll_resources *edp_pll_res = clk->priv;

	if (is_gdsc_disabled(edp_pll_res))
	return 0;

	rc = mdss_pll_resource_enable(edp_pll_res, true);
	if (rc) {
	pr_err("edp pll resources not available\n");
	return rc;
	}

	div = MDSS_PLL_REG_R(edp_pll_res->pll_base,
	EDP_PHY_PLL_UNIPHY_PLL_POSTDIV2_CFG);
	mdss_pll_resource_enable(edp_pll_res, false);
	div &= 0x01;
	pr_debug("div=%d\n", div);
	return div + 1;
	}

	static struct clk_div_ops edp_pixel_ops = {
	.set_div = edp_pixel_set_div,
	.get_div = edp_pixel_get_div,
	};

	struct div_clk edp_pixel_clk_src = {
	.data = {
	.max_div = 2,
	.min_div = 1,
	},
	.ops = &edp_pixel_ops,
	.c = {
	.parent = &edp_vco_clk.c,
	.dbg_name = "edp_pixel_clk_src",
	.ops = &edp_pixel_clk_ops,
	.flags = CLKFLAG_NO_RATE_CACHE,
	CLK_INIT(edp_pixel_clk_src.c),
	},
	};

	static struct clk_lookup mdss_edp_pllcc_8974[] = {
	CLK_LOOKUP("edp_pixel_src", edp_pixel_clk_src.c,
	"fd8c0000.qcom,mmsscc-mdss"),
	CLK_LOOKUP("edp_mainlink_src", edp_mainlink_clk_src.c,
	"fd8c0000.qcom,mmsscc-mdss"),
	};

	int edp_pll_clock_register(struct platform_device *pdev,
	struct mdss_pll_resources *pll_res)
	{
	int rc = -ENOTSUPP;

	/* Set client data to div and vco clocks */
	edp_pixel_clk_src.priv = pll_res;
	edp_mainlink_clk_src.priv = pll_res;
	edp_vco_clk.priv = pll_res;

	/* Set clock operation for mainlink and pixel clock */
	edp_mainlink_clk_src_ops = clk_ops_div;
	edp_mainlink_clk_src_ops.get_parent = clk_get_parent;
	edp_mainlink_clk_src_ops.get_rate = edp_mainlink_get_rate;

	edp_pixel_clk_ops = clk_ops_slave_div;
	edp_pixel_clk_ops.prepare = edp_div_prepare;

	rc = of_msm_clock_register(pdev->dev.of_node, mdss_edp_pllcc_8974,
	ARRAY_SIZE(mdss_edp_pllcc_8974));
	if (rc) {
	pr_err("Clock register failed rc=%d\n", rc);
	rc = -EPROBE_DEFER;
	}

	return rc;
	}