disp: msm: make msm_drm into single module

Make msm_drm into single module and all child driver
registers and unregisters are handled from parent's
register and unregister respectively.

Change-Id: I017513d1de3b6b25dd5543d7fa7741c0bac1740d
Signed-off-by: Shashank Babu Chinta Venkata <sbchin@codeaurora.org>
Signed-off-by: Narendra Muppalla <NarendraM@codeaurora.org>
Signed-off-by: Chandan Uddaraju <chandanu@codeaurora.org>

hdcp/msm_hdcp.c

@@ -328,18 +328,12 @@ static struct platform_driver msm_hdcp_driver = {
 	}
 };
 
-static int __init msm_hdcp_init(void)
+void __init msm_hdcp_register(void)
 {
-	return platform_driver_register(&msm_hdcp_driver);
+	platform_driver_register(&msm_hdcp_driver);
 }
 
-static void __exit msm_hdcp_exit(void)
+void __exit msm_hdcp_unregister(void)
 {
-	return platform_driver_unregister(&msm_hdcp_driver);
+	platform_driver_unregister(&msm_hdcp_driver);
 }
-
-module_init(msm_hdcp_init);
-module_exit(msm_hdcp_exit);
-
-MODULE_DESCRIPTION("MSM HDCP driver");
-MODULE_LICENSE("GPL v2");

include/linux/sde_rsc.h

@@ -141,7 +141,7 @@ struct sde_rsc_cmd_config {
 	u32 prefill_lines;
 };
 
-#ifdef CONFIG_DRM_SDE_RSC
+#if IS_ENABLED(CONFIG_DRM_SDE_RSC)
 /**
  * sde_rsc_client_create() - create the client for sde rsc.
  * Different displays like DSI, HDMI, DP, WB, etc should call this

msm/dp/dp_display.c

@@ -3347,22 +3347,13 @@ static struct platform_driver dp_display_driver = {
 	},
 };
 
-static int __init dp_display_init(void)
+void __init dp_display_register(void)
 {
-	int ret;
 
-	ret = platform_driver_register(&dp_display_driver);
+	platform_driver_register(&dp_display_driver);
-	if (ret) {
-		DP_ERR("driver register failed\n");
-		return ret;
-	}
-
-	return ret;
 }
-late_initcall(dp_display_init);
 
-static void __exit dp_display_cleanup(void)
+void __exit dp_display_unregister(void)
 {
 	platform_driver_unregister(&dp_display_driver);
 }
-module_exit(dp_display_cleanup);

msm/dp/dp_display.h

@@ -127,7 +127,7 @@ struct dp_display {
 			bool wakeup);
 };
 
-#ifdef CONFIG_DRM_MSM_DP
+#if IS_ENABLED(CONFIG_DRM_MSM_DP)
 int dp_display_get_num_of_displays(void);
 int dp_display_get_displays(void **displays, int count);
 int dp_display_get_num_of_streams(void);
@@ -149,5 +149,5 @@ static inline int dp_connector_update_pps(struct drm_connector *connector,
 {
 	return 0;
 }
-#endif
+#endif /* CONFIG_DRM_MSM_DP */
 #endif /* _DP_DISPLAY_H_ */

msm/dp/dp_drm.h

@@ -24,7 +24,7 @@ struct dp_bridge {
 };
 
 
-#ifdef CONFIG_DRM_MSM_DP
+#if IS_ENABLED(CONFIG_DRM_MSM_DP)
 /**
  * dp_connector_config_hdr - callback to configure HDR
  * @connector: Pointer to drm connector structure
@@ -231,6 +231,6 @@ static inline void convert_to_drm_mode(const struct dp_display_mode *dp_mode,
 				struct drm_display_mode *drm_mode)
 {
 }
-#endif
+#endif /* CONFIG_DRM_MSM_DP */
 
 #endif /* _DP_DRM_H_ */

msm/dp/dp_mst_drm.h

@@ -12,7 +12,7 @@
 
 #include "dp_display.h"
 
-#ifdef CONFIG_DRM_MSM_DP_MST
+#if IS_ENABLED(CONFIG_DRM_MSM_DP_MST)
 
 /**
  * dp_mst_drm_bridge_init - initialize mst bridge
@@ -60,6 +60,6 @@ static inline int dp_mst_deinit(struct dp_display *dp_display)
 {
 	return 0;
 }
-#endif
+#endif /* CONFIG_DRM_MSM_DP_MST */
 
 #endif /* _DP_MST_DRM_H_ */

msm/dp/dp_usbpd.h

@@ -46,7 +46,7 @@ struct dp_usbpd {
 	bool debug_en;
 };
 
-#ifdef CONFIG_DRM_MSM_DP_USBPD_LEGACY
+#if IS_ENABLED(CONFIG_DRM_MSM_DP_USBPD_LEGACY)
 /**
  * dp_usbpd_get() - setup usbpd module
  *

msm/dsi/dsi_display.c

@@ -7732,17 +7732,17 @@ int dsi_display_unprepare(struct dsi_display *display)
 	return rc;
 }
 
-static int __init dsi_display_register(void)
+void __init dsi_display_register(void)
 {
 	dsi_phy_drv_register();
 	dsi_ctrl_drv_register();
 
 	dsi_display_parse_boot_display_selection();
 
-	return platform_driver_register(&dsi_display_driver);
+	platform_driver_register(&dsi_display_driver);
 }
 
-static void __exit dsi_display_unregister(void)
+void __exit dsi_display_unregister(void)
 {
 	platform_driver_unregister(&dsi_display_driver);
 	dsi_ctrl_drv_unregister();
@@ -7756,5 +7756,3 @@ module_param_string(dsi_display1, dsi_display_secondary, MAX_CMDLINE_PARAM_LEN,
 								0600);
 MODULE_PARM_DESC(dsi_display1,
 	"msm_drm.dsi_display1=<display node>:<configX> where <display node> is 'secondary dsi display node name' and <configX> where x represents index in the topology list");
-module_init(dsi_display_register);
-module_exit(dsi_display_unregister);

msm/msm_drv.c

@@ -2045,10 +2045,18 @@ static int __init msm_drm_register(void)
 		return -EINVAL;
 
 	DBG("init");
+	sde_rsc_rpmh_register();
+	sde_rsc_register();
+	dsi_display_register();
+	msm_hdcp_register();
+	dp_display_register();
 	msm_smmu_driver_init();
+	sde_rotator_register();
+	sde_rotator_smmu_driver_register();
 	msm_dsi_register();
 	msm_edp_register();
 	msm_hdmi_register();
+	sde_wb_register();
 	return platform_driver_register(&msm_platform_driver);
 }
 
@@ -2056,10 +2064,17 @@ static void __exit msm_drm_unregister(void)
 {
 	DBG("fini");
 	platform_driver_unregister(&msm_platform_driver);
+	sde_wb_unregister();
 	msm_hdmi_unregister();
 	msm_edp_unregister();
 	msm_dsi_unregister();
+	sde_rotator_smmu_driver_unregister();
+	sde_rotator_unregister();
 	msm_smmu_driver_cleanup();
+	msm_hdcp_unregister();
+	dp_display_unregister();
+	dsi_display_unregister();
+	sde_rsc_unregister();
 }
 
 module_init(msm_drm_register);

msm/msm_drv.h

@@ -1101,7 +1101,7 @@ struct drm_fb_helper *msm_fbdev_init(struct drm_device *dev);
 void msm_fbdev_free(struct drm_device *dev);
 
 struct hdmi;
-#ifdef CONFIG_DRM_MSM_HDMI
+#if IS_ENABLED(CONFIG_DRM_MSM_HDMI)
 int msm_hdmi_modeset_init(struct hdmi *hdmi, struct drm_device *dev,
 		struct drm_encoder *encoder);
 void __init msm_hdmi_register(void);
@@ -1113,10 +1113,10 @@ static inline void __init msm_hdmi_register(void)
 static inline void __exit msm_hdmi_unregister(void)
 {
 }
-#endif
+#endif /* CONFIG_DRM_MSM_HDMI */
 
 struct msm_edp;
-#ifdef CONFIG_DRM_MSM_EDP
+#if IS_ENABLED(CONFIG_DRM_MSM_EDP)
 void __init msm_edp_register(void);
 void __exit msm_edp_unregister(void);
 int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev,
@@ -1134,7 +1134,7 @@ static inline int msm_edp_modeset_init(struct msm_edp *edp,
 {
 	return -EINVAL;
 }
-#endif
+#endif /* CONFIG_DRM_MSM_EDP */
 
 struct msm_dsi;
 
@@ -1147,12 +1147,7 @@ struct msm_dsi;
  */
 void msm_mode_object_event_notify(struct drm_mode_object *obj,
 		struct drm_device *dev, struct drm_event *event, u8 *payload);
-#ifndef CONFIG_DRM_MSM_DSI
+#if IS_ENABLED(CONFIG_DRM_MSM_DSI)
-void __init msm_dsi_register(void);
-void __exit msm_dsi_unregister(void);
-int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev,
-			 struct drm_encoder *encoder);
-#else
 static inline void __init msm_dsi_register(void)
 {
 }
@@ -1165,9 +1160,14 @@ static inline int msm_dsi_modeset_init(struct msm_dsi *msm_dsi,
 {
 	return -EINVAL;
 }
-#endif
+#else
+void __init msm_dsi_register(void);
+void __exit msm_dsi_unregister(void);
+int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev,
+			 struct drm_encoder *encoder);
+#endif /* CONFIG_DRM_MSM_DSI */
 
-#ifdef CONFIG_DRM_MSM_MDP5
+#if IS_ENABLED(CONFIG_DRM_MSM_MDP5)
 void __init msm_mdp_register(void);
 void __exit msm_mdp_unregister(void);
 #else
@@ -1177,7 +1177,7 @@ static inline void __init msm_mdp_register(void)
 static inline void __exit msm_mdp_unregister(void)
 {
 }
-#endif
+#endif /* CONFIG_DRM_MSM_MDP5 */
 
 #ifdef CONFIG_DEBUG_FS
 void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m);
@@ -1200,6 +1200,94 @@ static inline void msm_rd_debugfs_cleanup(struct msm_drm_private *priv) {}
 static inline void msm_perf_debugfs_cleanup(struct msm_drm_private *priv) {}
 #endif
 
+#if IS_ENABLED(CONFIG_DRM_MSM_DSI)
+void __init dsi_display_register(void);
+void __exit dsi_display_unregister(void);
+#else
+static inline void __init dsi_display_register(void)
+{
+}
+static inline void __exit dsi_display_unregister(void)
+{
+}
+#endif /* CONFIG_DRM_MSM_DSI */
+
+#if IS_ENABLED(CONFIG_HDCP_QSEECOM)
+void __init msm_hdcp_register(void);
+void __exit msm_hdcp_unregister(void);
+#else
+static inline void __init msm_hdcp_register(void)
+{
+}
+static inline void __exit msm_hdcp_unregister(void)
+{
+}
+#endif /* CONFIG_HDCP_QSEECOM */
+
+#if IS_ENABLED(CONFIG_DRM_MSM_DP)
+void __init dp_display_register(void);
+void __exit dp_display_unregister(void);
+#else
+static inline void __init dp_display_register(void)
+{
+}
+static inline void __exit dp_display_unregister(void)
+{
+}
+#endif /* CONFIG_DRM_MSM_DP */
+
+#if IS_ENABLED(CONFIG_DRM_SDE_RSC)
+void __init sde_rsc_register(void);
+void __exit sde_rsc_unregister(void);
+void __init sde_rsc_rpmh_register(void);
+#else
+static inline void __init sde_rsc_register(void)
+{
+}
+static inline void __exit sde_rsc_unregister(void)
+{
+}
+static inline void __init sde_rsc_rpmh_register(void)
+{
+}
+#endif /* CONFIG_DRM_SDE_RSC */
+
+#if IS_ENABLED(CONFIG_DRM_SDE_WB)
+void __init sde_wb_register(void);
+void __exit sde_wb_unregister(void);
+#else
+static inline void __init sde_wb_register(void)
+{
+}
+static inline void __exit sde_wb_unregister(void)
+{
+}
+#endif /* CONFIG_DRM_SDE_WB */
+
+#if IS_ENABLED(CONFIG_MSM_SDE_ROTATOR)
+void  __init sde_rotator_register(void);
+void __exit sde_rotator_unregister(void);
+#else
+static inline void __init sde_rotator_register(void)
+{
+}
+static inline void __exit sde_rotator_unregister(void)
+{
+}
+#endif /* CONFIG_MSM_SDE_ROTATOR */
+
+#if IS_ENABLED(CONFIG_MSM_SDE_ROTATOR)
+void __init sde_rotator_smmu_driver_register(void);
+void __exit sde_rotator_smmu_driver_unregister(void);
+#else
+static inline void __init sde_rotator_smmu_driver_register(void)
+{
+}
+static inline void __exit sde_rotator_smmu_driver_unregister(void)
+{
+}
+#endif /* CONFIG_MSM_SDE_ROTATOR */
+
 struct clk *msm_clk_get(struct platform_device *pdev, const char *name);
 int msm_clk_bulk_get(struct device *dev, struct clk_bulk_data **bulk);
 

msm/msm_kms.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
  * Copyright (C) 2013 Red Hat
  * Author: Rob Clark <robdclark@gmail.com>
  *
@@ -163,7 +163,7 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev);
 static inline
 struct msm_kms *mdp4_kms_init(struct drm_device *dev) { return NULL; };
 #endif
-#ifdef CONFIG_DRM_MSM_MDP5
+#if IS_ENABLED(CONFIG_DRM_MSM_MDP5)
 struct msm_kms *mdp5_kms_init(struct drm_device *dev);
 int msm_mdss_init(struct drm_device *dev);
 void msm_mdss_destroy(struct drm_device *dev);
@@ -190,7 +190,7 @@ static inline int msm_mdss_disable(struct msm_mdss *mdss)
 {
 	return 0;
 }
-#endif
+#endif /* CONFIG_DRM_MSM_MDP5 */
 
 struct msm_kms *sde_kms_init(struct drm_device *dev);
 

msm/sde/sde_encoder_phys.h

@@ -511,7 +511,7 @@ struct sde_encoder_phys *sde_encoder_phys_cmd_init(
  * @p:	Pointer to init params structure
  * Return: Error code or newly allocated encoder
  */
-#ifdef CONFIG_DRM_SDE_WB
+#if IS_ENABLED(CONFIG_DRM_SDE_WB)
 struct sde_encoder_phys *sde_encoder_phys_wb_init(
 		struct sde_enc_phys_init_params *p);
 #else
@@ -521,7 +521,7 @@ struct sde_encoder_phys *sde_encoder_phys_wb_init(
 {
 	return NULL;
 }
-#endif
+#endif /* CONFIG_DRM_SDE_WB */
 
 void sde_encoder_phys_setup_cdm(struct sde_encoder_phys *phys_enc,
 		struct drm_framebuffer *fb, const struct sde_format *format,

msm/sde/sde_kms.c

@@ -24,7 +24,6 @@
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/dma-buf.h>
-#include <linux/memblock.h>
 #include <drm/drm_atomic_uapi.h>
 #include <drm/drm_probe_helper.h>
 
@@ -61,6 +60,8 @@
 #define MEM_PROTECT_SD_CTRL_SWITCH 0x18
 #define MDP_DEVICE_ID            0x1A
 
+EXPORT_TRACEPOINT_SYMBOL(sde_drm_tracing_mark_write);
+
 static const char * const iommu_ports[] = {
 		"mdp_0",
 };
@@ -727,7 +728,6 @@ static int _sde_kms_release_splash_buffer(unsigned int mem_addr,
 	pfn_start = mem_addr >> PAGE_SHIFT;
 	pfn_end = (mem_addr + splash_buffer_size) >> PAGE_SHIFT;
 
-	ret = memblock_free(mem_addr, splash_buffer_size);
 	if (ret) {
 		SDE_ERROR("continuous splash memory free failed:%d\n", ret);
 		return ret;

msm/sde/sde_trace.h

@@ -113,7 +113,7 @@ TRACE_EVENT(sde_encoder_underrun,
 		__entry->underrun_cnt)
 );
 
-TRACE_EVENT(tracing_mark_write,
+TRACE_EVENT(sde_drm_tracing_mark_write,
 	TP_PROTO(char trace_type, const struct task_struct *task,
 		const char *name, int value),
 	TP_ARGS(trace_type, task, name, value),
@@ -390,7 +390,7 @@ TRACE_EVENT(sde_perf_uidle_status,
 			)
 );
 
-#define sde_atrace trace_tracing_mark_write
+#define sde_atrace trace_sde_drm_tracing_mark_write
 
 #define SDE_ATRACE_END(name) sde_atrace('E', current, name, 0)
 #define SDE_ATRACE_BEGIN(name) sde_atrace('B', current, name, 0)

msm/sde/sde_wb.c

@@ -824,15 +824,12 @@ static struct platform_driver sde_wb_driver = {
 	},
 };
 
-static int __init sde_wb_register(void)
+void __init sde_wb_register(void)
 {
-	return platform_driver_register(&sde_wb_driver);
+	platform_driver_register(&sde_wb_driver);
 }
 
-static void __exit sde_wb_unregister(void)
+void __exit sde_wb_unregister(void)
 {
 	platform_driver_unregister(&sde_wb_driver);
 }
-
-module_init(sde_wb_register);
-module_exit(sde_wb_unregister);

msm/sde/sde_wb.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
  */
 
 #ifndef __SDE_WB_H__
@@ -60,7 +60,7 @@ int sde_wb_get_index(struct sde_wb_device *wb_dev)
 	return wb_dev ? wb_dev->index : -1;
 }
 
-#ifdef CONFIG_DRM_SDE_WB
+#if IS_ENABLED(CONFIG_DRM_SDE_WB)
 /**
  * sde_wb_get_output_fb - get framebuffer in current atomic state
  * @wb_dev:	Pointer to writeback device
@@ -357,6 +357,6 @@ int sde_wb_get_mode_info(struct drm_connector *connector,
 {
 	return 0;
 }
-#endif
+#endif /* CONFIG_DRM_SDE_WB */
 #endif /* __SDE_WB_H__ */
 

msm/sde_io_util.c

@@ -82,7 +82,6 @@ static struct resource *msm_dss_get_res_byname(struct platform_device *pdev,
 
 	return res;
 } /* msm_dss_get_res_byname */
-EXPORT_SYMBOL(msm_dss_get_res_byname);
 
 int msm_dss_ioremap_byname(struct platform_device *pdev,
 	struct dss_io_data *io_data, const char *name)

msm/sde_rsc.c

@@ -1843,8 +1843,6 @@ static const struct of_device_id dt_match[] = {
 	{},
 };
 
-MODULE_DEVICE_TABLE(of, dt_match);
-
 static struct platform_driver sde_rsc_platform_driver = {
 	.probe      = sde_rsc_probe,
 	.remove     = sde_rsc_remove,
@@ -1869,21 +1867,17 @@ static struct platform_driver sde_rsc_rpmh_driver = {
 	},
 };
 
-static int __init sde_rsc_register(void)
+void __init sde_rsc_register(void)
 {
-	return platform_driver_register(&sde_rsc_platform_driver);
+	platform_driver_register(&sde_rsc_platform_driver);
 }
 
-static void __exit sde_rsc_unregister(void)
+void __exit sde_rsc_unregister(void)
 {
 	platform_driver_unregister(&sde_rsc_platform_driver);
 }
 
-static int __init sde_rsc_rpmh_register(void)
+void __init sde_rsc_rpmh_register(void)
 {
-	return platform_driver_register(&sde_rsc_rpmh_driver);
+	platform_driver_register(&sde_rsc_rpmh_driver);
 }
-
-subsys_initcall(sde_rsc_rpmh_register);
-module_init(sde_rsc_register);
-module_exit(sde_rsc_unregister);

rotator/sde_rotator_dev.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
  */
 #define pr_fmt(fmt)	"%s:%d: " fmt, __func__, __LINE__
 
@@ -3618,16 +3618,12 @@ static struct platform_driver rotator_driver = {
 	},
 };
 
-static int __init sde_rotator_init_module(void)
+void  __init sde_rotator_register(void)
 {
-	return platform_driver_register(&rotator_driver);
+	platform_driver_register(&rotator_driver);
 }
 
-static void __exit sde_rotator_exit_module(void)
+void __exit sde_rotator_unregister(void)
 {
 	platform_driver_unregister(&rotator_driver);
 }
-
-late_initcall(sde_rotator_init_module);
-module_exit(sde_rotator_exit_module);
-MODULE_DESCRIPTION("MSM SDE ROTATOR driver");

rotator/sde_rotator_inline.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
  */
 
 #ifndef __SDE_ROTATOR_INLINE_H__
@@ -96,7 +96,7 @@ struct sde_rotator_inline_cmd {
 	void *priv_handle;
 };
 
-#if defined(CONFIG_MSM_SDE_ROTATOR)
+#if IS_ENABLED(CONFIG_MSM_SDE_ROTATOR)
 
 void *sde_rotator_inline_open(struct platform_device *pdev);
 int sde_rotator_inline_get_dst_pixfmt(struct platform_device *pdev,

rotator/sde_rotator_smmu.c

@@ -494,7 +494,6 @@ static const struct of_device_id sde_smmu_dt_match[] = {
 	{ .compatible = SMMU_SDE_ROT_SEC, .data = &sde_rot_sec},
 	{}
 };
-MODULE_DEVICE_TABLE(of, sde_smmu_dt_match);
 
 /*
  * sde_smmu_probe()
@@ -673,28 +672,12 @@ static struct platform_driver sde_smmu_driver = {
 	},
 };
 
-static int sde_smmu_register_driver(void)
+void __init sde_rotator_smmu_driver_register(void)
 {
-	return platform_driver_register(&sde_smmu_driver);
+	platform_driver_register(&sde_smmu_driver);
 }
 
-static int __init sde_smmu_driver_init(void)
+void __exit sde_rotator_smmu_driver_unregister(void)
-{
-	int ret;
-
-	ret = sde_smmu_register_driver();
-	if (ret)
-		SDEROT_ERR("sde_smmu_register_driver() failed!\n");
-
-	return ret;
-}
-module_init(sde_smmu_driver_init);
-
-static void __exit sde_smmu_driver_cleanup(void)
 {
 	platform_driver_unregister(&sde_smmu_driver);
 }
-module_exit(sde_smmu_driver_cleanup);
-
-MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("SDE SMMU driver");