[ipfire-2.x.git] / src / patches / kernel / omap / 3isp / 0001-omap3isp-Use-the-common-clock-framework.patch

From 369b60c157f67a71a6f302ab9843ae2de1805a2a Mon Sep 17 00:00:00 2001
From: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Date: Mon, 22 Oct 2012 15:43:00 +0200
Subject: [PATCH 1/6] omap3isp: Use the common clock framework

Expose the two ISP external clocks XCLKA and XCLKB as common clocks for
subdev drivers.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Acked-by: Mike Turquette <mturquette@linaro.org>
---
 drivers/media/platform/omap3isp/isp.c |  277 ++++++++++++++++++++++++---------
 drivers/media/platform/omap3isp/isp.h |   22 ++-
 include/media/omap3isp.h              |   10 +-
 3 files changed, 225 insertions(+), 84 deletions(-)

diff --git a/drivers/media/platform/omap3isp/isp.c b/drivers/media/platform/omap3isp/isp.c
index 6e5ad8e..1d7dbd5 100644
--- a/drivers/media/platform/omap3isp/isp.c
+++ b/drivers/media/platform/omap3isp/isp.c
@@ -55,6 +55,7 @@
 #include <asm/cacheflush.h>
 
 #include <linux/clk.h>
+#include <linux/clkdev.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
@@ -148,6 +149,201 @@ void omap3isp_flush(struct isp_device *isp)
 	isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_REVISION);
 }
 
+/* -----------------------------------------------------------------------------
+ * XCLK
+ */
+
+#define to_isp_xclk(_hw)	container_of(_hw, struct isp_xclk, hw)
+
+static void isp_xclk_update(struct isp_xclk *xclk, u32 divider)
+{
+	switch (xclk->id) {
+	case ISP_XCLK_A:
+		isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
+				ISPTCTRL_CTRL_DIVA_MASK,
+				divider << ISPTCTRL_CTRL_DIVA_SHIFT);
+		break;
+	case ISP_XCLK_B:
+		isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
+				ISPTCTRL_CTRL_DIVB_MASK,
+				divider << ISPTCTRL_CTRL_DIVB_SHIFT);
+		break;
+	}
+}
+
+static int isp_xclk_prepare(struct clk_hw *hw)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+
+	omap3isp_get(xclk->isp);
+
+	return 0;
+}
+
+static void isp_xclk_unprepare(struct clk_hw *hw)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+
+	omap3isp_put(xclk->isp);
+}
+
+static int isp_xclk_enable(struct clk_hw *hw)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+	unsigned long flags;
+
+	spin_lock_irqsave(&xclk->lock, flags);
+	isp_xclk_update(xclk, xclk->divider);
+	xclk->enabled = true;
+	spin_unlock_irqrestore(&xclk->lock, flags);
+
+	return 0;
+}
+
+static void isp_xclk_disable(struct clk_hw *hw)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+	unsigned long flags;
+
+	spin_lock_irqsave(&xclk->lock, flags);
+	isp_xclk_update(xclk, 0);
+	xclk->enabled = false;
+	spin_unlock_irqrestore(&xclk->lock, flags);
+}
+
+static unsigned long isp_xclk_recalc_rate(struct clk_hw *hw,
+					  unsigned long parent_rate)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+
+	return parent_rate / xclk->divider;
+}
+
+static u32 isp_xclk_calc_divider(unsigned long *rate, unsigned long parent_rate)
+{
+	u32 divider;
+
+	if (*rate >= parent_rate) {
+		*rate = parent_rate;
+		return ISPTCTRL_CTRL_DIV_BYPASS;
+	}
+
+	divider = DIV_ROUND_CLOSEST(parent_rate, *rate);
+	if (divider >= ISPTCTRL_CTRL_DIV_BYPASS)
+		divider = ISPTCTRL_CTRL_DIV_BYPASS - 1;
+
+	*rate = parent_rate / divider;
+	return divider;
+}
+
+static long isp_xclk_round_rate(struct clk_hw *hw, unsigned long rate,
+				unsigned long *parent_rate)
+{
+	isp_xclk_calc_divider(&rate, *parent_rate);
+	return rate;
+}
+
+static int isp_xclk_set_rate(struct clk_hw *hw, unsigned long rate,
+			     unsigned long parent_rate)
+{
+	struct isp_xclk *xclk = to_isp_xclk(hw);
+	unsigned long flags;
+	u32 divider;
+
+	divider = isp_xclk_calc_divider(&rate, parent_rate);
+
+	spin_lock_irqsave(&xclk->lock, flags);
+
+	xclk->divider = divider;
+	if (xclk->enabled)
+		isp_xclk_update(xclk, divider);
+
+	spin_unlock_irqrestore(&xclk->lock, flags);
+
+	dev_dbg(xclk->isp->dev, "%s: cam_xclk%c set to %lu Hz (div %u)\n",
+		__func__, xclk->id == ISP_XCLK_A ? 'a' : 'b', rate, divider);
+	return 0;
+}
+
+static const struct clk_ops isp_xclk_ops = {
+	.prepare = isp_xclk_prepare,
+	.unprepare = isp_xclk_unprepare,
+	.enable = isp_xclk_enable,
+	.disable = isp_xclk_disable,
+	.recalc_rate = isp_xclk_recalc_rate,
+	.round_rate = isp_xclk_round_rate,
+	.set_rate = isp_xclk_set_rate,
+};
+
+static const char *isp_xclk_parent_name = "cam_mclk";
+
+static const struct clk_init_data isp_xclk_init_data = {
+	.name = "cam_xclk",
+	.ops = &isp_xclk_ops,
+	.parent_names = &isp_xclk_parent_name,
+	.num_parents = 1,
+};
+
+static int isp_xclk_init(struct isp_device *isp)
+{
+	struct isp_platform_data *pdata = isp->pdata;
+	struct clk_init_data init;
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) {
+		struct isp_xclk *xclk = &isp->xclks[i];
+		struct clk *clk;
+
+		xclk->isp = isp;
+		xclk->id = i == 0 ? ISP_XCLK_A : ISP_XCLK_B;
+		xclk->divider = 1;
+		spin_lock_init(&xclk->lock);
+
+		init.name = i == 0 ? "cam_xclka" : "cam_xclkb";
+		init.ops = &isp_xclk_ops;
+		init.parent_names = &isp_xclk_parent_name;
+		init.num_parents = 1;
+
+		xclk->hw.init = &init;
+
+		clk = devm_clk_register(isp->dev, &xclk->hw);
+		if (IS_ERR(clk))
+			return PTR_ERR(clk);
+
+		if (pdata->xclks[i].con_id == NULL &&
+		    pdata->xclks[i].dev_id == NULL)
+			continue;
+
+		xclk->lookup = kzalloc(sizeof(*xclk->lookup), GFP_KERNEL);
+		if (xclk->lookup == NULL)
+			return -ENOMEM;
+
+		xclk->lookup->con_id = pdata->xclks[i].con_id;
+		xclk->lookup->dev_id = pdata->xclks[i].dev_id;
+		xclk->lookup->clk = clk;
+
+		clkdev_add(xclk->lookup);
+	}
+
+	return 0;
+}
+
+static void isp_xclk_cleanup(struct isp_device *isp)
+{
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) {
+		struct isp_xclk *xclk = &isp->xclks[i];
+
+		if (xclk->lookup)
+			clkdev_drop(xclk->lookup);
+	}
+}
+
+/* -----------------------------------------------------------------------------
+ * Interrupts
+ */
+
 /*
  * isp_enable_interrupts - Enable ISP interrupts.
  * @isp: OMAP3 ISP device
@@ -180,80 +376,6 @@ static void isp_disable_interrupts(struct isp_device *isp)
 	isp_reg_writel(isp, 0, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE);
 }
 
-/**
- * isp_set_xclk - Configures the specified cam_xclk to the desired frequency.
- * @isp: OMAP3 ISP device
- * @xclk: Desired frequency of the clock in Hz. 0 = stable low, 1 is stable high
- * @xclksel: XCLK to configure (0 = A, 1 = B).
- *
- * Configures the specified MCLK divisor in the ISP timing control register
- * (TCTRL_CTRL) to generate the desired xclk clock value.
- *
- * Divisor = cam_mclk_hz / xclk
- *
- * Returns the final frequency that is actually being generated
- **/
-static u32 isp_set_xclk(struct isp_device *isp, u32 xclk, u8 xclksel)
-{
-	u32 divisor;
-	u32 currentxclk;
-	unsigned long mclk_hz;
-
-	if (!omap3isp_get(isp))
-		return 0;
-
-	mclk_hz = clk_get_rate(isp->clock[ISP_CLK_CAM_MCLK]);
-
-	if (xclk >= mclk_hz) {
-		divisor = ISPTCTRL_CTRL_DIV_BYPASS;
-		currentxclk = mclk_hz;
-	} else if (xclk >= 2) {
-		divisor = mclk_hz / xclk;
-		if (divisor >= ISPTCTRL_CTRL_DIV_BYPASS)
-			divisor = ISPTCTRL_CTRL_DIV_BYPASS - 1;
-		currentxclk = mclk_hz / divisor;
-	} else {
-		divisor = xclk;
-		currentxclk = 0;
-	}
-
-	switch (xclksel) {
-	case ISP_XCLK_A:
-		isp_reg_clr_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
-				ISPTCTRL_CTRL_DIVA_MASK,
-				divisor << ISPTCTRL_CTRL_DIVA_SHIFT);
-		dev_dbg(isp->dev, "isp_set_xclk(): cam_xclka set to %d Hz\n",
-			currentxclk);
-		break;
-	case ISP_XCLK_B:
-		isp_reg_clr_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
-				ISPTCTRL_CTRL_DIVB_MASK,
-				divisor << ISPTCTRL_CTRL_DIVB_SHIFT);
-		dev_dbg(isp->dev, "isp_set_xclk(): cam_xclkb set to %d Hz\n",
-			currentxclk);
-		break;
-	case ISP_XCLK_NONE:
-	default:
-		omap3isp_put(isp);
-		dev_dbg(isp->dev, "ISP_ERR: isp_set_xclk(): Invalid requested "
-			"xclk. Must be 0 (A) or 1 (B).\n");
-		return -EINVAL;
-	}
-
-	/* Do we go from stable whatever to clock? */
-	if (divisor >= 2 && isp->xclk_divisor[xclksel - 1] < 2)
-		omap3isp_get(isp);
-	/* Stopping the clock. */
-	else if (divisor < 2 && isp->xclk_divisor[xclksel - 1] >= 2)
-		omap3isp_put(isp);
-
-	isp->xclk_divisor[xclksel - 1] = divisor;
-
-	omap3isp_put(isp);
-
-	return currentxclk;
-}
-
 /*
  * isp_core_init - ISP core settings
  * @isp: OMAP3 ISP device
@@ -1969,6 +2091,7 @@ static int isp_remove(struct platform_device *pdev)
 
 	isp_unregister_entities(isp);
 	isp_cleanup_modules(isp);
+	isp_xclk_cleanup(isp);
 
 	__omap3isp_get(isp, false);
 	iommu_detach_device(isp->domain, &pdev->dev);
@@ -2042,7 +2165,6 @@ static int isp_probe(struct platform_device *pdev)
 	}
 
 	isp->autoidle = autoidle;
-	isp->platform_cb.set_xclk = isp_set_xclk;
 
 	mutex_init(&isp->isp_mutex);
 	spin_lock_init(&isp->stat_lock);
@@ -2093,6 +2215,10 @@ static int isp_probe(struct platform_device *pdev)
 	if (ret < 0)
 		goto error_isp;
 
+	ret = isp_xclk_init(isp);
+	if (ret < 0)
+		goto error_isp;
+
 	/* Memory resources */
 	for (m = 0; m < ARRAY_SIZE(isp_res_maps); m++)
 		if (isp->revision == isp_res_maps[m].isp_rev)
@@ -2162,6 +2288,7 @@ detach_dev:
 free_domain:
 	iommu_domain_free(isp->domain);
 error_isp:
+	isp_xclk_cleanup(isp);
 	omap3isp_put(isp);
 error:
 	platform_set_drvdata(pdev, NULL);
diff --git a/drivers/media/platform/omap3isp/isp.h b/drivers/media/platform/omap3isp/isp.h
index c77e1f2..cd3eff4 100644
--- a/drivers/media/platform/omap3isp/isp.h
+++ b/drivers/media/platform/omap3isp/isp.h
@@ -29,6 +29,7 @@
 
 #include <media/omap3isp.h>
 #include <media/v4l2-device.h>
+#include <linux/clk-provider.h>
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/iommu.h>
@@ -125,8 +126,20 @@ struct isp_reg {
 	u32 val;
 };
 
-struct isp_platform_callback {
-	u32 (*set_xclk)(struct isp_device *isp, u32 xclk, u8 xclksel);
+enum isp_xclk_id {
+	ISP_XCLK_A,
+	ISP_XCLK_B,
+};
+
+struct isp_xclk {
+	struct isp_device *isp;
+	struct clk_hw hw;
+	struct clk_lookup *lookup;
+	enum isp_xclk_id id;
+
+	spinlock_t lock;	/* Protects enabled and divider */
+	bool enabled;
+	unsigned int divider;
 };
 
 /*
@@ -149,6 +162,7 @@ struct isp_platform_callback {
  * @cam_mclk: Pointer to camera functional clock structure.
  * @csi2_fck: Pointer to camera CSI2 complexIO clock structure.
  * @l3_ick: Pointer to OMAP3 L3 bus interface clock.
+ * @xclks: External clocks provided by the ISP
  * @irq: Currently attached ISP ISR callbacks information structure.
  * @isp_af: Pointer to current settings for ISP AutoFocus SCM.
  * @isp_hist: Pointer to current settings for ISP Histogram SCM.
@@ -185,12 +199,12 @@ struct isp_device {
 	int has_context;
 	int ref_count;
 	unsigned int autoidle;
-	u32 xclk_divisor[2];	/* Two clocks, a and b. */
 #define ISP_CLK_CAM_ICK		0
 #define ISP_CLK_CAM_MCLK	1
 #define ISP_CLK_CSI2_FCK	2
 #define ISP_CLK_L3_ICK		3
 	struct clk *clock[4];
+	struct isp_xclk xclks[2];
 
 	/* ISP modules */
 	struct ispstat isp_af;
@@ -209,8 +223,6 @@ struct isp_device {
 	unsigned int subclk_resources;
 
 	struct iommu_domain *domain;
-
-	struct isp_platform_callback platform_cb;
 };
 
 #define v4l2_dev_to_isp_device(dev) \
diff --git a/include/media/omap3isp.h b/include/media/omap3isp.h
index 9584269..c9d06d9 100644
--- a/include/media/omap3isp.h
+++ b/include/media/omap3isp.h
@@ -29,10 +29,6 @@
 struct i2c_board_info;
 struct isp_device;
 
-#define ISP_XCLK_NONE			0
-#define ISP_XCLK_A			1
-#define ISP_XCLK_B			2
-
 enum isp_interface_type {
 	ISP_INTERFACE_PARALLEL,
 	ISP_INTERFACE_CSI2A_PHY2,
@@ -153,7 +149,13 @@ struct isp_v4l2_subdevs_group {
 	} bus; /* gcc < 4.6.0 chokes on anonymous union initializers */
 };
 
+struct isp_platform_xclk {
+	const char *dev_id;
+	const char *con_id;
+};
+
 struct isp_platform_data {
+	struct isp_platform_xclk xclks[2];
 	struct isp_v4l2_subdevs_group *subdevs;
 	void (*set_constraints)(struct isp_device *isp, bool enable);
 };
-- 
1.7.10.4
Commit	Line	Data
d006af40 AF	1	From 369b60c157f67a71a6f302ab9843ae2de1805a2a Mon Sep 17 00:00:00 2001
	2	From: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
	3	Date: Mon, 22 Oct 2012 15:43:00 +0200
	4	Subject: [PATCH 1/6] omap3isp: Use the common clock framework
	5
	6	Expose the two ISP external clocks XCLKA and XCLKB as common clocks for
	7	subdev drivers.
	8
	9	Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
	10	Acked-by: Mike Turquette <mturquette@linaro.org>
	11	---
	12	drivers/media/platform/omap3isp/isp.c \| 277 ++++++++++++++++++++++++---------
	13	drivers/media/platform/omap3isp/isp.h \| 22 ++-
	14	include/media/omap3isp.h \| 10 +-
	15	3 files changed, 225 insertions(+), 84 deletions(-)
	16
	17	diff --git a/drivers/media/platform/omap3isp/isp.c b/drivers/media/platform/omap3isp/isp.c
	18	index 6e5ad8e..1d7dbd5 100644
	19	--- a/drivers/media/platform/omap3isp/isp.c
	20	+++ b/drivers/media/platform/omap3isp/isp.c
	21	@@ -55,6 +55,7 @@
	22	#include <asm/cacheflush.h>
	23
	24	#include <linux/clk.h>
	25	+#include <linux/clkdev.h>
	26	#include <linux/delay.h>
	27	#include <linux/device.h>
	28	#include <linux/dma-mapping.h>
	29	@@ -148,6 +149,201 @@ void omap3isp_flush(struct isp_device *isp)
	30	isp_reg_readl(isp, OMAP3_ISP_IOMEM_MAIN, ISP_REVISION);
	31	}
	32
	33	+/* -----------------------------------------------------------------------------
	34	+ * XCLK
	35	+ */
	36	+
	37	+#define to_isp_xclk(_hw) container_of(_hw, struct isp_xclk, hw)
	38	+
	39	+static void isp_xclk_update(struct isp_xclk *xclk, u32 divider)
	40	+{
	41	+ switch (xclk->id) {
	42	+ case ISP_XCLK_A:
	43	+ isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
	44	+ ISPTCTRL_CTRL_DIVA_MASK,
	45	+ divider << ISPTCTRL_CTRL_DIVA_SHIFT);
	46	+ break;
	47	+ case ISP_XCLK_B:
	48	+ isp_reg_clr_set(xclk->isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
	49	+ ISPTCTRL_CTRL_DIVB_MASK,
	50	+ divider << ISPTCTRL_CTRL_DIVB_SHIFT);
	51	+ break;
	52	+ }
	53	+}
	54	+
	55	+static int isp_xclk_prepare(struct clk_hw *hw)
	56	+{
	57	+ struct isp_xclk *xclk = to_isp_xclk(hw);
	58	+
	59	+ omap3isp_get(xclk->isp);
	60	+
	61	+ return 0;
	62	+}
	63	+
	64	+static void isp_xclk_unprepare(struct clk_hw *hw)
65	+{
66	+ struct isp_xclk *xclk = to_isp_xclk(hw);
67	+
68	+ omap3isp_put(xclk->isp);
69	+}
70	+
71	+static int isp_xclk_enable(struct clk_hw *hw)
72	+{
73	+ struct isp_xclk *xclk = to_isp_xclk(hw);
74	+ unsigned long flags;
75	+
76	+ spin_lock_irqsave(&xclk->lock, flags);
77	+ isp_xclk_update(xclk, xclk->divider);
78	+ xclk->enabled = true;
79	+ spin_unlock_irqrestore(&xclk->lock, flags);
80	+
81	+ return 0;
82	+}
83	+
84	+static void isp_xclk_disable(struct clk_hw *hw)
85	+{
86	+ struct isp_xclk *xclk = to_isp_xclk(hw);
87	+ unsigned long flags;
88	+
89	+ spin_lock_irqsave(&xclk->lock, flags);
90	+ isp_xclk_update(xclk, 0);
91	+ xclk->enabled = false;
92	+ spin_unlock_irqrestore(&xclk->lock, flags);
93	+}
94	+
95	+static unsigned long isp_xclk_recalc_rate(struct clk_hw *hw,
96	+ unsigned long parent_rate)
97	+{
98	+ struct isp_xclk *xclk = to_isp_xclk(hw);
99	+
100	+ return parent_rate / xclk->divider;
101	+}
102	+
103	+static u32 isp_xclk_calc_divider(unsigned long *rate, unsigned long parent_rate)
104	+{
105	+ u32 divider;
106	+
107	+ if (*rate >= parent_rate) {
108	+ *rate = parent_rate;
109	+ return ISPTCTRL_CTRL_DIV_BYPASS;
110	+ }
111	+
112	+ divider = DIV_ROUND_CLOSEST(parent_rate, *rate);
113	+ if (divider >= ISPTCTRL_CTRL_DIV_BYPASS)
114	+ divider = ISPTCTRL_CTRL_DIV_BYPASS - 1;
115	+
116	+ *rate = parent_rate / divider;
117	+ return divider;
118	+}
119	+
120	+static long isp_xclk_round_rate(struct clk_hw *hw, unsigned long rate,
121	+ unsigned long *parent_rate)
122	+{
123	+ isp_xclk_calc_divider(&rate, *parent_rate);
124	+ return rate;
125	+}
126	+
127	+static int isp_xclk_set_rate(struct clk_hw *hw, unsigned long rate,
128	+ unsigned long parent_rate)
129	+{
130	+ struct isp_xclk *xclk = to_isp_xclk(hw);
131	+ unsigned long flags;
132	+ u32 divider;
133	+
134	+ divider = isp_xclk_calc_divider(&rate, parent_rate);
135	+
136	+ spin_lock_irqsave(&xclk->lock, flags);
137	+
138	+ xclk->divider = divider;
139	+ if (xclk->enabled)
140	+ isp_xclk_update(xclk, divider);
141	+
142	+ spin_unlock_irqrestore(&xclk->lock, flags);
143	+
144	+ dev_dbg(xclk->isp->dev, "%s: cam_xclk%c set to %lu Hz (div %u)\n",
145	+ __func__, xclk->id == ISP_XCLK_A ? 'a' : 'b', rate, divider);
146	+ return 0;
147	+}
148	+
149	+static const struct clk_ops isp_xclk_ops = {
150	+ .prepare = isp_xclk_prepare,
151	+ .unprepare = isp_xclk_unprepare,
152	+ .enable = isp_xclk_enable,
153	+ .disable = isp_xclk_disable,
154	+ .recalc_rate = isp_xclk_recalc_rate,
155	+ .round_rate = isp_xclk_round_rate,
156	+ .set_rate = isp_xclk_set_rate,
157	+};
158	+
159	+static const char *isp_xclk_parent_name = "cam_mclk";
160	+
161	+static const struct clk_init_data isp_xclk_init_data = {
162	+ .name = "cam_xclk",
163	+ .ops = &isp_xclk_ops,
164	+ .parent_names = &isp_xclk_parent_name,
165	+ .num_parents = 1,
166	+};
167	+
168	+static int isp_xclk_init(struct isp_device *isp)
169	+{
170	+ struct isp_platform_data *pdata = isp->pdata;
171	+ struct clk_init_data init;
172	+ unsigned int i;
173	+
174	+ for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) {
175	+ struct isp_xclk *xclk = &isp->xclks[i];
176	+ struct clk *clk;
177	+
178	+ xclk->isp = isp;
179	+ xclk->id = i == 0 ? ISP_XCLK_A : ISP_XCLK_B;
180	+ xclk->divider = 1;
181	+ spin_lock_init(&xclk->lock);
182	+
183	+ init.name = i == 0 ? "cam_xclka" : "cam_xclkb";
184	+ init.ops = &isp_xclk_ops;
185	+ init.parent_names = &isp_xclk_parent_name;
186	+ init.num_parents = 1;
187	+
188	+ xclk->hw.init = &init;
189	+
190	+ clk = devm_clk_register(isp->dev, &xclk->hw);
191	+ if (IS_ERR(clk))
192	+ return PTR_ERR(clk);
193	+
194	+ if (pdata->xclks[i].con_id == NULL &&
195	+ pdata->xclks[i].dev_id == NULL)
196	+ continue;
197	+
198	+ xclk->lookup = kzalloc(sizeof(*xclk->lookup), GFP_KERNEL);
199	+ if (xclk->lookup == NULL)
200	+ return -ENOMEM;
201	+
202	+ xclk->lookup->con_id = pdata->xclks[i].con_id;
203	+ xclk->lookup->dev_id = pdata->xclks[i].dev_id;
204	+ xclk->lookup->clk = clk;
205	+
206	+ clkdev_add(xclk->lookup);
207	+ }
208	+
209	+ return 0;
210	+}
211	+
212	+static void isp_xclk_cleanup(struct isp_device *isp)
213	+{
214	+ unsigned int i;
215	+
216	+ for (i = 0; i < ARRAY_SIZE(isp->xclks); ++i) {
217	+ struct isp_xclk *xclk = &isp->xclks[i];
218	+
219	+ if (xclk->lookup)
220	+ clkdev_drop(xclk->lookup);
221	+ }
222	+}
223	+
224	+/* -----------------------------------------------------------------------------
225	+ * Interrupts
226	+ */
227	+
228	/*
229	* isp_enable_interrupts - Enable ISP interrupts.
230	* @isp: OMAP3 ISP device
231	@@ -180,80 +376,6 @@ static void isp_disable_interrupts(struct isp_device *isp)
232	isp_reg_writel(isp, 0, OMAP3_ISP_IOMEM_MAIN, ISP_IRQ0ENABLE);
233	}
234
235	-/**
236	- * isp_set_xclk - Configures the specified cam_xclk to the desired frequency.
237	- * @isp: OMAP3 ISP device
238	- * @xclk: Desired frequency of the clock in Hz. 0 = stable low, 1 is stable high
239	- * @xclksel: XCLK to configure (0 = A, 1 = B).
240	- *
241	- * Configures the specified MCLK divisor in the ISP timing control register
242	- * (TCTRL_CTRL) to generate the desired xclk clock value.
243	- *
244	- * Divisor = cam_mclk_hz / xclk
245	- *
246	- * Returns the final frequency that is actually being generated
247	- **/
248	-static u32 isp_set_xclk(struct isp_device *isp, u32 xclk, u8 xclksel)
249	-{
250	- u32 divisor;
251	- u32 currentxclk;
252	- unsigned long mclk_hz;
253	-
254	- if (!omap3isp_get(isp))
255	- return 0;
256	-
257	- mclk_hz = clk_get_rate(isp->clock[ISP_CLK_CAM_MCLK]);
258	-
259	- if (xclk >= mclk_hz) {
260	- divisor = ISPTCTRL_CTRL_DIV_BYPASS;
261	- currentxclk = mclk_hz;
262	- } else if (xclk >= 2) {
263	- divisor = mclk_hz / xclk;
264	- if (divisor >= ISPTCTRL_CTRL_DIV_BYPASS)
265	- divisor = ISPTCTRL_CTRL_DIV_BYPASS - 1;
266	- currentxclk = mclk_hz / divisor;
267	- } else {
268	- divisor = xclk;
269	- currentxclk = 0;
270	- }
271	-
272	- switch (xclksel) {
273	- case ISP_XCLK_A:
274	- isp_reg_clr_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
275	- ISPTCTRL_CTRL_DIVA_MASK,
276	- divisor << ISPTCTRL_CTRL_DIVA_SHIFT);
277	- dev_dbg(isp->dev, "isp_set_xclk(): cam_xclka set to %d Hz\n",
278	- currentxclk);
279	- break;
280	- case ISP_XCLK_B:
281	- isp_reg_clr_set(isp, OMAP3_ISP_IOMEM_MAIN, ISP_TCTRL_CTRL,
282	- ISPTCTRL_CTRL_DIVB_MASK,
283	- divisor << ISPTCTRL_CTRL_DIVB_SHIFT);
284	- dev_dbg(isp->dev, "isp_set_xclk(): cam_xclkb set to %d Hz\n",
285	- currentxclk);
286	- break;
287	- case ISP_XCLK_NONE:
288	- default:
289	- omap3isp_put(isp);
290	- dev_dbg(isp->dev, "ISP_ERR: isp_set_xclk(): Invalid requested "
291	- "xclk. Must be 0 (A) or 1 (B).\n");
292	- return -EINVAL;
293	- }
294	-
295	- /* Do we go from stable whatever to clock? */
296	- if (divisor >= 2 && isp->xclk_divisor[xclksel - 1] < 2)
297	- omap3isp_get(isp);
298	- /* Stopping the clock. */
299	- else if (divisor < 2 && isp->xclk_divisor[xclksel - 1] >= 2)
300	- omap3isp_put(isp);
301	-
302	- isp->xclk_divisor[xclksel - 1] = divisor;
303	-
304	- omap3isp_put(isp);
305	-
306	- return currentxclk;
307	-}
308	-
309	/*
310	* isp_core_init - ISP core settings
311	* @isp: OMAP3 ISP device
312	@@ -1969,6 +2091,7 @@ static int isp_remove(struct platform_device *pdev)
313
314	isp_unregister_entities(isp);
315	isp_cleanup_modules(isp);
316	+ isp_xclk_cleanup(isp);
317
318	__omap3isp_get(isp, false);
319	iommu_detach_device(isp->domain, &pdev->dev);
320	@@ -2042,7 +2165,6 @@ static int isp_probe(struct platform_device *pdev)
321	}
322
323	isp->autoidle = autoidle;
324	- isp->platform_cb.set_xclk = isp_set_xclk;
325
326	mutex_init(&isp->isp_mutex);
327	spin_lock_init(&isp->stat_lock);
328	@@ -2093,6 +2215,10 @@ static int isp_probe(struct platform_device *pdev)
329	if (ret < 0)
330	goto error_isp;
331
332	+ ret = isp_xclk_init(isp);
333	+ if (ret < 0)
334	+ goto error_isp;
335	+
336	/* Memory resources */
337	for (m = 0; m < ARRAY_SIZE(isp_res_maps); m++)
338	if (isp->revision == isp_res_maps[m].isp_rev)
339	@@ -2162,6 +2288,7 @@ detach_dev:
340	free_domain:
341	iommu_domain_free(isp->domain);
342	error_isp:
343	+ isp_xclk_cleanup(isp);
344	omap3isp_put(isp);
345	error:
346	platform_set_drvdata(pdev, NULL);
347	diff --git a/drivers/media/platform/omap3isp/isp.h b/drivers/media/platform/omap3isp/isp.h
348	index c77e1f2..cd3eff4 100644
349	--- a/drivers/media/platform/omap3isp/isp.h
350	+++ b/drivers/media/platform/omap3isp/isp.h
351	@@ -29,6 +29,7 @@
352
353	#include <media/omap3isp.h>
354	#include <media/v4l2-device.h>
355	+#include <linux/clk-provider.h>
356	#include <linux/device.h>
357	#include <linux/io.h>
358	#include <linux/iommu.h>
359	@@ -125,8 +126,20 @@ struct isp_reg {
360	u32 val;
361	};
362
363	-struct isp_platform_callback {
364	- u32 (set_xclk)(struct isp_device isp, u32 xclk, u8 xclksel);
365	+enum isp_xclk_id {
366	+ ISP_XCLK_A,
367	+ ISP_XCLK_B,
368	+};
369	+
370	+struct isp_xclk {
371	+ struct isp_device *isp;
372	+ struct clk_hw hw;
373	+ struct clk_lookup *lookup;
374	+ enum isp_xclk_id id;
375	+
376	+ spinlock_t lock; /* Protects enabled and divider */
377	+ bool enabled;
378	+ unsigned int divider;
379	};
380
381	/*
382	@@ -149,6 +162,7 @@ struct isp_platform_callback {
383	* @cam_mclk: Pointer to camera functional clock structure.
384	* @csi2_fck: Pointer to camera CSI2 complexIO clock structure.
385	* @l3_ick: Pointer to OMAP3 L3 bus interface clock.
386	+ * @xclks: External clocks provided by the ISP
387	* @irq: Currently attached ISP ISR callbacks information structure.
388	* @isp_af: Pointer to current settings for ISP AutoFocus SCM.
389	* @isp_hist: Pointer to current settings for ISP Histogram SCM.
390	@@ -185,12 +199,12 @@ struct isp_device {
391	int has_context;
392	int ref_count;
393	unsigned int autoidle;
394	- u32 xclk_divisor[2]; /* Two clocks, a and b. */
395	#define ISP_CLK_CAM_ICK 0
396	#define ISP_CLK_CAM_MCLK 1
397	#define ISP_CLK_CSI2_FCK 2
398	#define ISP_CLK_L3_ICK 3
399	struct clk *clock[4];
400	+ struct isp_xclk xclks[2];
401
402	/* ISP modules */
403	struct ispstat isp_af;
404	@@ -209,8 +223,6 @@ struct isp_device {
405	unsigned int subclk_resources;
406
407	struct iommu_domain *domain;
408	-
409	- struct isp_platform_callback platform_cb;
410	};
411
412	#define v4l2_dev_to_isp_device(dev) \
413	diff --git a/include/media/omap3isp.h b/include/media/omap3isp.h
414	index 9584269..c9d06d9 100644
415	--- a/include/media/omap3isp.h
416	+++ b/include/media/omap3isp.h
417	@@ -29,10 +29,6 @@
418	struct i2c_board_info;
419	struct isp_device;
420
421	-#define ISP_XCLK_NONE 0
422	-#define ISP_XCLK_A 1
423	-#define ISP_XCLK_B 2
424	-
425	enum isp_interface_type {
426	ISP_INTERFACE_PARALLEL,
427	ISP_INTERFACE_CSI2A_PHY2,
428	@@ -153,7 +149,13 @@ struct isp_v4l2_subdevs_group {
429	} bus; /* gcc < 4.6.0 chokes on anonymous union initializers */
430	};
431
432	+struct isp_platform_xclk {
433	+ const char *dev_id;
434	+ const char *con_id;
435	+};
436	+
437	struct isp_platform_data {
438	+ struct isp_platform_xclk xclks[2];
439	struct isp_v4l2_subdevs_group *subdevs;
440	void (set_constraints)(struct isp_device isp, bool enable);
441	};
442	--
443	1.7.10.4
444