IKXCLOCK-193:Init mechanism of M4 based drivers

Change-Id: I3c665f1c31d14e73d3776982d570c250e6f8c3b1
Reviewed-on: http://gerrit.pcs.mot.com/608745
SLTApproved: Slta Waiver <sltawvr@motorola.com>
Tested-by: Jira Key <jirakey@motorola.com>
Reviewed-by: Sajid Dalvi <fsd017@motorola.com>
Submit-Approved: Jira Key <jirakey@motorola.com>

12 files changed, 125 insertions, 66 deletions

diff --git a/drivers/mfd/m4sensorhub-core.c b/drivers/mfd/m4sensorhub-core.c
index cb8bad9743f..5d0b83912f8 100644
--- a/drivers/mfd/m4sensorhub-core.c
+++ b/drivers/mfd/m4sensorhub-core.c
@@ -51,7 +51,8 @@ static struct miscdevice m4sensorhub_misc_device = {
 };
 
 struct init_call {
-	int(*initcb)(struct m4sensorhub_data *);
+	int(*initcb)(struct init_calldata *);
+	void *pdata;
 	struct init_call *next;
 };
 
@@ -301,7 +302,8 @@ static void m4sensorhub_hw_free(struct m4sensorhub_data *m4sensorhub)
 	m4sensorhub->filename = NULL;
 }
 
-int m4sensorhub_register_initcall(int(*initfunc)(struct m4sensorhub_data *))
+int m4sensorhub_register_initcall(int(*initfunc)(struct init_calldata *),
+								void *pdata)
 {
 	struct init_call *inc = NULL;
 
@@ -311,6 +313,7 @@ int m4sensorhub_register_initcall(int(*initfunc)(struct m4sensorhub_data *))
 		return -ENOMEM;
 	}
 	inc->initcb = initfunc;
+	inc->pdata = pdata;
 	/* add it to the list */
 	if (inithead == NULL)
 		inc->next = NULL;
@@ -321,7 +324,7 @@ int m4sensorhub_register_initcall(int(*initfunc)(struct m4sensorhub_data *))
 }
 EXPORT_SYMBOL_GPL(m4sensorhub_register_initcall);
 
-void m4sensorhub_unregister_initcall(int(*initfunc)(struct m4sensorhub_data *))
+void m4sensorhub_unregister_initcall(int(*initfunc)(struct init_calldata *))
 {
 	struct init_call *node = inithead;
 	struct init_call *prev;
@@ -348,6 +351,7 @@ static void m4sensorhub_initialize(const struct firmware *firmware,
 {
 	int err = 0;
 	struct init_call *inc, *prev;
+	struct init_calldata arg;
 
 	if (firmware == NULL) {
 		KDEBUG(M4SH_ERROR, "%s:No firmware data recieved\n", __func__);
@@ -382,9 +386,11 @@ static void m4sensorhub_initialize(const struct firmware *firmware,
 
 	/* Initialize all the m4 drivers */
 	inc = inithead;
+	arg.p_m4sensorhub_data = &m4sensorhub_misc_data;
 	prev = NULL;
 	while (inc) {
-		err = inc->initcb(&m4sensorhub_misc_data);
+		arg.p_data = inc->pdata;
+		err = inc->initcb(&arg);
 		if (err < 0)
 			dump_stack();
 		prev = inc;
diff --git a/drivers/misc/m4sensorhub_audio.c b/drivers/misc/m4sensorhub_audio.c
index 7ab475df9aa..86d737230f7 100644
--- a/drivers/misc/m4sensorhub_audio.c
+++ b/drivers/misc/m4sensorhub_audio.c
@@ -349,9 +349,10 @@ static const struct file_operations audio_client_fops = {
 	.read = audio_client_read,
 };
 
-static int audio_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int audio_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 
 	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_MIC_DATA_READY,
 		m4_handle_audio_irq, audio_data);
@@ -387,7 +388,8 @@ static int audio_client_probe(struct spi_device *spi)
 	}
 	audio_client_data->dev_dsp = ret;
 	audio_client_data->dev_dsp_open_count = 0;
-	ret = m4sensorhub_register_initcall(audio_driver_init);
+	ret = m4sensorhub_register_initcall(audio_driver_init,
+						audio_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for audio client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_bmp180.c b/drivers/misc/m4sensorhub_bmp180.c
index 933f583f8ba..02fa1e7c102 100644
--- a/drivers/misc/m4sensorhub_bmp180.c
+++ b/drivers/misc/m4sensorhub_bmp180.c
@@ -240,9 +240,10 @@ static struct miscdevice pressure_client_miscdrv = {
 };
 
 
-static int pressure_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int pressure_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 	ret = m4sensorhub_irq_register(m4sensorhub,
 					M4SH_IRQ_PRESSURE_DATA_READY,
 					m4_handle_pressure_irq,
@@ -299,7 +300,8 @@ static int pressure_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_pressure_data = pressure_client_data;
-	ret = m4sensorhub_register_initcall(pressure_driver_init);
+	ret = m4sensorhub_register_initcall(pressure_driver_init,
+					pressure_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for pressure client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_display.c b/drivers/misc/m4sensorhub_display.c
index a5b81d3375a..0c8cf733337 100644
--- a/drivers/misc/m4sensorhub_display.c
+++ b/drivers/misc/m4sensorhub_display.c
@@ -391,9 +391,10 @@ static void display_panic_restore(\
 	}
 }
 
-static int display_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int display_driver_init(struct init_calldata *p_arg)
 {
 	int err;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 
 	err = m4sensorhub_panic_register(m4sensorhub, PANICHDL_DISPLAY_RESTORE,
 		display_panic_restore, global_display_data);
@@ -448,7 +449,7 @@ static int display_client_probe(struct platform_device *pdev)
 	mutex_init(&(display_data->m4_mutex));
 
 	global_display_data = display_data;
-	ret = m4sensorhub_register_initcall(display_driver_init);
+	ret = m4sensorhub_register_initcall(display_driver_init, display_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for display client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_download.c b/drivers/misc/m4sensorhub_download.c
index a671a393f88..85206e228f9 100644
--- a/drivers/misc/m4sensorhub_download.c
+++ b/drivers/misc/m4sensorhub_download.c
@@ -311,9 +311,10 @@ static struct miscdevice download_client_miscdrv = {
 	.fops = &download_client_fops,
 };
 
-static int download_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int download_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY,
 					m4_handle_download_irq,
 					misc_download_data);
@@ -360,7 +361,8 @@ static int download_client_probe(struct platform_device *pdev)
 		goto free_memory;
 	}
 	misc_download_data = download_client_data;
-	ret = m4sensorhub_register_initcall(download_driver_init);
+	ret = m4sensorhub_register_initcall(download_driver_init,
+						download_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for download client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_gesture.c b/drivers/misc/m4sensorhub_gesture.c
index 21eaba7e82a..eb814fa220b 100644
--- a/drivers/misc/m4sensorhub_gesture.c
+++ b/drivers/misc/m4sensorhub_gesture.c
@@ -245,9 +245,10 @@ static struct miscdevice gesture_client_miscdrv = {
 	.fops = &gesture_client_fops,
 };
 
-static int gesture_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int gesture_driver_init(struct init_calldata *p_arg)
 {
 	int ret = 0;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED,
 					m4_handle_gesture_irq,
 					misc_gesture_data);
@@ -326,7 +327,8 @@ static int gesture_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_gesture_data = gesture_client_data;
-	ret = m4sensorhub_register_initcall(gesture_driver_init);
+	ret = m4sensorhub_register_initcall(gesture_driver_init,
+						gesture_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function"
 			"for gesture client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_mpu9150.c b/drivers/misc/m4sensorhub_mpu9150.c
index 6cc7a838081..e3ee394d1a2 100644
--- a/drivers/misc/m4sensorhub_mpu9150.c
+++ b/drivers/misc/m4sensorhub_mpu9150.c
@@ -903,7 +903,7 @@ static int mpu9150_irq_enable_disable(struct mpu9150_client *mpu9150_client_data
 	return ret;
 }
 
-static int mpu9150_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int mpu9150_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
 	ret = mpu9150_irq_init(misc_mpu9150_data);
@@ -982,7 +982,8 @@ static int mpu9150_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_mpu9150_data = mpu9150_client_data;
-	ret = m4sensorhub_register_initcall(mpu9150_driver_init);
+	ret = m4sensorhub_register_initcall(mpu9150_driver_init,
+					mpu9150_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function"
 			"for mpu9150 client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_passive.c b/drivers/misc/m4sensorhub_passive.c
index b875afbd80c..6e40b5c4c1d 100644
--- a/drivers/misc/m4sensorhub_passive.c
+++ b/drivers/misc/m4sensorhub_passive.c
@@ -168,9 +168,10 @@ static struct miscdevice passive_client_miscdrv = {
 	.fops = &passive_client_fops,
 };
 
-static int passive_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int passive_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 	ret = m4sensorhub_irq_register(m4sensorhub,
 					M4SH_IRQ_PASSIVE_BUFFER_FULL,
 					m4_handle_passive_irq,
@@ -239,7 +240,8 @@ static int passive_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_passive_data = passive_client_data;
-	ret = m4sensorhub_register_initcall(passive_driver_init);
+	ret = m4sensorhub_register_initcall(passive_driver_init,
+					passive_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function"
 			"for passive client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_pedometer.c b/drivers/misc/m4sensorhub_pedometer.c
index 7b17c022fc0..88faa11f04b 100644
--- a/drivers/misc/m4sensorhub_pedometer.c
+++ b/drivers/misc/m4sensorhub_pedometer.c
@@ -357,9 +357,10 @@ static struct miscdevice pedometer_client_miscdrv = {
 	.fops = &pedometer_client_fops,
 };
 
-static int pedometer_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int pedometer_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 
 	ret = m4sensorhub_irq_register(m4sensorhub,
 					M4SH_IRQ_PEDOMETER_DATA_READY,
@@ -449,7 +450,8 @@ static int pedometer_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_pedometer_data = pedometer_client_data;
-	ret = m4sensorhub_register_initcall(pedometer_driver_init);
+	ret = m4sensorhub_register_initcall(pedometer_driver_init,
+					pedometer_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for pedometer client = %d\n", ret);
diff --git a/drivers/misc/m4sensorhub_stillmode.c b/drivers/misc/m4sensorhub_stillmode.c
index bfd56cc28a7..20ced175c6c 100644
--- a/drivers/misc/m4sensorhub_stillmode.c
+++ b/drivers/misc/m4sensorhub_stillmode.c
@@ -224,9 +224,10 @@ static DEVICE_ATTR(state, 0664, m4_stillmode_getstate,
 static DEVICE_ATTR(timeout, 0664, m4_stillmode_get_timeout,
 		   m4_stillmode_set_timeout);
 
-static int stillmode_driver_init(struct m4sensorhub_data *m4sensorhub)
+static int stillmode_driver_init(struct init_calldata *p_arg)
 {
 	int ret;
+	struct m4sensorhub_data *m4sensorhub = p_arg->p_m4sensorhub_data;
 
 	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_STILL_DETECTED,
 					m4_handle_stillmode_irq,
@@ -320,7 +321,8 @@ static int stillmode_client_probe(struct platform_device *pdev)
 	INIT_WORK(&stillmode_client_data->queued_work,
 		m4sensorhub_stillmode_work);
 
-	ret = m4sensorhub_register_initcall(stillmode_driver_init);
+	ret = m4sensorhub_register_initcall(stillmode_driver_init,
+							stillmode_client_data);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "Unable to register init function "
 			"for stillmode client = %d\n", ret);
diff --git a/drivers/rtc/rtc-sensorhub.c b/drivers/rtc/rtc-sensorhub.c
index 46b68ce7e70..8c4a4e9b1fc 100644
--- a/drivers/rtc/rtc-sensorhub.c
+++ b/drivers/rtc/rtc-sensorhub.c
@@ -11,18 +11,26 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/rtc.h>
+#include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/m4sensorhub.h>
 #include <linux/m4sensorhub/m4sensorhub_registers.h>
 
-static bool g_m4ready;
+struct rtc_sensorhub_private_data {
+	struct rtc_device *p_rtc;
+	struct m4sensorhub_data *p_m4sensorhub_data;
+};
 
 static int rtc_sensorhub_rtc_read_alarm(struct device *dev,
 	struct rtc_wkalrm *alrm)
 {
+	struct platform_device *pdev = to_platform_device(dev);
+	struct rtc_sensorhub_private_data *p_priv_data =
+						platform_get_drvdata(pdev);
+
 	pr_err("%s:\n", __func__);
 
-	if (!g_m4ready) {
+	if (!(p_priv_data->p_m4sensorhub_data)) {
 		pr_err("%s: ignore func call\n", __func__);
 		return -EIO;
 	}
@@ -33,9 +41,12 @@ static int rtc_sensorhub_rtc_read_alarm(struct device *dev,
 static int rtc_sensorhub_rtc_set_alarm(struct device *dev,
 	struct rtc_wkalrm *alrm)
 {
+	struct platform_device *pdev = to_platform_device(dev);
+	struct rtc_sensorhub_private_data *p_priv_data =
+						platform_get_drvdata(pdev);
 	pr_err("%s:\n", __func__);
 
-	if (!g_m4ready) {
+	if (!(p_priv_data->p_m4sensorhub_data)) {
 		pr_err("%s: ignore func call\n", __func__);
 		return -EIO;
 	}
@@ -43,11 +54,10 @@ static int rtc_sensorhub_rtc_set_alarm(struct device *dev,
 	return 0;
 }
 
-static int rtc_sensorhub_get_rtc_from_m4(struct rtc_time *p_tm)
+static int rtc_sensorhub_get_rtc_from_m4(struct rtc_time *p_tm,
+			struct m4sensorhub_data *p_m4_drvdata)
 {
-	struct m4sensorhub_data *p_m4_drvdata;
 	u32 seconds;
-	p_m4_drvdata = m4sensorhub_client_get_drvdata();
 
 	if (m4sensorhub_reg_getsize(p_m4_drvdata,
 		M4SH_REG_GENERAL_UTC) != m4sensorhub_reg_read(
@@ -65,8 +75,11 @@ static int rtc_sensorhub_rtc_read_time(struct device *dev,
 	struct rtc_time *p_tm)
 {
 	int err;
+	struct platform_device *pdev = to_platform_device(dev);
+	struct rtc_sensorhub_private_data *p_priv_data =
+						platform_get_drvdata(pdev);
 
-	if (!g_m4ready) {
+	if (!(p_priv_data->p_m4sensorhub_data)) {
 		pr_err("%s: func called, RTC hardware not ready\n", __func__);
 		/* M4 driver is not yet ready, just give the time since boot
 		and treat boot as start of epoch */
@@ -74,7 +87,8 @@ static int rtc_sensorhub_rtc_read_time(struct device *dev,
 		return 0;
 	}
 
-	err = rtc_sensorhub_get_rtc_from_m4(p_tm);
+	err = rtc_sensorhub_get_rtc_from_m4(p_tm,
+		p_priv_data->p_m4sensorhub_data);
 
 	return err;
 }
@@ -84,13 +98,16 @@ static int rtc_sensorhub_rtc_set_time(struct device *dev,
 {
 	u32 seconds;
 	unsigned long sec;
-	struct m4sensorhub_data *p_m4_drvdata;
+	struct platform_device *pdev = to_platform_device(dev);
+	struct rtc_sensorhub_private_data *p_priv_data =
+						platform_get_drvdata(pdev);
+	struct m4sensorhub_data *p_m4_drvdata =
+			p_priv_data->p_m4sensorhub_data;
 
-	if (!g_m4ready) {
+	if (!(p_m4_drvdata)) {
 		pr_err("%s: ignore func call\n", __func__);
 		return 0;
 	}
-	p_m4_drvdata = m4sensorhub_client_get_drvdata();
 
 	/* M4 expects the UTC time in seconds from Jan 1, 1970,
 	basically epoch_time in seconds */
@@ -115,10 +132,6 @@ static int rtc_sensorhub_rtc_set_mmss(struct device *dev, unsigned long secs)
 	/* TODO : implement a real handler*/
 	dev_info(dev, "%s, secs = %lu\n", __func__, secs);
 
-	if (!g_m4ready) {
-		pr_err("%s: ignore func call\n", __func__);
-		return -EIO;
-	}
 	return 0;
 }
 
@@ -145,10 +158,6 @@ static int rtc_sensorhub_rtc_alarm_irq_enable(struct device *dev,
 					unsigned int enable)
 {
 	/* TODO : implement a real handler*/
-	if (!g_m4ready) {
-		pr_err("%s: ignore func call\n", __func__);
-		return 0;
-	}
 	return 0;
 }
 
@@ -165,11 +174,6 @@ static const struct rtc_class_ops rtc_sensorhub_rtc_ops = {
 static ssize_t rtc_sensorhub_irq_show(struct device *dev,
 				struct device_attribute *attr, char *buf)
 {
-	/* TODO : implement a real handler*/
-	if (!g_m4ready) {
-		pr_err("%s: ignore func call\n", __func__);
-		return -EIO;
-	}
 	return sprintf(buf, "%d\n", 42);
 }
 static ssize_t rtc_sensorhub_irq_store(struct device *dev,
@@ -178,26 +182,25 @@ static ssize_t rtc_sensorhub_irq_store(struct device *dev,
 {
 	/* TODO : implement a real handler*/
 	pr_err("%s:\n", __func__);
-	if (!g_m4ready) {
-		pr_err("%s: ignore func call\n", __func__);
-		return -EIO;
-	}
 	return count;
 }
 
 static DEVICE_ATTR(irq, S_IRUGO | S_IWUSR, rtc_sensorhub_irq_show,
 						rtc_sensorhub_irq_store);
 
-static int rtc_sensorhub_init(struct m4sensorhub_data *m4sensorhub)
+static int rtc_sensorhub_init(struct init_calldata *p_arg)
 {
 	struct rtc_time rtc;
 	int err;
 	struct timespec tv;
+	struct rtc_sensorhub_private_data *p_priv_data =
+			(struct rtc_sensorhub_private_data *)(p_arg->p_data);
 
-	g_m4ready = true;
+	p_priv_data->p_m4sensorhub_data = p_arg->p_m4sensorhub_data;
 
 	/* read RTC time from M4 and set the system time */
-	err = rtc_sensorhub_get_rtc_from_m4(&rtc);
+	err = rtc_sensorhub_get_rtc_from_m4(&rtc,
+				p_priv_data->p_m4sensorhub_data);
 	if (err) {
 		pr_err("%s: get_rtc failed\n", __func__);
 		return 0;
@@ -223,52 +226,71 @@ static int rtc_sensorhub_init(struct m4sensorhub_data *m4sensorhub)
 static int rtc_sensorhub_probe(struct platform_device *plat_dev)
 {
 	int err;
-	struct rtc_device *rtc;
+	struct rtc_device *p_rtc;
+	struct rtc_sensorhub_private_data *p_priv_data;
+
+	p_priv_data = kzalloc(sizeof(*p_priv_data),
+					GFP_KERNEL);
+	if (!p_priv_data)
+		return -ENOMEM;
+
+	p_priv_data->p_m4sensorhub_data = NULL;
+	/* Set the private data before registering this driver with RTC core
+	since hctosys will call rtc interface right away, we need to make sure
+	our private data is set by this time */
+	platform_set_drvdata(plat_dev, p_priv_data);
 
 	err = device_init_wakeup(&plat_dev->dev, true);
 	if (err) {
 		pr_err("%s: failed to init as wakeup\n", __func__);
-		return err;
+		goto err_free_priv_data;
 	}
 
-	rtc = devm_rtc_device_register(&plat_dev->dev, "rtc_sensorhub",
+	p_rtc = devm_rtc_device_register(&plat_dev->dev, "rtc_sensorhub",
 				&rtc_sensorhub_rtc_ops, THIS_MODULE);
 
-	if (IS_ERR(rtc)) {
-		err = PTR_ERR(rtc);
+	if (IS_ERR(p_rtc)) {
+		err = PTR_ERR(p_rtc);
 		goto err_disable_wakeup;
 	}
 
+	p_priv_data->p_rtc = p_rtc;
+
 	err = device_create_file(&plat_dev->dev, &dev_attr_irq);
 	if (err)
 		goto err_unregister_rtc;
 
-	err = m4sensorhub_register_initcall(rtc_sensorhub_init);
+	err = m4sensorhub_register_initcall(rtc_sensorhub_init, p_priv_data);
 	if (err) {
 		pr_err("%s: can't register init with m4\n", __func__);
 		goto err_remove_file;
 	}
 
-	platform_set_drvdata(plat_dev, rtc);
-
 	return 0;
 
 err_remove_file:
 	device_remove_file(&plat_dev->dev, &dev_attr_irq);
 err_unregister_rtc:
-	devm_rtc_device_unregister(&plat_dev->dev, rtc);
+	devm_rtc_device_unregister(&plat_dev->dev, p_rtc);
+	kfree(p_rtc);
 err_disable_wakeup:
 	device_init_wakeup(&plat_dev->dev, false);
+err_free_priv_data:
+	kfree(p_priv_data);
 	return err;
 }
 
 static int rtc_sensorhub_remove(struct platform_device *plat_dev)
 {
-	struct rtc_device *rtc = platform_get_drvdata(plat_dev);
+	struct rtc_sensorhub_private_data *p_priv_data =
+						platform_get_drvdata(plat_dev);
+	struct rtc_device *p_rtc = p_priv_data->p_rtc;
 	device_remove_file(&plat_dev->dev, &dev_attr_irq);
 	device_init_wakeup(&plat_dev->dev, false);
-	devm_rtc_device_unregister(&plat_dev->dev, rtc);
+	devm_rtc_device_unregister(&plat_dev->dev, p_rtc);
 	m4sensorhub_unregister_initcall(rtc_sensorhub_init);
+	kfree(p_priv_data->p_rtc);
+	kfree(p_priv_data);
 	return 0;
 }
 
diff --git a/include/linux/m4sensorhub.h b/include/linux/m4sensorhub.h
index d2a4a094715..c93321562ba 100644
--- a/include/linux/m4sensorhub.h
+++ b/include/linux/m4sensorhub.h
@@ -81,6 +81,15 @@ enum m4sensorhub_panichdl_index {
 
 struct m4sensorhub_data;
 
+/* args passed to init callback,
+	p_m4sensorhub_data is pointer to M4's data
+	p_data is the void * that was registered along
+		with the function pointer*/
+struct init_calldata {
+	struct m4sensorhub_data *p_m4sensorhub_data;
+	void *p_data;
+};
+
 struct m4sensorhub_platform_data {
 	int (*hw_init)(struct m4sensorhub_data *);
 	void (*hw_free)(struct m4sensorhub_data *);
@@ -203,9 +212,15 @@ int m4sensorhub_panic_register(struct m4sensorhub_data *m4sensorhub,
 int m4sensorhub_panic_unregister(struct m4sensorhub_data *m4sensorhub,
 				enum m4sensorhub_panichdl_index index);
 void m4sensorhub_panic_process(struct m4sensorhub_data *m4sensorhub);
-int m4sensorhub_register_initcall(int(*initfunc)(struct m4sensorhub_data *));
+/* all M4 based drivers need to register an init call with the core,
+ this callback will be executed once M4 core has properly set up FW
+ on M4. For registration, a callback and a void* is passed in. When
+ the callback is executed, the client provided void* is passed back
+ as part of (init_calldata).p_data */
+int m4sensorhub_register_initcall(int(*initfunc)(struct init_calldata *),
+							void *pdata);
 void m4sensorhub_unregister_initcall(
-		int(*initfunc)(struct m4sensorhub_data *));
+		int(*initfunc)(struct init_calldata *));
 
 
 #endif /* __KERNEL__ */