drm: omapdrm: dss: Pass omap_drm_private pointer to dss_mgr_ops

pinchartl · tomba · commit 64cb81797f8b · 2018-03-01T09:18:18.000+02:00
The dss_mgr_ops operations implemented by the omapdrm side have to look
up the omap_crtc objects from global variables as they are only passed a
channel number. In order to remove global variables in the omapdrm
driver pass the omap_drm_private pointer to the dss_mgr_ops. This
requires storing a pointer to the omap_drm_private in a global variable
on the DSS side as a temporary measure until the omapdrm and omapdss
drivers get merged.

Signed-off-by: Laurent Pinchart &lt;laurent.pinchart@ideasonboard.com&gt;
Reviewed-by: Sebastian Reichel &lt;sebastian.reichel@collabora.co.uk&gt;
diff --git a/drivers/gpu/drm/omapdrm/dss/omapdss.h b/drivers/gpu/drm/omapdrm/dss/omapdss.h
@@ -59,6 +59,7 @@
 #define DISPC_IRQ_ACBIAS_COUNT_STAT3	(1 << 29)
 #define DISPC_IRQ_FRAMEDONE3		(1 << 30)
 
+struct omap_drm_private;
 struct omap_dss_device;
 struct dss_lcd_mgr_config;
 struct snd_aes_iec958;
@@ -635,25 +636,35 @@ struct device_node *dss_of_port_get_parent_device(struct device_node *port);
 u32 dss_of_port_get_port_number(struct device_node *port);
 
 struct dss_mgr_ops {
-	int (*connect)(enum omap_channel channel,
-		struct omap_dss_device *dst);
-	void (*disconnect)(enum omap_channel channel,
-		struct omap_dss_device *dst);
-
-	void (*start_update)(enum omap_channel channel);
-	int (*enable)(enum omap_channel channel);
-	void (*disable)(enum omap_channel channel);
-	void (*set_timings)(enum omap_channel channel,
-			const struct videomode *vm);
-	void (*set_lcd_config)(enum omap_channel channel,
-			const struct dss_lcd_mgr_config *config);
-	int (*register_framedone_handler)(enum omap_channel channel,
+	int (*connect)(struct omap_drm_private *priv,
+		       enum omap_channel channel,
+		       struct omap_dss_device *dst);
+	void (*disconnect)(struct omap_drm_private *priv,
+			   enum omap_channel channel,
+			   struct omap_dss_device *dst);
+
+	void (*start_update)(struct omap_drm_private *priv,
+			     enum omap_channel channel);
+	int (*enable)(struct omap_drm_private *priv,
+		      enum omap_channel channel);
+	void (*disable)(struct omap_drm_private *priv,
+			enum omap_channel channel);
+	void (*set_timings)(struct omap_drm_private *priv,
+			    enum omap_channel channel,
+			    const struct videomode *vm);
+	void (*set_lcd_config)(struct omap_drm_private *priv,
+			       enum omap_channel channel,
+			       const struct dss_lcd_mgr_config *config);
+	int (*register_framedone_handler)(struct omap_drm_private *priv,
+			enum omap_channel channel,
 			void (*handler)(void *), void *data);
-	void (*unregister_framedone_handler)(enum omap_channel channel,
+	void (*unregister_framedone_handler)(struct omap_drm_private *priv,
+			enum omap_channel channel,
 			void (*handler)(void *), void *data);
 };
 
-int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops);
+int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops,
+			struct omap_drm_private *priv);
 void dss_uninstall_mgr_ops(void);
 
 int dss_mgr_connect(struct omap_dss_device *dssdev,
diff --git a/drivers/gpu/drm/omapdrm/dss/output.c b/drivers/gpu/drm/omapdrm/dss/output.c
@@ -170,13 +170,16 @@ struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device
 EXPORT_SYMBOL(omapdss_find_output_from_display);
 
 static const struct dss_mgr_ops *dss_mgr_ops;
+static struct omap_drm_private *dss_mgr_ops_priv;
 
-int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops)
+int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops,
+			struct omap_drm_private *priv)
 {
 	if (dss_mgr_ops)
 		return -EBUSY;
 
 	dss_mgr_ops = mgr_ops;
+	dss_mgr_ops_priv = priv;
 
 	return 0;
 }
@@ -185,66 +188,71 @@ EXPORT_SYMBOL(dss_install_mgr_ops);
 void dss_uninstall_mgr_ops(void)
 {
 	dss_mgr_ops = NULL;
+	dss_mgr_ops_priv = NULL;
 }
 EXPORT_SYMBOL(dss_uninstall_mgr_ops);
 
 int dss_mgr_connect(struct omap_dss_device *dssdev, struct omap_dss_device *dst)
 {
-	return dss_mgr_ops->connect(dssdev->dispc_channel, dst);
+	return dss_mgr_ops->connect(dss_mgr_ops_priv,
+				    dssdev->dispc_channel, dst);
 }
 EXPORT_SYMBOL(dss_mgr_connect);
 
 void dss_mgr_disconnect(struct omap_dss_device *dssdev,
 			struct omap_dss_device *dst)
 {
-	dss_mgr_ops->disconnect(dssdev->dispc_channel, dst);
+	dss_mgr_ops->disconnect(dss_mgr_ops_priv, dssdev->dispc_channel, dst);
 }
 EXPORT_SYMBOL(dss_mgr_disconnect);
 
 void dss_mgr_set_timings(struct omap_dss_device *dssdev,
 			 const struct videomode *vm)
 {
-	dss_mgr_ops->set_timings(dssdev->dispc_channel, vm);
+	dss_mgr_ops->set_timings(dss_mgr_ops_priv, dssdev->dispc_channel, vm);
 }
 EXPORT_SYMBOL(dss_mgr_set_timings);
 
 void dss_mgr_set_lcd_config(struct omap_dss_device *dssdev,
 		const struct dss_lcd_mgr_config *config)
 {
-	dss_mgr_ops->set_lcd_config(dssdev->dispc_channel, config);
+	dss_mgr_ops->set_lcd_config(dss_mgr_ops_priv,
+				    dssdev->dispc_channel, config);
 }
 EXPORT_SYMBOL(dss_mgr_set_lcd_config);
 
 int dss_mgr_enable(struct omap_dss_device *dssdev)
 {
-	return dss_mgr_ops->enable(dssdev->dispc_channel);
+	return dss_mgr_ops->enable(dss_mgr_ops_priv, dssdev->dispc_channel);
 }
 EXPORT_SYMBOL(dss_mgr_enable);
 
 void dss_mgr_disable(struct omap_dss_device *dssdev)
 {
-	dss_mgr_ops->disable(dssdev->dispc_channel);
+	dss_mgr_ops->disable(dss_mgr_ops_priv, dssdev->dispc_channel);
 }
 EXPORT_SYMBOL(dss_mgr_disable);
 
 void dss_mgr_start_update(struct omap_dss_device *dssdev)
 {
-	dss_mgr_ops->start_update(dssdev->dispc_channel);
+	dss_mgr_ops->start_update(dss_mgr_ops_priv, dssdev->dispc_channel);
 }
 EXPORT_SYMBOL(dss_mgr_start_update);
 
 int dss_mgr_register_framedone_handler(struct omap_dss_device *dssdev,
 		void (*handler)(void *), void *data)
 {
-	return dss_mgr_ops->register_framedone_handler(dssdev->dispc_channel,
+	return dss_mgr_ops->register_framedone_handler(dss_mgr_ops_priv,
+						       dssdev->dispc_channel,
 						       handler, data);
 }
 EXPORT_SYMBOL(dss_mgr_register_framedone_handler);
 
 void dss_mgr_unregister_framedone_handler(struct omap_dss_device *dssdev,
 		void (*handler)(void *), void *data)
 {
-	dss_mgr_ops->unregister_framedone_handler(dssdev->dispc_channel,
+	dss_mgr_ops->unregister_framedone_handler(dss_mgr_ops_priv,
+						  dssdev->dispc_channel,
 						  handler, data);
 }
 EXPORT_SYMBOL(dss_mgr_unregister_framedone_handler);
diff --git a/drivers/gpu/drm/omapdrm/omap_crtc.c b/drivers/gpu/drm/omapdrm/omap_crtc.c
@@ -113,7 +113,8 @@ static struct omap_crtc *omap_crtcs[8];
 static struct omap_dss_device *omap_crtc_output[8];
 
 /* we can probably ignore these until we support command-mode panels: */
-static int omap_crtc_dss_connect(enum omap_channel channel,
+static int omap_crtc_dss_connect(struct omap_drm_private *priv,
+		enum omap_channel channel,
 		struct omap_dss_device *dst)
 {
 	const struct dispc_ops *dispc_ops = dispc_get_ops();
@@ -130,14 +131,16 @@ static int omap_crtc_dss_connect(enum omap_channel channel,
 	return 0;
 }
 
-static void omap_crtc_dss_disconnect(enum omap_channel channel,
+static void omap_crtc_dss_disconnect(struct omap_drm_private *priv,
+		enum omap_channel channel,
 		struct omap_dss_device *dst)
 {
 	omap_crtc_output[channel] = NULL;
 	dst->dispc_channel_connected = false;
 }
 
-static void omap_crtc_dss_start_update(enum omap_channel channel)
+static void omap_crtc_dss_start_update(struct omap_drm_private *priv,
+				       enum omap_channel channel)
 {
 }
 
@@ -207,51 +210,53 @@ static void omap_crtc_set_enabled(struct drm_crtc *crtc, bool enable)
 }
 
 
-static int omap_crtc_dss_enable(enum omap_channel channel)
+static int omap_crtc_dss_enable(struct omap_drm_private *priv,
+				enum omap_channel channel)
 {
 	struct omap_crtc *omap_crtc = omap_crtcs[channel];
-	struct omap_drm_private *priv = omap_crtc->base.dev->dev_private;
 
 	priv->dispc_ops->mgr_set_timings(omap_crtc->channel, &omap_crtc->vm);
 	omap_crtc_set_enabled(&omap_crtc->base, true);
 
 	return 0;
 }
 
-static void omap_crtc_dss_disable(enum omap_channel channel)
+static void omap_crtc_dss_disable(struct omap_drm_private *priv,
+				  enum omap_channel channel)
 {
 	struct omap_crtc *omap_crtc = omap_crtcs[channel];
 
 	omap_crtc_set_enabled(&omap_crtc->base, false);
 }
 
-static void omap_crtc_dss_set_timings(enum omap_channel channel,
+static void omap_crtc_dss_set_timings(struct omap_drm_private *priv,
+		enum omap_channel channel,
 		const struct videomode *vm)
 {
 	struct omap_crtc *omap_crtc = omap_crtcs[channel];
 	DBG("%s", omap_crtc->name);
 	omap_crtc->vm = *vm;
 }
 
-static void omap_crtc_dss_set_lcd_config(enum omap_channel channel,
+static void omap_crtc_dss_set_lcd_config(struct omap_drm_private *priv,
+		enum omap_channel channel,
 		const struct dss_lcd_mgr_config *config)
 {
 	struct omap_crtc *omap_crtc = omap_crtcs[channel];
-	struct omap_drm_private *priv = omap_crtc->base.dev->dev_private;
 
 	DBG("%s", omap_crtc->name);
 	priv->dispc_ops->mgr_set_lcd_config(omap_crtc->channel, config);
 }
 
 static int omap_crtc_dss_register_framedone(
-		enum omap_channel channel,
+		struct omap_drm_private *priv, enum omap_channel channel,
 		void (*handler)(void *), void *data)
 {
 	return 0;
 }
 
 static void omap_crtc_dss_unregister_framedone(
-		enum omap_channel channel,
+		struct omap_drm_private *priv, enum omap_channel channel,
 		void (*handler)(void *), void *data)
 {
 }
@@ -669,11 +674,11 @@ static const char *channel_names[] = {
 	[OMAP_DSS_CHANNEL_LCD3] = "lcd3",
 };
 
-void omap_crtc_pre_init(void)
+void omap_crtc_pre_init(struct omap_drm_private *priv)
 {
 	memset(omap_crtcs, 0, sizeof(omap_crtcs));
 
-	dss_install_mgr_ops(&mgr_ops);
+	dss_install_mgr_ops(&mgr_ops, priv);
 }
 
 void omap_crtc_pre_uninit(void)
diff --git a/drivers/gpu/drm/omapdrm/omap_crtc.h b/drivers/gpu/drm/omapdrm/omap_crtc.h
@@ -32,7 +32,7 @@ struct videomode;
 
 struct videomode *omap_crtc_timings(struct drm_crtc *crtc);
 enum omap_channel omap_crtc_channel(struct drm_crtc *crtc);
-void omap_crtc_pre_init(void);
+void omap_crtc_pre_init(struct omap_drm_private *priv);
 void omap_crtc_pre_uninit(void);
 struct drm_crtc *omap_crtc_init(struct drm_device *dev,
 		struct drm_plane *plane, struct omap_dss_device *dssdev);
diff --git a/drivers/gpu/drm/omapdrm/omap_drv.c b/drivers/gpu/drm/omapdrm/omap_drv.c
@@ -521,7 +521,7 @@ static int omapdrm_init(struct omap_drm_private *priv, struct device *dev)
 
 	priv->dev = dev;
 
-	omap_crtc_pre_init();
+	omap_crtc_pre_init(priv);
 
 	ret = omap_connect_dssdevs();
 	if (ret)

Original file line number	Diff line number	Diff line change
`@@ -170,13 +170,16 @@ struct omap_dss_device *omapdss_find_output_from_display(struct omap_dss_device`
`170`	`170`	`EXPORT_SYMBOL(omapdss_find_output_from_display);`
`171`	`171`
`172`	`172`	`static const struct dss_mgr_ops *dss_mgr_ops;`
	`173`	`+static struct omap_drm_private *dss_mgr_ops_priv;`
`173`	`174`
`174`		`-int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops)`
	`175`	`+int dss_install_mgr_ops(const struct dss_mgr_ops *mgr_ops,`
	`176`	`+ struct omap_drm_private *priv)`
`175`	`177`	`{`
`176`	`178`	`if (dss_mgr_ops)`
`177`	`179`	`return -EBUSY;`
`178`	`180`
`179`	`181`	`dss_mgr_ops = mgr_ops;`
	`182`	`+ dss_mgr_ops_priv = priv;`
`180`	`183`
`181`	`184`	`return 0;`
`182`	`185`	`}`
`@@ -185,66 +188,71 @@ EXPORT_SYMBOL(dss_install_mgr_ops);`
`185`	`188`	`void dss_uninstall_mgr_ops(void)`
`186`	`189`	`{`
`187`	`190`	`dss_mgr_ops = NULL;`
	`191`	`+ dss_mgr_ops_priv = NULL;`
`188`	`192`	`}`
`189`	`193`	`EXPORT_SYMBOL(dss_uninstall_mgr_ops);`
`190`	`194`
`191`	`195`	`int dss_mgr_connect(struct omap_dss_device dssdev, struct omap_dss_device dst)`
`192`	`196`	`{`
`193`		`- return dss_mgr_ops->connect(dssdev->dispc_channel, dst);`
	`197`	`+ return dss_mgr_ops->connect(dss_mgr_ops_priv,`
	`198`	`+ dssdev->dispc_channel, dst);`
`194`	`199`	`}`
`195`	`200`	`EXPORT_SYMBOL(dss_mgr_connect);`
`196`	`201`
`197`	`202`	`void dss_mgr_disconnect(struct omap_dss_device *dssdev,`
`198`	`203`	`struct omap_dss_device *dst)`
`199`	`204`	`{`
`200`		`- dss_mgr_ops->disconnect(dssdev->dispc_channel, dst);`
	`205`	`+ dss_mgr_ops->disconnect(dss_mgr_ops_priv, dssdev->dispc_channel, dst);`
`201`	`206`	`}`
`202`	`207`	`EXPORT_SYMBOL(dss_mgr_disconnect);`
`203`	`208`
`204`	`209`	`void dss_mgr_set_timings(struct omap_dss_device *dssdev,`
`205`	`210`	`const struct videomode *vm)`
`206`	`211`	`{`
`207`		`- dss_mgr_ops->set_timings(dssdev->dispc_channel, vm);`
	`212`	`+ dss_mgr_ops->set_timings(dss_mgr_ops_priv, dssdev->dispc_channel, vm);`
`208`	`213`	`}`
`209`	`214`	`EXPORT_SYMBOL(dss_mgr_set_timings);`
`210`	`215`
`211`	`216`	`void dss_mgr_set_lcd_config(struct omap_dss_device *dssdev,`
`212`	`217`	`const struct dss_lcd_mgr_config *config)`
`213`	`218`	`{`
`214`		`- dss_mgr_ops->set_lcd_config(dssdev->dispc_channel, config);`
	`219`	`+ dss_mgr_ops->set_lcd_config(dss_mgr_ops_priv,`
	`220`	`+ dssdev->dispc_channel, config);`
`215`	`221`	`}`
`216`	`222`	`EXPORT_SYMBOL(dss_mgr_set_lcd_config);`
`217`	`223`
`218`	`224`	`int dss_mgr_enable(struct omap_dss_device *dssdev)`
`219`	`225`	`{`
`220`		`- return dss_mgr_ops->enable(dssdev->dispc_channel);`
	`226`	`+ return dss_mgr_ops->enable(dss_mgr_ops_priv, dssdev->dispc_channel);`
`221`	`227`	`}`
`222`	`228`	`EXPORT_SYMBOL(dss_mgr_enable);`
`223`	`229`
`224`	`230`	`void dss_mgr_disable(struct omap_dss_device *dssdev)`
`225`	`231`	`{`
`226`		`- dss_mgr_ops->disable(dssdev->dispc_channel);`
	`232`	`+ dss_mgr_ops->disable(dss_mgr_ops_priv, dssdev->dispc_channel);`
`227`	`233`	`}`
`228`	`234`	`EXPORT_SYMBOL(dss_mgr_disable);`
`229`	`235`
`230`	`236`	`void dss_mgr_start_update(struct omap_dss_device *dssdev)`
`231`	`237`	`{`
`232`		`- dss_mgr_ops->start_update(dssdev->dispc_channel);`
	`238`	`+ dss_mgr_ops->start_update(dss_mgr_ops_priv, dssdev->dispc_channel);`
`233`	`239`	`}`
`234`	`240`	`EXPORT_SYMBOL(dss_mgr_start_update);`
`235`	`241`
`236`	`242`	`int dss_mgr_register_framedone_handler(struct omap_dss_device *dssdev,`
`237`	`243`	`void (handler)(void ), void *data)`
`238`	`244`	`{`
`239`		`- return dss_mgr_ops->register_framedone_handler(dssdev->dispc_channel,`
	`245`	`+ return dss_mgr_ops->register_framedone_handler(dss_mgr_ops_priv,`
	`246`	`+ dssdev->dispc_channel,`
`240`	`247`	`handler, data);`
`241`	`248`	`}`
`242`	`249`	`EXPORT_SYMBOL(dss_mgr_register_framedone_handler);`
`243`	`250`
`244`	`251`	`void dss_mgr_unregister_framedone_handler(struct omap_dss_device *dssdev,`
`245`	`252`	`void (handler)(void ), void *data)`
`246`	`253`	`{`
`247`		`- dss_mgr_ops->unregister_framedone_handler(dssdev->dispc_channel,`
	`254`	`+ dss_mgr_ops->unregister_framedone_handler(dss_mgr_ops_priv,`
	`255`	`+ dssdev->dispc_channel,`
`248`	`256`	`handler, data);`
`249`	`257`	`}`
`250`	`258`	`EXPORT_SYMBOL(dss_mgr_unregister_framedone_handler);`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,8 @@ static struct omap_crtc *omap_crtcs[8];`
`113`	`113`	`static struct omap_dss_device *omap_crtc_output[8];`
`114`	`114`
`115`	`115`	`/* we can probably ignore these until we support command-mode panels: */`
`116`		`-static int omap_crtc_dss_connect(enum omap_channel channel,`
	`116`	`+static int omap_crtc_dss_connect(struct omap_drm_private *priv,`
	`117`	`+ enum omap_channel channel,`
`117`	`118`	`struct omap_dss_device *dst)`
`118`	`119`	`{`
`119`	`120`	`const struct dispc_ops *dispc_ops = dispc_get_ops();`
`@@ -130,14 +131,16 @@ static int omap_crtc_dss_connect(enum omap_channel channel,`
`130`	`131`	`return 0;`
`131`	`132`	`}`
`132`	`133`
`133`		`-static void omap_crtc_dss_disconnect(enum omap_channel channel,`
	`134`	`+static void omap_crtc_dss_disconnect(struct omap_drm_private *priv,`
	`135`	`+ enum omap_channel channel,`
`134`	`136`	`struct omap_dss_device *dst)`
`135`	`137`	`{`
`136`	`138`	`omap_crtc_output[channel] = NULL;`
`137`	`139`	`dst->dispc_channel_connected = false;`
`138`	`140`	`}`
`139`	`141`
`140`		`-static void omap_crtc_dss_start_update(enum omap_channel channel)`
	`142`	`+static void omap_crtc_dss_start_update(struct omap_drm_private *priv,`
	`143`	`+ enum omap_channel channel)`
`141`	`144`	`{`
`142`	`145`	`}`
`143`	`146`
`@@ -207,51 +210,53 @@ static void omap_crtc_set_enabled(struct drm_crtc *crtc, bool enable)`
`207`	`210`	`}`
`208`	`211`
`209`	`212`
`210`		`-static int omap_crtc_dss_enable(enum omap_channel channel)`
	`213`	`+static int omap_crtc_dss_enable(struct omap_drm_private *priv,`
	`214`	`+ enum omap_channel channel)`
`211`	`215`	`{`
`212`	`216`	`struct omap_crtc *omap_crtc = omap_crtcs[channel];`
`213`		`- struct omap_drm_private *priv = omap_crtc->base.dev->dev_private;`
`214`	`217`
`215`	`218`	`priv->dispc_ops->mgr_set_timings(omap_crtc->channel, &omap_crtc->vm);`
`216`	`219`	`omap_crtc_set_enabled(&omap_crtc->base, true);`
`217`	`220`
`218`	`221`	`return 0;`
`219`	`222`	`}`
`220`	`223`
`221`		`-static void omap_crtc_dss_disable(enum omap_channel channel)`
	`224`	`+static void omap_crtc_dss_disable(struct omap_drm_private *priv,`
	`225`	`+ enum omap_channel channel)`
`222`	`226`	`{`
`223`	`227`	`struct omap_crtc *omap_crtc = omap_crtcs[channel];`
`224`	`228`
`225`	`229`	`omap_crtc_set_enabled(&omap_crtc->base, false);`
`226`	`230`	`}`
`227`	`231`
`228`		`-static void omap_crtc_dss_set_timings(enum omap_channel channel,`
	`232`	`+static void omap_crtc_dss_set_timings(struct omap_drm_private *priv,`
	`233`	`+ enum omap_channel channel,`
`229`	`234`	`const struct videomode *vm)`
`230`	`235`	`{`
`231`	`236`	`struct omap_crtc *omap_crtc = omap_crtcs[channel];`
`232`	`237`	`DBG("%s", omap_crtc->name);`
`233`	`238`	`omap_crtc->vm = *vm;`
`234`	`239`	`}`
`235`	`240`
`236`		`-static void omap_crtc_dss_set_lcd_config(enum omap_channel channel,`
	`241`	`+static void omap_crtc_dss_set_lcd_config(struct omap_drm_private *priv,`
	`242`	`+ enum omap_channel channel,`
`237`	`243`	`const struct dss_lcd_mgr_config *config)`
`238`	`244`	`{`
`239`	`245`	`struct omap_crtc *omap_crtc = omap_crtcs[channel];`
`240`		`- struct omap_drm_private *priv = omap_crtc->base.dev->dev_private;`
`241`	`246`
`242`	`247`	`DBG("%s", omap_crtc->name);`
`243`	`248`	`priv->dispc_ops->mgr_set_lcd_config(omap_crtc->channel, config);`
`244`	`249`	`}`
`245`	`250`
`246`	`251`	`static int omap_crtc_dss_register_framedone(`
`247`		`- enum omap_channel channel,`
	`252`	`+ struct omap_drm_private *priv, enum omap_channel channel,`
`248`	`253`	`void (handler)(void ), void *data)`
`249`	`254`	`{`
`250`	`255`	`return 0;`
`251`	`256`	`}`
`252`	`257`
`253`	`258`	`static void omap_crtc_dss_unregister_framedone(`
`254`		`- enum omap_channel channel,`
	`259`	`+ struct omap_drm_private *priv, enum omap_channel channel,`
`255`	`260`	`void (handler)(void ), void *data)`
`256`	`261`	`{`
`257`	`262`	`}`
`@@ -669,11 +674,11 @@ static const char *channel_names[] = {`
`669`	`674`	`[OMAP_DSS_CHANNEL_LCD3] = "lcd3",`
`670`	`675`	`};`
`671`	`676`
`672`		`-void omap_crtc_pre_init(void)`
	`677`	`+void omap_crtc_pre_init(struct omap_drm_private *priv)`
`673`	`678`	`{`
`674`	`679`	`memset(omap_crtcs, 0, sizeof(omap_crtcs));`
`675`	`680`
`676`		`- dss_install_mgr_ops(&mgr_ops);`
	`681`	`+ dss_install_mgr_ops(&mgr_ops, priv);`
`677`	`682`	`}`
`678`	`683`
`679`	`684`	`void omap_crtc_pre_uninit(void)`