IKG5-1478: Change m4 kernel modules to be kernel builtins

Change-Id: I39210cb9b0d0cf75042b5adcfa57da8b800f89a5
Reviewed-on: http://gerrit.pcs.mot.com/588276
SLTApproved: Slta Waiver <sltawvr@motorola.com>
Tested-by: Jira Key <jirakey@motorola.com>
Reviewed-by: Douglas Zobel <dzobel1@motorola.com>
Reviewed-by: Sajid Dalvi <fsd017@motorola.com>
Reviewed-by: Jee Su Chang <w20740@motorola.com>
Submit-Approved: Jira Key <jirakey@motorola.com>

19 files changed, 432 insertions, 2002 deletions

diff --git a/arch/arm/configs/minnow_defconfig b/arch/arm/configs/minnow_defconfig
index e10cd468104..ecb2043ef4a 100644
--- a/arch/arm/configs/minnow_defconfig
+++ b/arch/arm/configs/minnow_defconfig
@@ -1508,6 +1508,7 @@ CONFIG_REGULATOR_FIXED_VOLTAGE=y
 CONFIG_REGULATOR_TPS65912=y
 CONFIG_REGULATOR_CPCAP=y
 # CONFIG_MEDIA_SUPPORT is not set
+CONFIG_MFD_M4SENSORHUB=y
 
 #
 # Graphics support
diff --git a/drivers/mfd/m4sensorhub-core.c b/drivers/mfd/m4sensorhub-core.c
index cd86cc7e7c2..14bc2d26071 100644
--- a/drivers/mfd/m4sensorhub-core.c
+++ b/drivers/mfd/m4sensorhub-core.c
@@ -33,6 +33,7 @@
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/delay.h>
+#include <linux/firmware.h>
 
 
 #define M4SENSORHUB_NUM_GPIOS       6
@@ -49,9 +50,16 @@ static struct miscdevice m4sensorhub_misc_device = {
 	.name = M4SENSORHUB_DRIVER_NAME,
 };
 
+struct init_call {
+	int(*initcb)(struct m4sensorhub_data *);
+	struct init_call *next;
+};
+
 /* --------------- Local Declarations -------------- */
-static struct m4sensorhub_data *m4sensorhub_misc_data;
+static struct m4sensorhub_data m4sensorhub_misc_data;
 static DEFINE_MUTEX(m4sensorhub_driver_lock);
+static struct init_call *inithead;
+static int firmware_download_status = -1;
 
 unsigned short force_upgrade;
 module_param(force_upgrade, short, 0644);
@@ -65,7 +73,7 @@ MODULE_PARM_DESC(debug_level, "Set debug level 1 (CRITICAL) to "
 /* -------------- Global Functions ----------------- */
 struct m4sensorhub_data *m4sensorhub_client_get_drvdata(void)
 {
-	return m4sensorhub_misc_data;
+	return &m4sensorhub_misc_data;
 }
 EXPORT_SYMBOL_GPL(m4sensorhub_client_get_drvdata);
 
@@ -281,8 +289,91 @@ static void minnow_m4sensorhub_hw_free(struct m4sensorhub_data *m4sensorhub)
 	m4sensorhub->filename = NULL;
 }
 
+int m4sensorhub_register_initcall(int(*initfunc)(struct m4sensorhub_data *))
+{
+	struct init_call *inc = NULL;
+
+	inc = kzalloc(sizeof(struct init_call), GFP_KERNEL);
+	if (inc == NULL) {
+		KDEBUG(M4SH_ERROR, "Unable to allocate for init call\n");
+		return -ENOMEM;
+	}
+	inc->initcb = initfunc;
+	/* add it to the list */
+	if (inithead == NULL)
+		inc->next = NULL;
+	else
+		inc->next = inithead;
+	inithead = inc;
+	return 0;
+}
+EXPORT_SYMBOL_GPL(m4sensorhub_register_initcall);
+
+void m4sensorhub_unregister_initcall(int(*initfunc)(struct m4sensorhub_data *))
+{
+	struct init_call *node = inithead;
+	struct init_call *prev;
+
+	for (node = inithead, prev = NULL;
+		node != NULL;
+		prev = node, node = node->next) {
+		if (node->initcb == initfunc) {
+			/* remove this node */
+			if (node == inithead)
+				inithead = node->next;
+			else
+				prev->next = node->next;
+			kfree(node);
+		}
+	}
+}
+EXPORT_SYMBOL_GPL(m4sensorhub_unregister_initcall);
 /* END BOARD FILE FUNCTIONS */
 
+/* Downloads m4 firmware and also initializes all m4 drivers */
+static void m4sensorhub_initialize(const struct firmware *firmware,
+					void *context)
+{
+	int err = 0;
+	struct init_call *inc, *prev;
+
+	if (firmware == NULL) {
+		KDEBUG(M4SH_ERROR, "%s:No firmware data recieved\n", __func__);
+		return;
+	}
+
+	/* initiate m4 firmware download */
+	firmware_download_status = m4sensorhub_load_firmware(
+					&m4sensorhub_misc_data,
+					force_upgrade,
+					firmware);
+
+	if (firmware_download_status < 0) {
+		KDEBUG(M4SH_ERROR, "Failed to load M4 firmware = %d\n", err);
+		/* Since firmware download failed, put m4 back into boot mode*/
+		minnow_m4sensorhub_hw_reset(&m4sensorhub_misc_data);
+		return;
+	}
+
+	err = m4sensorhub_irq_init(&m4sensorhub_misc_data);
+	if (err < 0) {
+		KDEBUG(M4SH_ERROR, "M4sensorhub irq init failed\n");
+		return;
+	}
+
+	/* Initialize all the m4 drivers */
+	inc = inithead;
+	prev = NULL;
+	while (inc) {
+		err = inc->initcb(&m4sensorhub_misc_data);
+		if (err < 0)
+			dump_stack();
+		prev = inc;
+		inc = inc->next;
+		kfree(prev);
+	}
+}
+
 static ssize_t m4sensorhub_set_dbg(struct device *dev,
 	struct device_attribute *attr, const char *buf, size_t count)
 {
@@ -307,7 +398,7 @@ static ssize_t m4sensorhub_get_loglevel(struct device *dev,
 {
 	unsigned long long loglevel;
 
-	m4sensorhub_reg_read(m4sensorhub_misc_data,
+	m4sensorhub_reg_read(&m4sensorhub_misc_data,
 		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
 	KDEBUG(M4SH_INFO, "M4 loglevel = %llx", loglevel);
 	return sprintf(buf, "%llu\n", loglevel);
@@ -354,7 +445,7 @@ static ssize_t m4sensorhub_set_loglevel(struct device *dev,
 	char *tag, *level;
 	char **logbuf = (char **) &buf;
 
-	m4sensorhub_reg_read(m4sensorhub_misc_data,
+	m4sensorhub_reg_read(&m4sensorhub_misc_data,
 		M4SH_REG_LOG_LOGENABLE, (char *)&currentLogLevels);
 	while (1) {
 		tag = strsep(logbuf, "=,\n ");
@@ -366,7 +457,7 @@ static ssize_t m4sensorhub_set_loglevel(struct device *dev,
 		ParseAndUpdateLogLevels(tag, level, &currentLogLevels);
 	}
 
-	return m4sensorhub_reg_write(m4sensorhub_misc_data,
+	return m4sensorhub_reg_write(&m4sensorhub_misc_data,
 		M4SH_REG_LOG_LOGENABLE, (char *)&currentLogLevels,
 		m4sh_no_mask);
 }
@@ -377,7 +468,7 @@ static DEVICE_ATTR(log_level, S_IRUGO|S_IWUGO, m4sensorhub_get_loglevel,
 static int m4sensorhub_probe(struct i2c_client *client,
 			     const struct i2c_device_id *id)
 {
-	struct m4sensorhub_data *m4sensorhub;
+	struct m4sensorhub_data *m4sensorhub = &m4sensorhub_misc_data;
 	struct device_node *node = client->dev.of_node;
 	int err = -EINVAL;
 
@@ -395,23 +486,14 @@ static int m4sensorhub_probe(struct i2c_client *client,
 		m4sensorhub_debug = M4SH_ERROR;
 #endif
 	}
-	KDEBUG(M4SH_ERROR, "Initializing M4 Sensor Hub: force_upgrade=%d "
-			    "debug=%d\n", force_upgrade, m4sensorhub_debug);
+	KDEBUG(M4SH_ERROR, "Initializing M4 Sensor Hub debug=%d\n",
+			m4sensorhub_debug);
 
 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 		KDEBUG(M4SH_ERROR, "client not i2c capable\n");
 		err = -ENODEV;
 		goto err_unload;
 	}
-	m4sensorhub = kzalloc(sizeof(*m4sensorhub), GFP_KERNEL);
-	if (m4sensorhub == NULL) {
-		err = -ENOMEM;
-		KDEBUG(M4SH_ERROR,
-			"failed to allocate memory for module data: %d\n", err);
-		goto err_unload;
-	}
-	m4sensorhub_misc_data = m4sensorhub;
-
 	err = minnow_m4sensorhub_hw_init(m4sensorhub, node);
 	if (err)
 		printk(KERN_ERR "%s: hw_init Failed!", __func__);
@@ -440,33 +522,27 @@ static int m4sensorhub_probe(struct i2c_client *client,
 		goto err_del_debug_file;
 	}
 
-	err = m4sensorhub_load_firmware(m4sensorhub, force_upgrade);
-	if (err < 0) {
-		dev_err(&client->dev, "load firmware file failed: %d\n", err);
-		goto err_del_log_file;
-	}
-
-	err = m4sensorhub_reg_init(m4sensorhub);
-	if (err < 0)
-		goto err_set_bootmode;
-
 	if (m4sensorhub->hwconfig.irq_gpio >= 0)
 		client->irq = gpio_to_irq(m4sensorhub->hwconfig.irq_gpio);
 	else {
 		KDEBUG(M4SH_ERROR, "Error: No IRQ configured\n");
 		err = -ENODEV;
-		goto err_reg_shutdown;
+		goto err_del_log_file;
 	}
 
 	err = m4sensorhub_panic_init(m4sensorhub);
 	if (err < 0)
 		goto err_reg_shutdown;
 
-	err = m4sensorhub_irq_init(m4sensorhub);
-	if (err < 0)
+	err = request_firmware_nowait(THIS_MODULE,
+			FW_ACTION_HOTPLUG, m4sensorhub->filename,
+			&(m4sensorhub->i2c_client->dev),
+			GFP_KERNEL, m4sensorhub,
+			m4sensorhub_initialize);
+	if (err < 0) {
+		KDEBUG(M4SH_ERROR, "request_firmware_nowait failed: %d\n", err);
 		goto err_panic_shutdown;
-
-
+	}
 	KDEBUG(M4SH_NOTICE, "Registered M4 Sensor Hub\n");
 
 	goto done;
@@ -475,8 +551,6 @@ err_panic_shutdown:
 	m4sensorhub_panic_shutdown(m4sensorhub);
 err_reg_shutdown:
 	m4sensorhub_reg_shutdown(m4sensorhub);
-err_set_bootmode:
-	minnow_m4sensorhub_hw_reset(m4sensorhub);
 err_del_log_file:
 	device_remove_file(&client->dev, &dev_attr_log_level);
 err_del_debug_file:
@@ -487,9 +561,7 @@ err_hw_free:
 	m4sensorhub->i2c_client = NULL;
 	i2c_set_clientdata(client, NULL);
 	minnow_m4sensorhub_hw_free(m4sensorhub);
-	kfree(m4sensorhub);
 	m4sensorhub = NULL;
-	m4sensorhub_misc_data = NULL;
 err_unload:
 done:
 	return err;
@@ -510,9 +582,7 @@ static int __exit m4sensorhub_remove(struct i2c_client *client)
 	m4sensorhub->i2c_client = NULL;
 	i2c_set_clientdata(client, NULL);
 	minnow_m4sensorhub_hw_free(m4sensorhub);
-	kfree(m4sensorhub);
 	m4sensorhub = NULL;
-	m4sensorhub_misc_data = NULL;
 
 	return 0;
 }
diff --git a/drivers/mfd/m4sensorhub-irq.c b/drivers/mfd/m4sensorhub-irq.c
index cd0d1fa59d2..a9324898755 100644
--- a/drivers/mfd/m4sensorhub-irq.c
+++ b/drivers/mfd/m4sensorhub-irq.c
@@ -307,6 +307,11 @@ int m4sensorhub_irq_register(struct m4sensorhub_data *m4sensorhub,
 
 	irqdata = m4sensorhub->irqdata;
 
+	if (irqdata == NULL) {
+		KDEBUG(M4SH_ERROR, "irqdata null for caller = %d\n", irq);
+		return -EINVAL;
+	}
+
 	mutex_lock(&irqdata->lock);
 
 	if (irqdata->event_handler[irq].func == NULL) {
@@ -342,7 +347,8 @@ int m4sensorhub_irq_unregister(struct m4sensorhub_data *m4sensorhub,
 	struct m4sensorhub_irqdata *data = m4sensorhub->irqdata;
 	int retval;
 
-	if (irq >= M4SH_IRQ__NUM)
+	if ((irq >= M4SH_IRQ__NUM) || (m4sensorhub == NULL) ||
+			(m4sensorhub->irqdata == NULL))
 		return -EINVAL;
 
 	retval = m4sensorhub_irq_disable(m4sensorhub, irq);
diff --git a/drivers/mfd/m4sensorhub-panic.c b/drivers/mfd/m4sensorhub-panic.c
index aaf35f89886..6ce982b3f0c 100644
--- a/drivers/mfd/m4sensorhub-panic.c
+++ b/drivers/mfd/m4sensorhub-panic.c
@@ -225,7 +225,7 @@ void m4sensorhub_panic_process(struct m4sensorhub_data *m4sensorhub)
 	KDEBUG(M4SH_ERROR, "m4sensorhub_panic: Detected M4 panic, reset M4!\n");
 	m4sensorhub->pdev->hw_reset(m4sensorhub);
 	msleep(100);
-	ret = m4sensorhub_load_firmware(m4sensorhub, 0);
+	ret = m4sensorhub_load_firmware(m4sensorhub, 0, NULL);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "m4sensorhub_panic: "\
 			"Failed to restart M4, ret = %d\n", ret);
diff --git a/drivers/mfd/m4sensorhub-stm32-fw.c b/drivers/mfd/m4sensorhub-stm32-fw.c
index 30fe52ef6ff..811ec70c4b8 100644
--- a/drivers/mfd/m4sensorhub-stm32-fw.c
+++ b/drivers/mfd/m4sensorhub-stm32-fw.c
@@ -106,9 +106,10 @@ int flash_delay[NUM_FLASH_TO_ERASE] = {
 */
 
 int m4sensorhub_load_firmware(struct m4sensorhub_data *m4sensorhub,
-	unsigned short force_upgrade)
+	unsigned short force_upgrade,
+	const struct firmware *fm)
 {
-	const struct firmware *firmware;
+	const struct firmware *firmware = fm;
 	int i = MAX_RETRIES;
 	int ret = 0;
 	int bytes_left, bytes_to_write;
@@ -123,9 +124,12 @@ int m4sensorhub_load_firmware(struct m4sensorhub_data *m4sensorhub,
 		ret = -ENOMEM;
 		goto done;
 	}
+	if (firmware == NULL) {
+		ret = request_firmware(&firmware, m4sensorhub->filename,
+			&m4sensorhub->i2c_client->dev);
+	}
+	KDEBUG(M4SH_INFO, "Firmware = %s\n", m4sensorhub->filename);
 
-	ret = request_firmware(&firmware, m4sensorhub->filename,
-		&m4sensorhub->i2c_client->dev);
 	if (ret < 0) {
 		KDEBUG(M4SH_ERROR, "%s: request_firmware failed for %s\n",
 			__func__,  m4sensorhub->filename);
@@ -224,10 +228,12 @@ int m4sensorhub_load_firmware(struct m4sensorhub_data *m4sensorhub,
 				"Version of firmware on file is 0x%04x\n",
 				fw_version_file);
 			KDEBUG(M4SH_ERROR,
-				"Firmware on device different from file, updating...\n");
+				"Firmware on device different from file,"
+				"updating...\n");
 		}
 	} else {
-		KDEBUG(M4SH_NOTICE, "Version of firmware on file is 0x%04x\n",
+		KDEBUG(M4SH_NOTICE, "Version of firmware on file is 0x%04x, "
+			"updating...\n",
 			fw_version_file);
 	}
 
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 9f72ecb358d..33404218a5e 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -54,7 +54,6 @@ obj-$(CONFIG_INTEL_MEI)		+= mei/
 obj-$(CONFIG_VMWARE_VMCI)	+= vmw_vmci/
 obj-$(CONFIG_LATTICE_ECP3_CONFIG)	+= lattice-ecp3-config.o
 obj-$(CONFIG_SRAM)		+= sram.o
-obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_tmp006.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_bmp180.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_mpu9150.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_pedometer.o
@@ -63,6 +62,5 @@ obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_stillmode.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_download.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_display.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_audio.o
-obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_wrist.o
 obj-$(CONFIG_MFD_M4SENSORHUB)   += m4sensorhub_passive.o
 obj-$(CONFIG_VIB_GPIO)          += vib-gpio.o
diff --git a/drivers/misc/m4sensorhub_audio.c b/drivers/misc/m4sensorhub_audio.c
index 511e2776bf8..7ab475df9aa 100644
--- a/drivers/misc/m4sensorhub_audio.c
+++ b/drivers/misc/m4sensorhub_audio.c
@@ -63,42 +63,7 @@ struct audio_client {
 	int active;	/* Indicates if audio transfer is active */
 };
 
-struct audio_client *audio_data;
-
-static ssize_t audio_get_loglevel(struct device *dev,
-			struct device_attribute *attr, char *buf)
-{
-	unsigned long long loglevel;
-	struct spi_device *spi = to_spi_device(dev);
-	struct audio_client *audio_client_data = spi_get_drvdata(spi);
-
-	m4sensorhub_reg_read(audio_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, AUDIO_MASK_BIT_1);
-	return sprintf(buf, "%llu\n", loglevel);
-}
-static ssize_t audio_set_loglevel(struct device *dev,
-			struct device_attribute *attr,
-			const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned long long mask = 0, newlevel;
-	struct spi_device *spi = to_spi_device(dev);
-	struct audio_client *audio_client_data = spi_get_drvdata(spi);
-
-	if (strict_strtoul(buf, 10, &level) < 0)
-		return -1;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -1;
-	}
-	mask = (1ULL << AUDIO_MASK_BIT_1) | (1ULL << AUDIO_MASK_BIT_2);
-	newlevel = (unsigned long long)level << AUDIO_MASK_BIT_1;
-	return m4sensorhub_reg_write(audio_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&newlevel,
-		(unsigned char *)&mask);
-}
-static DEVICE_ATTR(LogLevel, 0664, audio_get_loglevel, audio_set_loglevel);
+static struct audio_client *audio_data;
 
 static void audio_client_spidma_read(struct audio_client *audio_client_data,
 	int len)
@@ -384,6 +349,19 @@ static const struct file_operations audio_client_fops = {
 	.read = audio_client_read,
 };
 
+static int audio_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+
+	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_MIC_DATA_READY,
+		m4_handle_audio_irq, audio_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
+			M4SH_IRQ_MIC_DATA_READY, ret);
+	}
+	return ret;
+}
+
 static int audio_client_probe(struct spi_device *spi)
 {
 	int ret = -1;
@@ -409,27 +387,16 @@ 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_irq_register(m4sensorhub, M4SH_IRQ_MIC_DATA_READY,
-		m4_handle_audio_irq, audio_client_data);
+	ret = m4sensorhub_register_initcall(audio_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-			M4SH_IRQ_MIC_DATA_READY, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for audio client = %d\n", ret);
 		goto unregister_sound_device;
 	}
 
-	ret = device_create_file(&spi->dev, &dev_attr_LogLevel);
-	if (ret) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-			AUDIO_CLIENT_DRIVER_NAME);
-		goto unregister_irq;
-	}
-
 	KDEBUG(M4SH_ERROR, "Initialized %s driver\n", AUDIO_CLIENT_DRIVER_NAME);
 	return 0;
 
-unregister_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_MIC_DATA_READY);
 unregister_sound_device:
 	unregister_sound_dsp(audio_client_data->dev_dsp);
 free_client_data:
@@ -442,11 +409,11 @@ static int __exit audio_client_remove(struct spi_device *spi)
 {
 	struct audio_client *audio_client_data = spi_get_drvdata(spi);
 
-	device_remove_file(&spi->dev, &dev_attr_LogLevel);
 	m4sensorhub_irq_disable(audio_client_data->m4sensorhub,
 		M4SH_IRQ_MIC_DATA_READY);
 	m4sensorhub_irq_unregister(audio_client_data->m4sensorhub,
 		M4SH_IRQ_MIC_DATA_READY);
+	m4sensorhub_unregister_initcall(audio_driver_init);
 	unregister_sound_dsp(audio_client_data->dev_dsp);
 	spi_set_drvdata(spi, NULL);
 	kfree(audio_client_data);
diff --git a/drivers/misc/m4sensorhub_bmp180.c b/drivers/misc/m4sensorhub_bmp180.c
index c64fa377ee0..f247aca61f3 100644
--- a/drivers/misc/m4sensorhub_bmp180.c
+++ b/drivers/misc/m4sensorhub_bmp180.c
@@ -223,44 +223,8 @@ static ssize_t altitude_show(struct device *dev,
 	return sprintf(buf, "%d\n", pressure_client_data->altitude);
 }
 
-static ssize_t bmp_get_loglevel(struct device *dev,
-			struct device_attribute *attr, char *buf)
-{
-	unsigned long long loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pressure_client *pressure_client_data
-				= platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(pressure_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, BMP_MASK_BIT_1);
-	return sprintf(buf, "%llu\n", loglevel);
-}
-static ssize_t bmp_set_loglevel(struct device *dev,
-			struct device_attribute *attr,
-			const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned long long mask = 0, newlevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pressure_client *pressure_client_data
-				 = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -1;
-	}
-	mask = (1ULL << BMP_MASK_BIT_1) | (1ULL << BMP_MASK_BIT_2);
-	newlevel = ((unsigned long long)level << BMP_MASK_BIT_1);
-	return m4sensorhub_reg_write(pressure_client_data->m4sensorhub,
-	M4SH_REG_LOG_LOGENABLE, (char *)&newlevel, (unsigned char *)&mask);
-}
-
 static DEVICE_ATTR(pressure, 0444, pressure_show, NULL);
 static DEVICE_ATTR(altitude, 0444, altitude_show, NULL);
-static DEVICE_ATTR(LogLevel, 0664, bmp_get_loglevel, bmp_set_loglevel);
 
 static const struct file_operations pressure_client_fops = {
 	.owner = THIS_MODULE,
@@ -275,6 +239,20 @@ static struct miscdevice pressure_client_miscdrv = {
 	.fops = &pressure_client_fops,
 };
 
+
+static int pressure_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+	ret = m4sensorhub_irq_register(m4sensorhub,
+					M4SH_IRQ_PRESSURE_DATA_READY,
+					m4_handle_pressure_irq,
+					misc_pressure_data);
+	if (ret < 0)
+		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
+			M4SH_IRQ_PRESSURE_DATA_READY, ret);
+	return ret;
+}
+
 static int pressure_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -321,19 +299,17 @@ static int pressure_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_pressure_data = pressure_client_data;
-	ret = m4sensorhub_irq_register(m4sensorhub,
-			M4SH_IRQ_PRESSURE_DATA_READY, m4_handle_pressure_irq,
-			pressure_client_data);
+	ret = m4sensorhub_register_initcall(pressure_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-				M4SH_IRQ_PRESSURE_DATA_READY, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for pressure client = %d\n", ret);
 		goto unregister_misc_device;
 	}
 	if (device_create_file(&pdev->dev, &dev_attr_pressure)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
 				PRESSURE_CLIENT_DRIVER_NAME);
 		ret = -1;
-		goto unregister_irq;
+		goto unregister_initcall;
 	}
 
 	if (device_create_file(&pdev->dev, &dev_attr_altitude)) {
@@ -342,21 +318,13 @@ static int pressure_client_probe(struct platform_device *pdev)
 		ret = -1;
 		goto remove_device_file;
 	}
-	if (device_create_file(&pdev->dev, &dev_attr_LogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				PRESSURE_CLIENT_DRIVER_NAME);
-		ret = -1;
-		goto remove_alt_device_file;
-	}
 	KDEBUG(M4SH_ERROR, "Initialized %s driver\n", __func__);
 	return 0;
 
-remove_alt_device_file:
-	device_remove_file(&pdev->dev, &dev_attr_altitude);
 remove_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_pressure);
-unregister_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_PRESSURE_DATA_READY);
+unregister_initcall:
+	m4sensorhub_unregister_initcall(pressure_driver_init);
 unregister_misc_device:
 	misc_pressure_data = NULL;
 	misc_deregister(&pressure_client_miscdrv);
@@ -375,13 +343,13 @@ static int __exit pressure_client_remove(struct platform_device *pdev)
 	struct pressure_client *pressure_client_data =
 					platform_get_drvdata(pdev);
 
-	device_remove_file(&pdev->dev, &dev_attr_LogLevel);
 	device_remove_file(&pdev->dev, &dev_attr_pressure);
 	device_remove_file(&pdev->dev, &dev_attr_altitude);
 	m4sensorhub_irq_disable(pressure_client_data->m4sensorhub,
 					M4SH_IRQ_PRESSURE_DATA_READY);
 	m4sensorhub_irq_unregister(pressure_client_data->m4sensorhub,
 					M4SH_IRQ_PRESSURE_DATA_READY);
+	m4sensorhub_unregister_initcall(pressure_driver_init);
 	misc_pressure_data = NULL;
 	misc_deregister(&pressure_client_miscdrv);
 	input_unregister_device(pressure_client_data->input_dev);
diff --git a/drivers/misc/m4sensorhub_display.c b/drivers/misc/m4sensorhub_display.c
index 2bc96643d89..a5b81d3375a 100644
--- a/drivers/misc/m4sensorhub_display.c
+++ b/drivers/misc/m4sensorhub_display.c
@@ -353,45 +353,6 @@ int m4sensorhub_set_display_control(int m4_ctrl, int gpio_mipi_mux)
 }
 EXPORT_SYMBOL_GPL(m4sensorhub_set_display_control);
 
-static ssize_t display_get_loglevel(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	uint64_t loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct display_client *display_data =
-		platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(display_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, DISPLAY_MASK_BIT_1);
-	return sprintf(buf, "%d\n", (int)loglevel);
-}
-
-static ssize_t display_set_loglevel(struct device *dev,
-	struct device_attribute *attr,
-	const char *buf, size_t size)
-{
-	uint64_t level = 0;
-	uint64_t mask = 0x3;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct display_client *display_data =
-		platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, (unsigned long *)&level)) < 0)
-		return -EINVAL;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -EINVAL;
-	}
-	mask <<= DISPLAY_MASK_BIT_1;
-	level <<= DISPLAY_MASK_BIT_1;
-	return m4sensorhub_reg_write(display_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&level, (unsigned char *)&mask);
-}
-
-static DEVICE_ATTR(LogLevel, 0664, \
-		display_get_loglevel, display_set_loglevel);
-
 static const struct file_operations display_client_fops = {
 	.owner = THIS_MODULE,
 	.unlocked_ioctl = display_client_ioctl,
@@ -430,6 +391,18 @@ static void display_panic_restore(\
 	}
 }
 
+static int display_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int err;
+
+	err = m4sensorhub_panic_register(m4sensorhub, PANICHDL_DISPLAY_RESTORE,
+		display_panic_restore, global_display_data);
+	if (err < 0)
+		KDEBUG(M4SH_ERROR, "Display driver init failed\n");
+
+	return err;
+}
+
 static int display_client_probe(struct platform_device *pdev)
 {
 	int ret = -EINVAL;
@@ -468,13 +441,6 @@ static int display_client_probe(struct platform_device *pdev)
 		goto disable_regulator;
 	}
 
-	if (device_create_file(&pdev->dev, &dev_attr_LogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				DISPLAY_CLIENT_DRIVER_NAME);
-		ret = -EFAULT;
-		goto unregister_misc_device;
-	}
-
 	/* default to host control */
 	display_data->m4_control = 0;
 	display_data->m4_enable = 0;
@@ -482,9 +448,12 @@ static int display_client_probe(struct platform_device *pdev)
 	mutex_init(&(display_data->m4_mutex));
 
 	global_display_data = display_data;
-
-	m4sensorhub_panic_register(m4sensorhub, PANICHDL_DISPLAY_RESTORE,\
-					display_panic_restore, display_data);
+	ret = m4sensorhub_register_initcall(display_driver_init);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for display client = %d\n", ret);
+		goto unregister_misc_device;
+	}
 
 	KDEBUG(M4SH_INFO, "Initialized %s driver\n", __func__);
 	return 0;
@@ -506,7 +475,7 @@ static int __exit display_client_remove(struct platform_device *pdev)
 						platform_get_drvdata(pdev);
 
 	display_data->m4sensorhub->pdev->set_display_control = NULL;
-	device_remove_file(&pdev->dev, &dev_attr_LogLevel);
+	m4sensorhub_unregister_initcall(display_driver_init);
 	misc_deregister(&display_client_miscdrv);
 	global_display_data = NULL;
 	regulator_put(display_data->regulator);
diff --git a/drivers/misc/m4sensorhub_download.c b/drivers/misc/m4sensorhub_download.c
index 7ad1aae47b5..a671a393f88 100644
--- a/drivers/misc/m4sensorhub_download.c
+++ b/drivers/misc/m4sensorhub_download.c
@@ -56,7 +56,7 @@ struct download_client {
 	struct m4sensorhub_data *m4sensorhub;
 };
 
-struct download_client *misc_download_data;
+static struct download_client *misc_download_data;
 static wait_queue_head_t download_wq;
 static atomic_t m4_dlcmd_resp_ready;
 static atomic_t download_client_entry;
@@ -298,45 +298,6 @@ static long download_client_ioctl(
 	return ret;
 }
 
-static ssize_t download_get_loglevel(struct device *dev,
-	struct device_attribute *attr, char *buf)
-{
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct download_client *download_client_data =
-		platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(download_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, DOWNLOAD_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
-
-static ssize_t download_set_loglevel(struct device *dev,
-	struct device_attribute *attr,
-	const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned int mask = 0;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct download_client *download_client_data =
-		platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -EINVAL;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -EINVAL;
-	}
-	mask = (1 << DOWNLOAD_MASK_BIT_1) | (1 << DOWNLOAD_MASK_BIT_2);
-	level = (level << DOWNLOAD_MASK_BIT_1);
-	return m4sensorhub_reg_write(download_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&level, (unsigned char *)&mask);
-}
-
-static DEVICE_ATTR(LogLevel, 0664, \
-		download_get_loglevel, download_set_loglevel);
-
 static const struct file_operations download_client_fops = {
 	.owner = THIS_MODULE,
 	.unlocked_ioctl = download_client_ioctl,
@@ -350,6 +311,29 @@ static struct miscdevice download_client_miscdrv = {
 	.fops = &download_client_fops,
 };
 
+static int download_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY,
+					m4_handle_download_irq,
+					misc_download_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
+			M4SH_IRQ_DLCMD_RESP_READY, ret);
+		return ret;
+	}
+	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enable irq %d (%d)\n",
+			M4SH_IRQ_DLCMD_RESP_READY, ret);
+		goto exit;
+	}
+	return ret;
+exit:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY);
+	return ret;
+}
+
 static int download_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -376,29 +360,12 @@ static int download_client_probe(struct platform_device *pdev)
 		goto free_memory;
 	}
 	misc_download_data = download_client_data;
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY,
-					m4_handle_download_irq,
-					download_client_data);
+	ret = m4sensorhub_register_initcall(download_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-				M4SH_IRQ_DLCMD_RESP_READY, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for download client = %d\n", ret);
 		goto unregister_misc_device;
 	}
-
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enable irq %d (%d)\n",
-				M4SH_IRQ_DLCMD_RESP_READY, ret);
-		goto unregister_irq;
-	}
-
-	if (device_create_file(&pdev->dev, &dev_attr_LogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				DOWNLOAD_CLIENT_DRIVER_NAME);
-		ret = -1;
-		goto disable_irq;
-	}
-
 	init_waitqueue_head(&download_wq);
 	atomic_set(&m4_dlcmd_resp_ready, false);
 	atomic_set(&download_client_entry, 0);
@@ -407,10 +374,6 @@ static int download_client_probe(struct platform_device *pdev)
 		DOWNLOAD_CLIENT_DRIVER_NAME);
 	return 0;
 
-disable_irq:
-	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY);
-unregister_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_DLCMD_RESP_READY);
 unregister_misc_device:
 	misc_download_data = NULL;
 	misc_deregister(&download_client_miscdrv);
@@ -427,11 +390,11 @@ static int __exit download_client_remove(struct platform_device *pdev)
 	struct download_client *download_client_data =
 		platform_get_drvdata(pdev);
 
-	device_remove_file(&pdev->dev, &dev_attr_LogLevel);
 	m4sensorhub_irq_disable(download_client_data->m4sensorhub,
 				M4SH_IRQ_DLCMD_RESP_READY);
 	m4sensorhub_irq_unregister(download_client_data->m4sensorhub,
 				M4SH_IRQ_DLCMD_RESP_READY);
+	m4sensorhub_unregister_initcall(download_driver_init);
 	misc_download_data = NULL;
 	misc_deregister(&download_client_miscdrv);
 	platform_set_drvdata(pdev, NULL);
diff --git a/drivers/misc/m4sensorhub_gesture.c b/drivers/misc/m4sensorhub_gesture.c
index b067be71d24..ed145f04478 100644
--- a/drivers/misc/m4sensorhub_gesture.c
+++ b/drivers/misc/m4sensorhub_gesture.c
@@ -245,6 +245,30 @@ static struct miscdevice gesture_client_miscdrv = {
 	.fops = &gesture_client_fops,
 };
 
+static int gesture_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret = 0;
+	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED,
+					m4_handle_gesture_irq,
+					misc_gesture_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
+			M4SH_IRQ_GESTURE_DETECTED, ret);
+		return ret;
+	}
+	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enabling int %d (%d)\n",
+			M4SH_IRQ_GESTURE_DETECTED, ret);
+		goto exit;
+	}
+	return ret;
+
+exit:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED);
+	return ret;
+}
+
 static int gesture_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -256,8 +280,11 @@ static int gesture_client_probe(struct platform_device *pdev)
 
 	gesture_client_data = kzalloc(sizeof(*gesture_client_data),
 						GFP_KERNEL);
-	if (!gesture_client_data)
+	if (!gesture_client_data) {
+		KDEBUG(M4SH_ERROR, "%s failed: unable to allocate"
+				"for client_data\n", __func__);
 		return -ENOMEM;
+	}
 
 	gesture_client_data->m4sensorhub = m4sensorhub;
 	platform_set_drvdata(pdev, gesture_client_data);
@@ -298,32 +325,22 @@ static int gesture_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_gesture_data = gesture_client_data;
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED,
-				       m4_handle_gesture_irq,
-				       gesture_client_data);
+	ret = m4sensorhub_register_initcall(gesture_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-		M4SH_IRQ_GESTURE_DETECTED, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function"
+			"for gesture client = %d\n", ret);
 		goto unregister_misc_device;
 	}
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enabling int %d (%d)\n",
-		M4SH_IRQ_GESTURE_DETECTED, ret);
-		goto unregister_display_gesture_irq;
-	}
 	if (device_create_file(&pdev->dev, &dev_attr_gesture_status)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
 		ret = -1;
-		goto disable_display_gesture_irq;
+		goto unregister_initcall;
 	}
 	KDEBUG(M4SH_INFO, "Initialized %s driver\n", __func__);
 	return 0;
 
-disable_display_gesture_irq:
-	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED);
-unregister_display_gesture_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_GESTURE_DETECTED);
+unregister_initcall:
+	m4sensorhub_unregister_initcall(gesture_driver_init);
 unregister_misc_device:
 	misc_gesture_data = NULL;
 	misc_deregister(&gesture_client_miscdrv);
@@ -347,6 +364,7 @@ static int __exit gesture_client_remove(struct platform_device *pdev)
 				M4SH_IRQ_GESTURE_DETECTED);
 	m4sensorhub_irq_unregister(gesture_client_data->m4sensorhub,
 				M4SH_IRQ_GESTURE_DETECTED);
+	m4sensorhub_unregister_initcall(gesture_driver_init);
 	misc_gesture_data = NULL;
 	misc_deregister(&gesture_client_miscdrv);
 	input_unregister_device(gesture_client_data->input_dev);
diff --git a/drivers/misc/m4sensorhub_mpu9150.c b/drivers/misc/m4sensorhub_mpu9150.c
index 55195f4d955..179f2d03ccb 100644
--- a/drivers/misc/m4sensorhub_mpu9150.c
+++ b/drivers/misc/m4sensorhub_mpu9150.c
@@ -467,7 +467,7 @@ static ssize_t m4_mpu9150_local_x(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : x_local = %d\n",
 			__func__, mpu9150_client_data->accel_local_data.lx);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_local_data.lx);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_local_data.lx);
 }
 
 static ssize_t m4_mpu9150_local_y(struct device *dev,
@@ -478,7 +478,7 @@ static ssize_t m4_mpu9150_local_y(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : y_local = %d\n",
 			__func__, mpu9150_client_data->accel_local_data.ly);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_local_data.ly);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_local_data.ly);
 }
 
 static ssize_t m4_mpu9150_local_z(struct device *dev,
@@ -489,7 +489,7 @@ static ssize_t m4_mpu9150_local_z(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : z_local = %d\n",
 			__func__, mpu9150_client_data->accel_local_data.lz);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_local_data.lz);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_local_data.lz);
 }
 static ssize_t m4_mpu9150_world_x(struct device *dev,
 				struct device_attribute *attr, char *buf)
@@ -499,7 +499,7 @@ static ssize_t m4_mpu9150_world_x(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : x_world = %d\n",
 			__func__, mpu9150_client_data->accel_world_data.wx);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_world_data.wx);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_world_data.wx);
 }
 
 static ssize_t m4_mpu9150_world_y(struct device *dev,
@@ -510,7 +510,7 @@ static ssize_t m4_mpu9150_world_y(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : y_world = %d\n",
 			__func__, mpu9150_client_data->accel_world_data.wy);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_world_data.wy);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_world_data.wy);
 }
 
 static ssize_t m4_mpu9150_world_z(struct device *dev,
@@ -521,7 +521,7 @@ static ssize_t m4_mpu9150_world_z(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : z_world = %d\n",
 			__func__, mpu9150_client_data->accel_world_data.wz);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_world_data.wz);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_world_data.wz);
 }
 static ssize_t m4_mpu9150_pitch(struct device *dev,
 				struct device_attribute *attr, char *buf)
@@ -531,7 +531,7 @@ static ssize_t m4_mpu9150_pitch(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : pitch = %d\n",
 			__func__, mpu9150_client_data->euler_data.pitch);
-	return sprintf(buf, "%d \n", mpu9150_client_data->euler_data.pitch);
+	return sprintf(buf, "%d\n", mpu9150_client_data->euler_data.pitch);
 }
 
 static ssize_t m4_mpu9150_roll(struct device *dev,
@@ -542,7 +542,7 @@ static ssize_t m4_mpu9150_roll(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : roll = %d\n",
 			__func__, mpu9150_client_data->euler_data.roll);
-	return sprintf(buf, "%d \n", mpu9150_client_data->euler_data.roll);
+	return sprintf(buf, "%d\n", mpu9150_client_data->euler_data.roll);
 }
 
 static ssize_t m4_mpu9150_yaw(struct device *dev,
@@ -553,7 +553,7 @@ static ssize_t m4_mpu9150_yaw(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : yaw = %d\n",
 			__func__, mpu9150_client_data->euler_data.yaw);
-	return sprintf(buf, "%d \n", mpu9150_client_data->euler_data.yaw);
+	return sprintf(buf, "%d\n", mpu9150_client_data->euler_data.yaw);
 }
 
 static ssize_t m4_mpu9150_heading(struct device *dev,
@@ -564,7 +564,7 @@ static ssize_t m4_mpu9150_heading(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : heading = %d\n",
 			__func__, mpu9150_client_data->heading_data.heading);
-	return sprintf(buf, "%d \n", mpu9150_client_data->heading_data.heading);
+	return sprintf(buf, "%d\n", mpu9150_client_data->heading_data.heading);
 }
 
 static ssize_t m4_mpu9150_heading_acc(struct device *dev,
@@ -586,7 +586,7 @@ static ssize_t m4_mpu9150_x(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : raw x = %d\n",
 			__func__, mpu9150_client_data->accel_data.x);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_data.x);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.x);
 }
 
 static ssize_t m4_mpu9150_y(struct device *dev,
@@ -597,7 +597,7 @@ static ssize_t m4_mpu9150_y(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : raw y = %d\n",
 			__func__, mpu9150_client_data->accel_data.y);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_data.y);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.y);
 }
 
 static ssize_t m4_mpu9150_z(struct device *dev,
@@ -608,7 +608,7 @@ static ssize_t m4_mpu9150_z(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : raw z = %d\n",
 			__func__, mpu9150_client_data->accel_data.z);
-	return sprintf(buf, "%d \n", mpu9150_client_data->accel_data.z);
+	return sprintf(buf, "%d\n", mpu9150_client_data->accel_data.z);
 }
 
 static ssize_t m4_mpu9150_cx(struct device *dev,
@@ -619,7 +619,7 @@ static ssize_t m4_mpu9150_cx(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : compass cx = %d\n",
 			__func__, mpu9150_client_data->compass_data.cx);
-	return sprintf(buf, "%d \n", mpu9150_client_data->compass_data.cx);
+	return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cx);
 }
 
 static ssize_t m4_mpu9150_cy(struct device *dev,
@@ -630,7 +630,7 @@ static ssize_t m4_mpu9150_cy(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : compass cy = %d\n",
 			__func__, mpu9150_client_data->compass_data.cy);
-	return sprintf(buf, "%d \n", mpu9150_client_data->compass_data.cy);
+	return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cy);
 }
 
 static ssize_t m4_mpu9150_cz(struct device *dev,
@@ -641,7 +641,7 @@ static ssize_t m4_mpu9150_cz(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : compass cz = %d\n",
 			__func__, mpu9150_client_data->compass_data.cz);
-	return sprintf(buf, "%d \n", mpu9150_client_data->compass_data.cz);
+	return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.cz);
 }
 
 static ssize_t m4_mpu9150_ca(struct device *dev,
@@ -652,7 +652,7 @@ static ssize_t m4_mpu9150_ca(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : compass ca = %d\n",
 			__func__, mpu9150_client_data->compass_data.ca);
-	return sprintf(buf, "%d \n", mpu9150_client_data->compass_data.ca);
+	return sprintf(buf, "%d\n", mpu9150_client_data->compass_data.ca);
 }
 
 static ssize_t m4_mpu9150_rx(struct device *dev,
@@ -663,7 +663,7 @@ static ssize_t m4_mpu9150_rx(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : rx = %d\n",
 			__func__, mpu9150_client_data->gyro_data.rx);
-	return sprintf(buf, "%d \n", mpu9150_client_data->gyro_data.rx);
+	return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.rx);
 }
 static ssize_t m4_mpu9150_ry(struct device *dev,
 				struct device_attribute *attr, char *buf)
@@ -673,7 +673,7 @@ static ssize_t m4_mpu9150_ry(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : ry = %d\n",
 			__func__, mpu9150_client_data->gyro_data.ry);
-	return sprintf(buf, "%d \n", mpu9150_client_data->gyro_data.ry);
+	return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.ry);
 }
 
 static ssize_t m4_mpu9150_rz(struct device *dev,
@@ -684,143 +684,9 @@ static ssize_t m4_mpu9150_rz(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : rz = %d\n",
 			__func__, mpu9150_client_data->gyro_data.rz);
-	return sprintf(buf, "%d \n", mpu9150_client_data->gyro_data.rz);
+	return sprintf(buf, "%d\n", mpu9150_client_data->gyro_data.rz);
 }
 
-static int mpu9150_set_loglevel(struct mpu9150_client *mpu9150_client_data,
-	unsigned long long level, enum mpu9150_sensor type)
-{
-	unsigned long long mask;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %llu !!!\n", level);
-		return -1;
-	}
-	switch (type) {
-	case TYPE_GYRO:
-	mask = (1ULL << GYRO_MASK_BIT_1) | (1ULL << GYRO_MASK_BIT_2);
-	level = (level << GYRO_MASK_BIT_1);
-	break;
-	case TYPE_ACCEL:
-	mask = (1ULL << ACCEL_MASK_BIT_1) | (1ULL << ACCEL_MASK_BIT_2);
-	level = (level << ACCEL_MASK_BIT_1);
-	break;
-	case TYPE_COMPASS:
-	mask = (1ULL << COMPASS_MASK_BIT_1) | (1ULL << COMPASS_MASK_BIT_2);
-	level = (level << COMPASS_MASK_BIT_1);
-	break;
-	case TYPE_FUSION:
-	mask = (1ULL << FUSION_MASK_BIT_1) | (1ULL << FUSION_MASK_BIT_2);
-	level = (level << FUSION_MASK_BIT_1);
-	break;
-	default:
-		return -1;
-	}
-	return m4sensorhub_reg_write(mpu9150_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&level, (unsigned char *)&mask);
-}
-
-static ssize_t gyro_set_loglevel(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t size)
-{
-	unsigned long level;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	return mpu9150_set_loglevel(mpu9150_client_data, level, TYPE_GYRO);
-}
-
-static ssize_t gyro_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	unsigned long long loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, GYRO_MASK_BIT_1);
-	return sprintf(buf, "%llu\n", loglevel);
-}
-
-static ssize_t accel_set_loglevel(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t size)
-{
-	unsigned long level;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	return mpu9150_set_loglevel(mpu9150_client_data, level, TYPE_ACCEL);
-}
-
-static ssize_t accel_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, ACCEL_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
-
-static ssize_t compass_set_loglevel(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t size)
-{
-	unsigned long level;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	return mpu9150_set_loglevel(mpu9150_client_data, level, TYPE_COMPASS);
-}
-
-static ssize_t compass_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, COMPASS_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
-
-static ssize_t fusion_set_loglevel(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t size)
-{
-	unsigned long level;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	return mpu9150_set_loglevel(mpu9150_client_data, level, TYPE_FUSION);
-}
-static ssize_t fusion_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct mpu9150_client *mpu9150_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(mpu9150_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, FUSION_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
 
 static DEVICE_ATTR(x_local, 0444, m4_mpu9150_local_x, NULL);
 static DEVICE_ATTR(y_local, 0444, m4_mpu9150_local_y, NULL);
@@ -843,14 +709,6 @@ static DEVICE_ATTR(compass_ca, 0444, m4_mpu9150_ca, NULL);
 static DEVICE_ATTR(rx, 0444, m4_mpu9150_rx, NULL);
 static DEVICE_ATTR(ry, 0444, m4_mpu9150_ry, NULL);
 static DEVICE_ATTR(rz, 0444, m4_mpu9150_rz, NULL);
-static DEVICE_ATTR(gyroLogLevel, 0644, gyro_get_loglevel,
-				gyro_set_loglevel);
-static DEVICE_ATTR(accelLogLevel, 0644, accel_get_loglevel,
-				accel_set_loglevel);
-static DEVICE_ATTR(compassLogLevel, 0644, compass_get_loglevel,
-				compass_set_loglevel);
-static DEVICE_ATTR(fusionLogLevel, 0644, fusion_get_loglevel,
-				fusion_set_loglevel);
 
 static struct attribute *mpu9150_attributes[] = {
 	&dev_attr_x_local.attr,
@@ -874,10 +732,6 @@ static struct attribute *mpu9150_attributes[] = {
 	&dev_attr_rx.attr,
 	&dev_attr_ry.attr,
 	&dev_attr_rz.attr,
-	&dev_attr_gyroLogLevel.attr,
-	&dev_attr_accelLogLevel.attr,
-	&dev_attr_compassLogLevel.attr,
-	&dev_attr_fusionLogLevel.attr,
 	NULL
 };
 
@@ -1051,6 +905,16 @@ static int mpu9150_irq_enable_disable(struct mpu9150_client *mpu9150_client_data
 	return ret;
 }
 
+static int mpu9150_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+	ret = mpu9150_irq_init(misc_mpu9150_data);
+
+	if (ret < 0)
+		KDEBUG(M4SH_ERROR, "mpu9150 irq init failed\n");
+	return ret;
+}
+
 static int mpu9150_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -1122,21 +986,24 @@ static int mpu9150_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_mpu9150_data = mpu9150_client_data;
-	ret = mpu9150_irq_init(mpu9150_client_data);
-	if (ret < 0)
+	ret = m4sensorhub_register_initcall(mpu9150_driver_init);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Unable to register init function"
+			"for mpu9150 client = %d\n", ret);
 		goto unregister_misc_device;
+	}
 
 #ifdef MPU9150_DEBUG
 	ret = sysfs_create_group(&pdev->dev.kobj, &mpu9150_group);
 	if (ret)
-		goto unregister_irq;
+		goto unregister_initcall;
 #endif
 	KDEBUG(M4SH_INFO, "Initialized %s driver\n", __func__);
 	return 0;
 
 #ifdef MPU9150_DEBUG
-unregister_irq:
-	mpu9150_irq_deinit(mpu9150_client_data);
+unregister_initcall:
+	m4sensorhub_unregister_initcall(mpu9150_driver_init);
 #endif
 unregister_misc_device:
 	misc_mpu9150_data = NULL;
@@ -1159,6 +1026,7 @@ static int __exit mpu9150_client_remove(struct platform_device *pdev)
 	sysfs_remove_group(&pdev->dev.kobj, &mpu9150_group);
 #endif
 	mpu9150_irq_deinit(mpu9150_client_data);
+	m4sensorhub_unregister_initcall(mpu9150_driver_init);
 	misc_mpu9150_data = NULL;
 	misc_deregister(&mpu9150_client_miscdrv);
 	input_unregister_device(mpu9150_client_data->input_dev);
diff --git a/drivers/misc/m4sensorhub_passive.c b/drivers/misc/m4sensorhub_passive.c
index 86c58fcc7e2..b875afbd80c 100644
--- a/drivers/misc/m4sensorhub_passive.c
+++ b/drivers/misc/m4sensorhub_passive.c
@@ -168,6 +168,32 @@ static struct miscdevice passive_client_miscdrv = {
 	.fops = &passive_client_fops,
 };
 
+static int passive_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+	ret = m4sensorhub_irq_register(m4sensorhub,
+					M4SH_IRQ_PASSIVE_BUFFER_FULL,
+					m4_handle_passive_irq,
+					misc_passive_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
+		M4SH_IRQ_PASSIVE_BUFFER_FULL, ret);
+		return ret;
+	}
+	ret = m4sensorhub_irq_enable(m4sensorhub,
+					M4SH_IRQ_PASSIVE_BUFFER_FULL);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enabling int %d (%d)\n",
+			M4SH_IRQ_PASSIVE_BUFFER_FULL, ret);
+		goto exit;
+	}
+
+	return ret;
+exit:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_PASSIVE_BUFFER_FULL);
+	return ret;
+}
+
 static int passive_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -213,27 +239,15 @@ static int passive_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_passive_data = passive_client_data;
-
-	ret = m4sensorhub_irq_register(m4sensorhub,
-				M4SH_IRQ_PASSIVE_BUFFER_FULL,
-				m4_handle_passive_irq,
-				passive_client_data);
+	ret = m4sensorhub_register_initcall(passive_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-					M4SH_IRQ_PASSIVE_BUFFER_FULL, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function"
+			"for passive client = %d\n", ret);
 		goto unregister_misc_device;
 	}
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_PASSIVE_BUFFER_FULL);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enabling int %d (%d)\n",
-					M4SH_IRQ_PASSIVE_BUFFER_FULL, ret);
-		goto unregister_irq;
-	}
 	KDEBUG(M4SH_INFO, "Initialized %s driver\n", __func__);
 	return 0;
 
-unregister_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_PASSIVE_BUFFER_FULL);
 unregister_misc_device:
 	misc_passive_data = NULL;
 	misc_deregister(&passive_client_miscdrv);
@@ -256,6 +270,7 @@ static int __exit passive_client_remove(struct platform_device *pdev)
 				M4SH_IRQ_PASSIVE_BUFFER_FULL);
 	m4sensorhub_irq_unregister(passive_client_data->m4sensorhub,
 				M4SH_IRQ_PASSIVE_BUFFER_FULL);
+	m4sensorhub_unregister_initcall(passive_driver_init);
 
 	misc_passive_data = NULL;
 	misc_deregister(&passive_client_miscdrv);
diff --git a/drivers/misc/m4sensorhub_pedometer.c b/drivers/misc/m4sensorhub_pedometer.c
index 9a6707fba0c..7b17c022fc0 100644
--- a/drivers/misc/m4sensorhub_pedometer.c
+++ b/drivers/misc/m4sensorhub_pedometer.c
@@ -321,7 +321,7 @@ static ssize_t m4_pedometer_floorsclimbed(struct device *dev,
 	m4_read_pedometer_data(pedo_client_data);
 	KDEBUG(M4SH_DEBUG, "%s  : floorsclimbed = %d\n",
 			__func__, pedo_client_data->curr_data.floorsclimbed);
-	return sprintf(buf, "%d \n", pedo_client_data->curr_data.floorsclimbed);
+	return sprintf(buf, "%d\n", pedo_client_data->curr_data.floorsclimbed);
 }
 
 static ssize_t m4_pedometer_metsactivity(struct device *dev,
@@ -332,76 +332,7 @@ static ssize_t m4_pedometer_metsactivity(struct device *dev,
 
 	KDEBUG(M4SH_DEBUG, "%s  : metsactivity = %d\n",
 			__func__, pedo_client_data->curr_data.metsactivity);
-	return sprintf(buf, "%d \n", pedo_client_data->curr_data.metsactivity);
-}
-
-static ssize_t pedo_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pedometer_client *pedo_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(pedo_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, PEDO_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
-
-static ssize_t pedo_set_loglevel(struct device *dev,
-				struct device_attribute *attr,
-				const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned int mask = 0;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pedometer_client *pedo_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -1;
-	}
-	mask = (1 << PEDO_MASK_BIT_1) | (1 << PEDO_MASK_BIT_2);
-	level = (level << PEDO_MASK_BIT_1);
-	return m4sensorhub_reg_write(pedo_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&level, (unsigned char *)&mask);
-}
-
-static ssize_t mets_get_loglevel(struct device *dev,
-				struct device_attribute *attr, char *buf)
-{
-	int loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pedometer_client *pedo_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(pedo_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, METS_MASK_BIT_1);
-	return sprintf(buf, "%d\n", loglevel);
-}
-
-static ssize_t mets_set_loglevel(struct device *dev,
-			struct device_attribute *attr,
-			const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned int mask = 0;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct pedometer_client *pedo_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -1;
-	}
-	mask = (1 << METS_MASK_BIT_1) | (1 << METS_MASK_BIT_2);
-	level = (level << METS_MASK_BIT_1);
-	return m4sensorhub_reg_write(pedo_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&level, (unsigned char *)&mask);
+	return sprintf(buf, "%d\n", pedo_client_data->curr_data.metsactivity);
 }
 
 static DEVICE_ATTR(activity, 0444, m4_pedometer_activity, NULL);
@@ -412,8 +343,6 @@ static DEVICE_ATTR(mets, 0444, m4_pedometer_mets, NULL);
 static DEVICE_ATTR(calories, 0444, m4_pedometer_calories, NULL);
 static DEVICE_ATTR(floorsclimbed, 0444, m4_pedometer_floorsclimbed, NULL);
 static DEVICE_ATTR(metsactivity, 0444, m4_pedometer_metsactivity, NULL);
-static DEVICE_ATTR(pedoLogLevel, 0664, pedo_get_loglevel, pedo_set_loglevel);
-static DEVICE_ATTR(metsLogLevel, 0644, mets_get_loglevel, mets_set_loglevel);
 
 static const struct file_operations pedometer_client_fops = {
 	.owner = THIS_MODULE,
@@ -428,6 +357,43 @@ static struct miscdevice pedometer_client_miscdrv = {
 	.fops = &pedometer_client_fops,
 };
 
+static int pedometer_driver_init(struct m4sensorhub_data *m4sensorhub)
+{
+	int ret;
+
+	ret = m4sensorhub_irq_register(m4sensorhub,
+					M4SH_IRQ_PEDOMETER_DATA_READY,
+					m4_handle_pedometer_irq,
+					misc_pedometer_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering m4 int %d (%d)\n",
+			M4SH_IRQ_PEDOMETER_DATA_READY, ret);
+		return ret;
+	}
+	ret = m4sensorhub_irq_register(m4sensorhub,
+					M4SH_IRQ_ACTIVITY_CHANGE,
+					m4_handle_pedometer_irq,
+					misc_pedometer_data);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering m4 int %d (%d)\n",
+			M4SH_IRQ_ACTIVITY_CHANGE, ret);
+		goto exit1;
+	}
+	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enabling m4 int %d (%d)\n",
+			M4SH_IRQ_ACTIVITY_CHANGE, ret);
+		goto exit;
+	}
+
+	return ret;
+exit:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE);
+exit1:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_PEDOMETER_DATA_READY);
+	return ret;
+}
+
 static int pedometer_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -483,34 +449,16 @@ static int pedometer_client_probe(struct platform_device *pdev)
 		goto unregister_input_device;
 	}
 	misc_pedometer_data = pedometer_client_data;
-	ret = m4sensorhub_irq_register(m4sensorhub,
-			M4SH_IRQ_PEDOMETER_DATA_READY, m4_handle_pedometer_irq,
-			pedometer_client_data);
+	ret = m4sensorhub_register_initcall(pedometer_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-					M4SH_IRQ_PEDOMETER_DATA_READY, ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for pedometer client = %d\n", ret);
 		goto unregister_misc_device;
 	}
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE,
-						m4_handle_pedometer_irq,
-						pedometer_client_data);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-				M4SH_IRQ_ACTIVITY_CHANGE, ret);
-		goto unregister_pedometer_irq;
-	}
-
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enabling int %d (%d)\n",
-			M4SH_IRQ_ACTIVITY_CHANGE, ret);
-		goto unregister_activity_irq;
-	}
-
 	if (device_create_file(&pdev->dev, &dev_attr_activity)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
 		ret = -1;
-		goto disable_activity_irq;
+		goto unregister_initcall;
 	}
 	if (device_create_file(&pdev->dev, &dev_attr_distance)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
@@ -532,20 +480,10 @@ static int pedometer_client_probe(struct platform_device *pdev)
 		ret = -1;
 		goto remove_stepcount_device_file;
 	}
-	if (device_create_file(&pdev->dev, &dev_attr_pedoLogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
-		ret = -1;
-		goto remove_mets_device_file;
-	}
-	if (device_create_file(&pdev->dev, &dev_attr_metsLogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
-		ret = -1;
-		goto remove_pedoLogLevel_device_file;
-	}
 	if (device_create_file(&pdev->dev, &dev_attr_calories)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
 		ret = -1;
-		goto remove_metsLogLevel_device_file;
+		goto remove_mets_device_file;
 	}
 	if (device_create_file(&pdev->dev, &dev_attr_floorsclimbed)) {
 		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n", __func__);
@@ -564,10 +502,6 @@ remove_floorsclimbed_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_floorsclimbed);
 remove_cals_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_calories);
-remove_metsLogLevel_device_file:
-	device_remove_file(&pdev->dev, &dev_attr_metsLogLevel);
-remove_pedoLogLevel_device_file:
-	device_remove_file(&pdev->dev, &dev_attr_pedoLogLevel);
 remove_mets_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_mets);
 remove_stepcount_device_file:
@@ -578,12 +512,8 @@ remove_distance_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_distance);
 remove_activity_device_file:
 	device_remove_file(&pdev->dev, &dev_attr_activity);
-disable_activity_irq:
-	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE);
-unregister_activity_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_ACTIVITY_CHANGE);
-unregister_pedometer_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_PEDOMETER_DATA_READY);
+unregister_initcall:
+	m4sensorhub_unregister_initcall(pedometer_driver_init);
 unregister_misc_device:
 	misc_pedometer_data = NULL;
 	misc_deregister(&pedometer_client_miscdrv);
@@ -602,8 +532,6 @@ static int __exit pedometer_client_remove(struct platform_device *pdev)
 	struct pedometer_client *pedometer_client_data =
 						platform_get_drvdata(pdev);
 
-	device_remove_file(&pdev->dev, &dev_attr_metsLogLevel);
-	device_remove_file(&pdev->dev, &dev_attr_pedoLogLevel);
 	device_remove_file(&pdev->dev, &dev_attr_mets);
 	device_remove_file(&pdev->dev, &dev_attr_calories);
 	device_remove_file(&pdev->dev, &dev_attr_stepcount);
@@ -619,6 +547,7 @@ static int __exit pedometer_client_remove(struct platform_device *pdev)
 				M4SH_IRQ_ACTIVITY_CHANGE);
 	m4sensorhub_irq_unregister(pedometer_client_data->m4sensorhub,
 				M4SH_IRQ_ACTIVITY_CHANGE);
+	m4sensorhub_unregister_initcall(pedometer_driver_init);
 	misc_pedometer_data = NULL;
 	misc_deregister(&pedometer_client_miscdrv);
 	input_unregister_device(pedometer_client_data->input_dev);
diff --git a/drivers/misc/m4sensorhub_stillmode.c b/drivers/misc/m4sensorhub_stillmode.c
index 3fa61219245..bfd56cc28a7 100644
--- a/drivers/misc/m4sensorhub_stillmode.c
+++ b/drivers/misc/m4sensorhub_stillmode.c
@@ -224,6 +224,57 @@ 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)
+{
+	int ret;
+
+	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_STILL_DETECTED,
+					m4_handle_stillmode_irq,
+					g_stillmode_data);
+
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering still mode IRQ: %d\n",
+		ret);
+		return ret;
+	}
+
+	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enabling still mode int: %d\n",
+			ret);
+		goto unregister_still_irq;
+	}
+
+	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_MOTION_DETECTED,
+					m4_handle_stillmode_irq,
+					g_stillmode_data);
+
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error registering moving mode IRQ: %d\n",
+			ret);
+		goto disable_still_irq;
+	}
+
+	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
+	if (ret < 0) {
+		KDEBUG(M4SH_ERROR, "Error enabling moving mode int: %d\n",
+			ret);
+		goto unregister_moving_irq;
+	}
+
+	/* initialize timer on M4 */
+	m4sensorhub_stillmode_exit();
+	return ret;
+
+unregister_moving_irq:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
+disable_still_irq:
+	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
+unregister_still_irq:
+	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
+	return ret;
+}
+
 static int stillmode_client_probe(struct platform_device *pdev)
 {
 	int ret = -1;
@@ -267,42 +318,19 @@ static int stillmode_client_probe(struct platform_device *pdev)
 		       STILLMODE_CLIENT_DRIVER_NAME);
 
 	INIT_WORK(&stillmode_client_data->queued_work,
-		  m4sensorhub_stillmode_work);
+		m4sensorhub_stillmode_work);
 
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_STILL_DETECTED,
-						m4_handle_stillmode_irq,
-						stillmode_client_data);
+	ret = m4sensorhub_register_initcall(stillmode_driver_init);
 	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering still mode IRQ: "
-			"%d\n", ret);
+		KDEBUG(M4SH_ERROR, "Unable to register init function "
+			"for stillmode client = %d\n", ret);
 		goto destroy_wakelock;
 	}
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enabling still mode int: "
-			"%d\n", ret);
-		goto unregister_still_irq;
-	}
-
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_MOTION_DETECTED,
-						m4_handle_stillmode_irq,
-						stillmode_client_data);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering moving mode IRQ: "
-			"%d\n", ret);
-		goto disable_still_irq;
-	}
-	ret = m4sensorhub_irq_enable(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error enabling moving mode int: "
-			"%d\n", ret);
-		goto unregister_moving_irq;
-	}
 
 	if (device_create_file(&pdev->dev, &dev_attr_state)) {
 		KDEBUG(M4SH_ERROR, "Error creating stillmode sys entry\n");
 		ret = -1;
-		goto disable_moving_irq;
+		goto unregister_initcall;
 	}
 
 	if (device_create_file(&pdev->dev, &dev_attr_timeout)) {
@@ -311,9 +339,6 @@ static int stillmode_client_probe(struct platform_device *pdev)
 		goto remove_stillmode_sysfs;
 	}
 
-	/* initialize timer on M4 */
-	m4sensorhub_stillmode_exit();
-
 	KDEBUG(M4SH_INFO, "Initialized %s driver\n",
 		STILLMODE_CLIENT_DRIVER_NAME);
 
@@ -321,14 +346,8 @@ static int stillmode_client_probe(struct platform_device *pdev)
 
 remove_stillmode_sysfs:
 	device_remove_file(&pdev->dev, &dev_attr_state);
-disable_moving_irq:
-	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
-unregister_moving_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
-disable_still_irq:
-	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
-unregister_still_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
+unregister_initcall:
+	m4sensorhub_unregister_initcall(stillmode_driver_init);
 destroy_wakelock:
 	wake_lock_destroy(&stillmode_client_data->wakelock);
 	input_unregister_device(stillmode_client_data->input_dev);
@@ -355,6 +374,7 @@ static int __exit stillmode_client_remove(struct platform_device *pdev)
 	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_MOTION_DETECTED);
 	m4sensorhub_irq_disable(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
 	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_STILL_DETECTED);
+	m4sensorhub_unregister_initcall(stillmode_driver_init);
 	wake_lock_destroy(&stillmode_client_data->wakelock);
 	input_unregister_device(stillmode_client_data->input_dev);
 	platform_set_drvdata(pdev, NULL);
diff --git a/drivers/misc/m4sensorhub_tmp006.c b/drivers/misc/m4sensorhub_tmp006.c
deleted file mode 100644
index 44cb293f9a4..00000000000
--- a/drivers/misc/m4sensorhub_tmp006.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- *  Copyright (C) 2012 Motorola, Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- *
- *  Adds ability to program periodic interrupts from user space that
- *  can wake the phone out of low power modes.
- *
- */
-
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/miscdevice.h>
-#include <linux/platform_device.h>
-#include <linux/proc_fs.h>
-#include <linux/input.h>
-#include <linux/slab.h>
-#include <linux/uaccess.h>
-#include <linux/m4sensorhub.h>
-#include <linux/m4sensorhub_client_ioctl.h>
-#include <linux/m4sensorhub/MemMapTempSensor.h>
-
-#define TMP_CLIENT_DRIVER_NAME "m4sensorhub_tmp006"
-#define TMP_MAX		1250
-#define TMP_MIN		-400
-
-struct tmp_client {
-	struct m4sensorhub_data *m4sensorhub;
-	struct input_dev *input_dev;
-	int internal_tmp;
-	int external_tmp;
-	signed short samplerate;
-};
-
-struct tmp_client *misc_tmp_data;
-
-static int temperature_client_open(struct inode *inode, struct file *file)
-{
-	int err = 0;
-
-	err = nonseekable_open(inode, file);
-	if (err < 0) {
-		KDEBUG(M4SH_DEBUG, "temperature_clientopen failed\n");
-		return err;
-	}
-	file->private_data = misc_tmp_data;
-
-	return 0;
-}
-
-static int temperature_client_close(struct inode *inode, struct file *file)
-{
-	KDEBUG(M4SH_DEBUG, "temperature_client in %s\n", __func__);
-	return 0;
-}
-
-static void  m4_report_temp_inputevent(struct tmp_client *tmp_data)
-{
-	input_report_abs(tmp_data->input_dev, ABS_THROTTLE,
-		tmp_data->external_tmp);
-	input_sync(tmp_data->input_dev);
-}
-
-static void m4_read_temp_data(struct tmp_client *tmp_data)
-{
-	sTempData tmp;
-
-	m4sensorhub_reg_read(tmp_data->m4sensorhub,
-			M4SH_REG_TEMP_EXTRNLTEMP, (char *)&tmp.extrnlTemp);
-	m4sensorhub_reg_read(tmp_data->m4sensorhub,
-			M4SH_REG_TEMP_INTRNLTEMP, (char *)&tmp.intrnlTemp);
-	tmp_data->internal_tmp = tmp.intrnlTemp;
-	tmp_data->external_tmp = tmp.extrnlTemp;
-}
-
-static void m4_handle_tmp_irq(enum m4sensorhub_irqs int_event,
-					void *tmp_data)
-{
-	struct tmp_client *tmp_client_data = tmp_data;
-
-	m4_read_temp_data(tmp_client_data);
-	m4_report_temp_inputevent(tmp_client_data);
-}
-
-static int m4_set_tmp_samplerate(
-			struct tmp_client *tmp_client_data,
-			signed int samplerate)
-{
-	int ret = 0;
-
-	if (samplerate != tmp_client_data->samplerate) {
-		ret = m4sensorhub_reg_write(tmp_client_data->m4sensorhub,
-				M4SH_REG_TEMP_SAMPLERATE,
-				(char *)&samplerate, m4sh_no_mask);
-		if (ret != m4sensorhub_reg_getsize(
-				tmp_client_data->m4sensorhub,
-				M4SH_REG_TEMP_SAMPLERATE)) {
-				KDEBUG(M4SH_ERROR, "Unable to set delay \
-					for temperature sensor\n");
-				return ret;
-		}
-
-		KDEBUG(M4SH_DEBUG, "%s() updating samplerate from %d to %d\n",
-				   __func__, tmp_client_data->samplerate,
-				   samplerate);
-		tmp_client_data->samplerate = samplerate;
-
-		if (samplerate >= 0)
-			ret = m4sensorhub_irq_enable(
-					tmp_client_data->m4sensorhub,
-					M4SH_IRQ_TMP_DATA_READY);
-		else
-			ret = m4sensorhub_irq_disable(
-					tmp_client_data->m4sensorhub,
-					M4SH_IRQ_TMP_DATA_READY);
-		if (ret != 0)
-			KDEBUG(M4SH_ERROR, "Unable to enable/disable \
-				temperature irq\n");
-	}
-
-	return ret;
-}
-
-
-/*
- * Handle commands from user-space.
- */
-static long temperature_client_ioctl(struct file *filp,
-				 unsigned int cmd, unsigned long arg)
-{
-	int ret = 0;
-	int delay = 0;
-	static int status;
-
-	void __user *argp = (void __user *)arg;
-	struct tmp_client *tmp_data = filp->private_data;
-
-	switch (cmd) {
-	case M4_SENSOR_IOCTL_GET_TEMPRATURE:
-		m4_read_temp_data(tmp_data);
-		m4_report_temp_inputevent(tmp_data);
-		break;
-	case M4_SENSOR_IOCTL_SET_DELAY:
-		if (copy_from_user(&delay, argp, sizeof(delay)))
-			return -EFAULT;
-		if (delay >= 0)
-			ret = m4_set_tmp_samplerate(tmp_data, delay);
-		if (ret < 0) {
-			KDEBUG(M4SH_ERROR, "Error setting samplerate to %d"
-				" (%d)\n", delay, ret);
-			return -EFAULT;
-		}
-		break;
-	case M4_SENSOR_IOCTL_APP_GET_FLAG:
-		if (copy_to_user(argp, &status, sizeof(status)))
-			return -EFAULT;
-		break;
-	case M4_SENSOR_IOCTL_APP_SET_FLAG:
-		if (copy_from_user(&status, argp, sizeof(status)))
-			return -EFAULT;
-		break;
-	default:
-		KDEBUG(M4SH_ERROR, "Invalid IOCTL Command %d\n", cmd);
-		 ret = -EINVAL;
-	}
-	return ret;
-}
-
-static ssize_t GetExternalTemp(struct device *dev,
-			      struct device_attribute *attr, char *buf)
-{
-	struct platform_device *pdev = to_platform_device(dev);
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	m4_read_temp_data(tmp_client_data);
-	KDEBUG(M4SH_DEBUG, "%s  : external temp = %d",
-		__func__, tmp_client_data->external_tmp);
-	return sprintf(buf, "%d\n", tmp_client_data->external_tmp);
-}
-
-static ssize_t GetInternalTemp(struct device *dev,
-			struct device_attribute *attr, char *buf)
-{
-	struct platform_device *pdev = to_platform_device(dev);
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	m4_read_temp_data(tmp_client_data);
-	KDEBUG(M4SH_DEBUG, "%s  : internal temp = %d",
-		__func__, tmp_client_data->internal_tmp);
-	return sprintf(buf, "%d\n", tmp_client_data->internal_tmp);
-}
-
-static ssize_t tmp_get_loglevel(struct device *dev,
-			struct device_attribute *attr, char *buf)
-{
-	unsigned long long loglevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	m4sensorhub_reg_read(tmp_client_data->m4sensorhub,
-		M4SH_REG_LOG_LOGENABLE, (char *)&loglevel);
-	loglevel = get_log_level(loglevel, TMP_MASK_BIT_1);
-	return sprintf(buf, "%llu\n", loglevel);
-}
-
-static ssize_t tmp_set_loglevel(struct device *dev,
-			struct device_attribute *attr,
-			const char *buf, size_t size)
-{
-	unsigned long level;
-	unsigned long long mask = 0, newlevel;
-	struct platform_device *pdev = to_platform_device(dev);
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	if ((strict_strtoul(buf, 10, &level)) < 0)
-		return -1;
-	if (level > M4_MAX_LOG_LEVEL) {
-		KDEBUG(M4SH_ERROR, " Invalid log level - %d\n", (int)level);
-		return -1;
-	}
-	mask = (1ULL << TMP_MASK_BIT_1) | (1ULL << TMP_MASK_BIT_2);
-	newlevel = (level << TMP_MASK_BIT_1);
-	return m4sensorhub_reg_write(tmp_client_data->m4sensorhub,
-	M4SH_REG_LOG_LOGENABLE, (char *)&newlevel, (unsigned char *)&mask);
-}
-
-static DEVICE_ATTR(internal, 0444, GetInternalTemp, NULL);
-static DEVICE_ATTR(external, 0444, GetExternalTemp, NULL);
-static DEVICE_ATTR(LogLevel, 0444, tmp_get_loglevel, tmp_set_loglevel);
-
-static const struct file_operations temperature_client_fops = {
-	.owner = THIS_MODULE,
-	.unlocked_ioctl = temperature_client_ioctl,
-	.open  = temperature_client_open,
-	.release = temperature_client_close,
-};
-
-static struct miscdevice temperature_client_miscdrv = {
-	.minor = MISC_DYNAMIC_MINOR,
-	.name  = TMP_CLIENT_DRIVER_NAME,
-	.fops = &temperature_client_fops,
-};
-
-static int temperature_client_probe(struct platform_device *pdev)
-{
-	int ret = -1;
-	struct tmp_client *tmp_client_data;
-	struct m4sensorhub_data *m4sensorhub = m4sensorhub_client_get_drvdata();
-
-	if (!m4sensorhub)
-		return -EFAULT;
-
-	tmp_client_data = kzalloc(sizeof(*tmp_client_data), GFP_KERNEL);
-	if (!tmp_client_data)
-		return -ENOMEM;
-
-	tmp_client_data->m4sensorhub = m4sensorhub;
-	platform_set_drvdata(pdev, tmp_client_data);
-
-	tmp_client_data->input_dev = input_allocate_device();
-	if (!tmp_client_data->input_dev) {
-		ret = -ENOMEM;
-		KDEBUG(M4SH_ERROR, "%s: input device allocate failed: %d\n",
-		__func__, ret);
-		goto free_memory;
-	}
-
-	tmp_client_data->input_dev->name = TMP_CLIENT_DRIVER_NAME;
-	set_bit(EV_ABS, tmp_client_data->input_dev->evbit);
-	set_bit(ABS_THROTTLE, tmp_client_data->input_dev->absbit);
-	input_set_abs_params(tmp_client_data->input_dev, ABS_THROTTLE,
-				TMP_MIN, TMP_MAX, 0, 0);
-
-	if (input_register_device(tmp_client_data->input_dev)) {
-		KDEBUG(M4SH_INFO, "%s: input device register failed\n",
-			__func__);
-		input_free_device(tmp_client_data->input_dev);
-		goto free_memory;
-	}
-
-	ret = misc_register(&temperature_client_miscdrv);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering %s driver\n",
-				 TMP_CLIENT_DRIVER_NAME);
-		goto unregister_input_device;
-	}
-	misc_tmp_data = tmp_client_data;
-	ret = m4sensorhub_irq_register(m4sensorhub, M4SH_IRQ_TMP_DATA_READY,
-					m4_handle_tmp_irq,
-					tmp_client_data);
-	if (ret < 0) {
-		KDEBUG(M4SH_ERROR, "Error registering int %d (%d)\n",
-				M4SH_IRQ_TMP_DATA_READY, ret);
-		goto unregister_misc_device;
-	}
-
-	if (device_create_file(&pdev->dev, &dev_attr_internal)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				TMP_CLIENT_DRIVER_NAME);
-		ret = -1;
-		goto unregister_irq;
-	}
-
-	if (device_create_file(&pdev->dev, &dev_attr_external)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				TMP_CLIENT_DRIVER_NAME);
-		ret = -1;
-		goto remove_internal_device_file;
-	}
-	if (device_create_file(&pdev->dev, &dev_attr_LogLevel)) {
-		KDEBUG(M4SH_ERROR, "Error creating %s sys entry\n",
-				TMP_CLIENT_DRIVER_NAME);
-		ret = -1;
-		goto remove_external_device_file;
-	}
-	KDEBUG(M4SH_INFO, "Initialized %s driver\n", TMP_CLIENT_DRIVER_NAME);
-	return 0;
-
-remove_external_device_file:
-	device_remove_file(&pdev->dev, &dev_attr_external);
-remove_internal_device_file:
-	device_remove_file(&pdev->dev, &dev_attr_internal);
-unregister_irq:
-	m4sensorhub_irq_unregister(m4sensorhub, M4SH_IRQ_TMP_DATA_READY);
-unregister_misc_device:
-	misc_tmp_data = NULL;
-	misc_deregister(&temperature_client_miscdrv);
-unregister_input_device:
-	input_unregister_device(tmp_client_data->input_dev);
-free_memory:
-	platform_set_drvdata(pdev, NULL);
-	tmp_client_data->m4sensorhub = NULL;
-	kfree(tmp_client_data);
-	tmp_client_data = NULL;
-	return ret;
-}
-
-static int __exit temperature_client_remove(struct platform_device *pdev)
-{
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	device_remove_file(&pdev->dev, &dev_attr_LogLevel);
-	device_remove_file(&pdev->dev, &dev_attr_external);
-	device_remove_file(&pdev->dev, &dev_attr_internal);
-	m4sensorhub_irq_disable(tmp_client_data->m4sensorhub,
-				M4SH_IRQ_TMP_DATA_READY);
-	m4sensorhub_irq_unregister(tmp_client_data->m4sensorhub,
-				M4SH_IRQ_TMP_DATA_READY);
-	misc_tmp_data = NULL;
-	misc_deregister(&temperature_client_miscdrv);
-	input_unregister_device(tmp_client_data->input_dev);
-	platform_set_drvdata(pdev, NULL);
-	tmp_client_data->m4sensorhub = NULL;
-	kfree(tmp_client_data);
-	tmp_client_data = NULL;
-	return 0;
-}
-
-static void temperature_client_shutdown(struct platform_device *pdev)
-{
-	return;
-}
-
-#ifdef CONFIG_PM
-
-static int temperature_client_suspend(struct platform_device *pdev,
-				pm_message_t message)
-{
-	struct tmp_client *tmp_client_data = platform_get_drvdata(pdev);
-
-	return m4_set_tmp_samplerate(tmp_client_data, -1);
-}
-
-static int temperature_client_resume(struct platform_device *pdev)
-{
-	return 0;
-}
-
-#else
-#define temperature_client_suspend NULL
-#define temperature_client_resume  NULL
-#endif
-
-static struct of_device_id m4temp_match_tbl[] = {
-	{ .compatible = "mot,m4temperature" },
-	{},
-};
-
-static struct platform_driver temp_client_driver = {
-	.probe		= temperature_client_probe,
-	.remove		= __exit_p(temperature_client_remove),
-	.shutdown	= temperature_client_shutdown,
-	.suspend	= temperature_client_suspend,
-	.resume		= temperature_client_resume,
-	.driver		= {
-		.name	= TMP_CLIENT_DRIVER_NAME,
-		.owner	= THIS_MODULE,
-		.of_match_table = of_match_ptr(m4temp_match_tbl),
-	},
-};
-
-static int __init temperature_client_init(void)
-{
-	return platform_driver_register(&temp_client_driver);
-}
-
-static void __exit temperature_client_exit(void)
-{
-	platform_driver_unregister(&temp_client_driver);
-}
-
-module_init(temperature_client_init);
-module_exit(temperature_client_exit);
-
-MODULE_ALIAS("platform:temperature_client");
-MODULE_DESCRIPTION("M4 Sensor Hub driver");
-MODULE_AUTHOR("Motorola");
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/misc/m4sensorhub_wrist.c b/drivers/misc/m4sensorhub_wrist.c
deleted file mode 100644
index faed5f4068b..00000000000
--- a/drivers/misc/m4sensorhub_wrist.c
+++ /dev/null
@@ -1,836 +0,0 @@
-/*
- * Copyright (C) 2013 Motorola Mobility, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- * 02111-1307, USA
- */
-
-#include "m4sensorhub_wrist.h"
-#include <linux/types.h>
-#include <linux/platform_device.h>
-#include <linux/m4sensorhub.h>
-#include <linux/firmware.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/m4sensorhub_gpio.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/of_gpio.h>
-
-static struct platform_driver m4wrist_client_driver;
-static int m4wrist_probe(struct platform_device *pdev);
-static int m4wrist_remove(struct platform_device *pdev);
-static int m4wrist_init(void);
-static void m4wrist_exit(void);
-static void m4wrist_free(struct m4wrist_driver_data *dd);
-static int m4wrist_gpio_init(struct m4wrist_driver_data *dd);
-static int m4wrist_request_firmware(struct m4wrist_driver_data *dd);
-static int m4wrist_request_irq(struct m4wrist_driver_data *dd);
-static void m4wrist_firmware_callback(const struct firmware *fw,
-		void *context);
-static void m4wrist_irq(enum m4sensorhub_irqs event, void *context);
-static int m4wrist_gpio_control(struct m4wrist_driver_data *dd);
-static int m4wrist_gpio_release(struct m4wrist_driver_data *dd);
-static int m4wrist_reflash_ic(struct m4wrist_driver_data *dd);
-static int m4wrist_enter_reset_mode(struct m4wrist_driver_data *dd);
-static int m4wrist_erase_flash(struct m4wrist_driver_data *dd);
-static int m4wrist_program_image(struct m4wrist_driver_data *dd);
-static void m4wrist_send_bitstream(struct m4wrist_driver_data *dd,
-		uint8_t *stream, uint32_t bits);
-static void m4wrist_toggle_clock(struct m4wrist_driver_data *dd, int cycles);
-static int m4wrist_wait_poll(struct m4wrist_driver_data *dd);
-static int m4wrist_read_id_word(struct m4wrist_driver_data *dd, uint8_t *data);
-
-
-static struct of_device_id m4wrist_match_tbl[] = {
-    { .compatible = "mot,m4wrist" },
-    {},
-};
-
-static struct platform_driver m4wrist_client_driver = {
-	.probe		= m4wrist_probe,
-	.remove		= m4wrist_remove,
-	.driver		= {
-		.name	= "m4sensorhub_wrist",
-		.owner	= THIS_MODULE,
-		.of_match_table = of_match_ptr(m4wrist_match_tbl),
-	},
-};
-
-static int m4wrist_probe(struct platform_device *pdev)
-{
-	int err = 0;
-	struct m4wrist_driver_data *dd = NULL;
-	struct device_node *node = pdev->dev.of_node;
-
-	if (!node) {
-		pr_warn("devtree node not present!\n");
-		return -ENODEV;
-	}
-	dd = kzalloc(sizeof(struct m4wrist_driver_data), GFP_KERNEL);
-	if (dd == NULL) {
-		printk(KERN_ERR "%s: Unable to create driver data.\n",
-			__func__);
-		err = -ENOMEM;
-		goto m4wrist_probe_fail;
-	}
-
-	dd->pdev = pdev;
-	platform_set_drvdata(pdev, dd);
-
-	dd->mutex = kzalloc(sizeof(struct mutex), GFP_KERNEL);
-	if (dd->mutex == NULL) {
-		printk(KERN_ERR "%s: Unable to create mutex lock.\n",
-			__func__);
-		err = -ENOMEM;
-		goto m4wrist_probe_fail;
-	}
-	mutex_init(dd->mutex);
-
-	dd->gpio_xres = of_get_named_gpio_flags(node,
-			"mot,wrist_xres", 0, NULL);
-	if (dd->gpio_xres <= 0) {
-		printk(KERN_ERR "%s: gpio_xres is invalid.\n", __func__);
-		err = -EINVAL;
-		goto m4wrist_probe_fail;
-	}
-	dd->gpio_clk = of_get_named_gpio_flags(node, "mot,wrist_clk", 0, NULL);
-	if (dd->gpio_clk <= 0) {
-		printk(KERN_ERR "%s: gpio_clk is invalid.\n", __func__);
-		err = -EINVAL;
-		goto m4wrist_probe_fail;
-	}
-	dd->gpio_data = of_get_named_gpio_flags(node,
-			"mot,wrist_data", 0, NULL);
-	if (dd->gpio_data <= 0) {
-		printk(KERN_ERR "%s: gpio_data is invalid.\n", __func__);
-		err = -EINVAL;
-		goto m4wrist_probe_fail;
-	}
-
-	err = m4wrist_gpio_init(dd);
-	if (err < 0)
-		goto m4wrist_probe_fail;
-
-	err = m4wrist_request_firmware(dd);
-	if (err < 0)
-		goto m4wrist_probe_fail;
-
-	err = m4wrist_request_irq(dd);
-	if (err < 0)
-		goto m4wrist_probe_fail;
-
-	goto m4wrist_probe_pass;
-
-m4wrist_probe_fail:
-	m4wrist_free(dd);
-	printk(KERN_ERR "%s: Probe failed with error code %d.\n",
-		__func__, err);
-	return err;
-
-m4wrist_probe_pass:
-	return 0;
-}
-
-static void m4wrist_free(struct m4wrist_driver_data *dd)
-{
-	if (dd != NULL) {
-		kfree(dd->img);
-
-		if (dd->client != NULL) {
-			m4sensorhub_irq_disable(dd->client,
-				M4SH_IRQ_WRIST_READY);
-			m4sensorhub_irq_unregister(dd->client,
-				M4SH_IRQ_WRIST_READY);
-		}
-
-		kfree(dd->mutex);
-		platform_set_drvdata(dd->pdev, NULL);
-		kfree(dd);
-	}
-
-	return;
-}
-
-static int m4wrist_gpio_init(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	int i = 0;
-	int gpio_nums[3] = {dd->gpio_xres, dd->gpio_clk, dd->gpio_data};
-	char *gpio_names[3] = {"wrist_xres", "wrist_clk", "wrist_data"};
-
-	for (i = 0; i < 3; i++) {
-		err = gpio_request(gpio_nums[i], gpio_names[i]);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to request %s.\n",
-				__func__, gpio_names[i]);
-			i--;
-			goto m4wrist_gpio_init_fail;
-		}
-
-		err = gpio_direction_input(gpio_nums[i]);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to make %s an input.\n",
-				__func__, gpio_names[i]);
-			gpio_free(gpio_nums[i]);
-			i--;
-			goto m4wrist_gpio_init_fail;
-		}
-	}
-
-	goto m4wrist_gpio_init_exit;
-
-m4wrist_gpio_init_fail:
-	while (i >= 0) {
-		gpio_free(gpio_nums[i]);
-		i--;
-	}
-
-m4wrist_gpio_init_exit:
-	return err;
-}
-
-static int m4wrist_request_firmware(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	const struct firmware *fw = NULL;
-
-	err = request_firmware(&fw,
-		"m4sensorhub_wrist.bin", &(dd->pdev->dev));
-	if (err < 0) {
-		printk(KERN_ERR "%s: Firmware request failed.\n", __func__);
-		goto m4wrist_request_firmware_fail;
-	}
-
-	m4wrist_firmware_callback(fw, dd);
-
-m4wrist_request_firmware_fail:
-	return err;
-}
-
-static int m4wrist_request_irq(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-
-	dd->client = m4sensorhub_client_get_drvdata();
-	if (dd->client == NULL) {
-		printk(KERN_ERR "%s: No client data retrieved.\n",
-			__func__);
-		err = -ENODATA;
-		goto m4wrist_request_irq_fail;
-	}
-
-	err = m4sensorhub_irq_register(dd->client,
-		M4SH_IRQ_WRIST_READY, m4wrist_irq, dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to register IRQ.\n", __func__);
-		dd->client = NULL;
-		goto m4wrist_request_irq_fail;
-	}
-
-	err = m4sensorhub_irq_enable(dd->client, M4SH_IRQ_WRIST_READY);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to enable IRQ.\n", __func__);
-		m4sensorhub_irq_unregister(dd->client, M4SH_IRQ_WRIST_READY);
-		dd->client = NULL;
-		goto m4wrist_request_irq_fail;
-	}
-
-m4wrist_request_irq_fail:
-	return err;
-}
-
-static void m4wrist_firmware_callback(const struct firmware *fw,
-		void *context)
-{
-	struct m4wrist_driver_data *dd = context;
-
-	mutex_lock(dd->mutex);
-
-	if (fw == NULL) {
-		printk(KERN_ERR "%s: No firmware received.\n", __func__);
-		goto m4wrist_firmware_callback_fail;
-	} else if (fw->data == NULL || fw->size == 0) {
-		printk(KERN_ERR "%s: No data found.\n", __func__);
-		goto m4wrist_firmware_callback_fail;
-	} else if (fw->data[0] < 4) {
-		printk(KERN_ERR "%s: Firmware header is too small.\n",
-			__func__);
-		goto m4wrist_firmware_callback_fail;
-	} else if (fw->data[0] >= fw->size) {
-		printk(KERN_ERR "%s: Firmware data is missing.\n", __func__);
-		goto m4wrist_firmware_callback_fail;
-	}
-
-	dd->size = fw->size - (fw->data[0] + 1);
-	dd->img = kzalloc(dd->size * sizeof(uint8_t), GFP_KERNEL);
-	if (dd->img == NULL) {
-		printk(KERN_ERR "%s: Failed to allocate memory for firmware.\n",
-			__func__);
-		goto m4wrist_firmware_callback_fail;
-	}
-	memcpy(dd->img, &(fw->data[fw->data[0] + 1]), dd->size);
-	dd->si_id[0] = fw->data[1];
-	dd->si_id[1] = fw->data[2];
-	dd->fw_ver[0] = fw->data[3];
-	dd->fw_ver[1] = fw->data[4];
-
-m4wrist_firmware_callback_fail:
-	release_firmware(fw);
-	mutex_unlock(dd->mutex);
-	return;
-}
-
-static int m4wrist_remove(struct platform_device *pdev)
-{
-	struct m4wrist_driver_data *dd = NULL;
-
-	dd = platform_get_drvdata(pdev);
-	if (dd != NULL) {
-		gpio_free(dd->gpio_xres);
-		gpio_free(dd->gpio_clk);
-		gpio_free(dd->gpio_data);
-		m4wrist_free(dd);
-	}
-
-	return 0;
-}
-
-static int m4wrist_init(void)
-{
-	return platform_driver_register(&m4wrist_client_driver);
-}
-
-static void m4wrist_exit(void)
-{
-	platform_driver_unregister(&m4wrist_client_driver);
-}
-
-module_init(m4wrist_init);
-module_exit(m4wrist_exit);
-
-static void m4wrist_irq(enum m4sensorhub_irqs event, void *context)
-{
-	struct m4wrist_driver_data *dd = context;
-	int err = 0;
-	uint8_t irq_reason = 0x00;
-	uint8_t val[2] = {0x00, 0x00};
-	uint8_t mask[2] = {0xFF, 0xFF};
-	mutex_lock(dd->mutex);
-
-	if (dd->img == NULL) {
-		printk(KERN_ERR "%s: Firmware image is missing--%s.\n",
-			__func__, "unable to respond to interrupts");
-		err = -ENODATA;
-		goto m4wrist_irq_fail;
-	}
-
-	err = m4sensorhub_reg_read(dd->client,
-		M4SH_REG_WRIST_INTERRUPTREASON, &irq_reason);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to read interrupt reason.\n",
-			__func__);
-		goto m4wrist_irq_fail;
-	} else if (err < 1) {
-		printk(KERN_ERR "%s: Read %d bytes instead of 1.\n",
-			__func__, err);
-		err = -EINVAL;
-		goto m4wrist_irq_fail;
-	}
-
-	switch (irq_reason) {
-	case 0x00:
-		err = m4wrist_gpio_control(dd);
-		if (err < 0) {
-			printk(KERN_ERR
-				"%s: Failed to take control of GPIO lines.\n",
-				__func__);
-			goto m4wrist_irq_fail;
-		}
-
-		err = m4wrist_reflash_ic(dd);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to reflash IC.\n",
-				__func__);
-			goto m4wrist_irq_fail;
-		}
-
-		err = m4wrist_gpio_release(dd);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to release GPIO lines.\n",
-				__func__);
-			goto m4wrist_irq_fail;
-		}
-
-		val[0] = 0x01;
-		err = m4sensorhub_reg_write(dd->client,
-			M4SH_REG_WRIST_HOSTRESPONSE, &(val[0]), &(mask[0]));
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to write host response.\n",
-				__func__);
-			goto m4wrist_irq_fail;
-		}  else if (err < 1) {
-			printk(KERN_ERR "%s: Wrote %d bytes instead of 1.\n",
-				__func__, err);
-			err = -EINVAL;
-			goto m4wrist_irq_fail;
-		}
-		break;
-
-	case 0x01:
-		val[0] = dd->fw_ver[0];
-		val[1] = dd->fw_ver[1];
-		err = m4sensorhub_reg_write(dd->client,
-			M4SH_REG_WRIST_FMONFILE, &(val[0]), &(mask[0]));
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to write firmware version.\n",
-				__func__);
-			goto m4wrist_irq_fail;
-		}  else if (err < 2) {
-			printk(KERN_ERR "%s: Wrote %d bytes instead of 2.\n",
-				__func__, err);
-			err = -EINVAL;
-			goto m4wrist_irq_fail;
-		}
-		break;
-
-	default:
-		printk(KERN_ERR "%s: Unexpected interrupt 0x%02X received.\n",
-			__func__, irq_reason);
-		err = -EINVAL;
-		goto m4wrist_irq_fail;
-		break;
-	}
-
-	goto m4wrist_irq_pass;
-
-m4wrist_irq_fail:
-	printk(KERN_ERR "%s: IRQ handler failed with error code %d.\n",
-		__func__, err);
-
-m4wrist_irq_pass:
-	mutex_unlock(dd->mutex);
-	return;
-}
-
-static int m4wrist_gpio_control(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	int i = 0;
-	int gpio_nums[3] = {dd->gpio_xres, dd->gpio_clk, dd->gpio_data};
-	char *gpio_names[3] = {"wrist_xres", "wrist_clk", "wrist_data"};
-
-	for (i = 0; i < 3; i++) {
-		err = gpio_direction_output(gpio_nums[i], 0);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to take control of %s.\n",
-				__func__, gpio_names[i]);
-			goto m4wrist_gpio_control_fail;
-		}
-	}
-
-m4wrist_gpio_control_fail:
-	return err;
-}
-
-static int m4wrist_gpio_release(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	int i = 0;
-	int gpio_nums[3] = {dd->gpio_xres, dd->gpio_clk, dd->gpio_data};
-	char *gpio_names[3] = {"wrist_xres", "wrist_clk", "wrist_data"};
-
-	for (i = 0; i < 3; i++) {
-		err = gpio_direction_input(gpio_nums[i]);
-		if (err < 0) {
-			printk(KERN_ERR "%s: Failed to release %s.\n",
-				__func__, gpio_names[i]);
-			goto m4wrist_gpio_release_fail;
-		}
-	}
-
-m4wrist_gpio_release_fail:
-	return err;
-}
-
-static int m4wrist_reflash_ic(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-
-	err = m4wrist_enter_reset_mode(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to enter programming mode.\n",
-			__func__);
-		goto m4wrist_reflash_ic_fail;
-	}
-
-	err = m4wrist_erase_flash(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to erase IC flash.\n", __func__);
-		goto m4wrist_reflash_ic_fail;
-	}
-
-	err = m4wrist_program_image(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to program firmware image",
-			__func__);
-		goto m4wrist_reflash_ic_fail;
-	}
-
-	gpio_set_value(dd->gpio_xres, 1);
-	udelay(100);
-	gpio_set_value(dd->gpio_xres, 0);
-
-m4wrist_reflash_ic_fail:
-	return err;
-}
-
-static int m4wrist_enter_reset_mode(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	uint8_t silicon_id[2] = {0x00, 0x00};
-
-	msleep(20);
-	gpio_set_value(dd->gpio_xres, 1);
-	udelay(400);
-	gpio_set_value(dd->gpio_xres, 0);
-	udelay(1);
-
-	m4wrist_send_bitstream(dd, &(m4wrist_id_setup_1[0]),
-		M4WRIST_ID_SETUP_1_BITS);
-
-	err = m4wrist_wait_poll(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to wait-and-poll 1.\n", __func__);
-		goto m4wrist_enter_reset_mode_fail;
-	}
-
-	m4wrist_send_bitstream(dd, &(m4wrist_id_setup_2[0]),
-		M4WRIST_ID_SETUP_2_BITS);
-
-	err = m4wrist_wait_poll(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to wait-and-poll 2.\n", __func__);
-		goto m4wrist_enter_reset_mode_fail;
-	}
-
-	m4wrist_send_bitstream(dd, &(m4wrist_sync_enable[0]),
-		M4WRIST_SYNC_ENABLE_BITS);
-
-	err = m4wrist_read_id_word(dd, &(silicon_id[0]));
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to read silicon ID\n", __func__);
-		goto m4wrist_enter_reset_mode_fail;
-	}
-
-	m4wrist_send_bitstream(dd, &(m4wrist_sync_disable[0]),
-		M4WRIST_SYNC_DISABLE_BITS);
-
-	if (silicon_id[0] != dd->si_id[0] || silicon_id[1] != dd->si_id[1]) {
-		printk(KERN_ERR "%s: Silicon ID mismatch (read 0x%02X%02X).\n",
-			__func__, silicon_id[0], silicon_id[1]);
-		err = -EINVAL;
-		goto m4wrist_enter_reset_mode_fail;
-	}
-
-m4wrist_enter_reset_mode_fail:
-	return err;
-}
-
-static int m4wrist_erase_flash(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-
-	m4wrist_send_bitstream(dd, &(m4wrist_erase[0]),
-		M4WRIST_ERASE_BITS);
-
-	err = m4wrist_wait_poll(dd);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to wait-and-poll.\n", __func__);
-		goto m4wrist_erase_flash_fail;
-	}
-
-m4wrist_erase_flash_fail:
-	return err;
-}
-
-static int m4wrist_program_image(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	uint32_t iter = 0;
-	int i = 0;
-	uint8_t blk_num = 0x00;
-	uint8_t cur_addr = 0x00;
-	uint8_t cur_vector[3] = {0x00, 0x00, 0x00};
-	uint8_t cur_blk_data[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-	uint8_t status[2] = {0x00, 0x00};
-
-	if (((dd->size % 128) != 0) || (dd->size == 0)) {
-		printk(KERN_ERR "%s: Firmware has invalid size of %u.\n",
-			__func__, dd->size);
-		err = -EINVAL;
-		goto m4wrist_program_image_fail;
-	}
-
-	printk(KERN_INFO "%s: Flashing version 0x%02X 0x%02X...\n", __func__,
-		dd->fw_ver[0], dd->fw_ver[1]);
-
-	while (iter < (dd->size - 1)) {
-		m4wrist_send_bitstream(dd, &(m4wrist_sync_enable[0]),
-			M4WRIST_SYNC_ENABLE_BITS);
-
-		m4wrist_send_bitstream(dd, &(m4wrist_read_write_setup[0]),
-			M4WRIST_READ_WRITE_SETUP_BITS);
-
-		cur_addr = 0x00;
-		for (i = 0; i < 128; i++) {
-			cur_vector[0] = 0x90 | ((cur_addr & 0x78) >> 3);
-			cur_vector[1] = ((cur_addr & 0x07) << 5) |
-				((dd->img[iter] & 0xF8) >> 3);
-			cur_vector[2] = ((dd->img[iter] & 0x07) << 5) | 0x1C;
-			m4wrist_send_bitstream(dd, &(cur_vector[0]), 22);
-
-			cur_addr++;
-			iter++;
-		}
-
-		m4wrist_send_bitstream(dd, &(m4wrist_sync_enable[0]),
-			M4WRIST_SYNC_ENABLE_BITS);
-
-		cur_blk_data[0] = 0xDE;
-		cur_blk_data[1] = 0xE0;
-		cur_blk_data[2] = 0x1E;
-		cur_blk_data[3] = 0x7D;
-		cur_blk_data[4] = (blk_num & 0xFE) >> 1;
-		cur_blk_data[5] = ((blk_num & 0x01) << 7) | 0x70;
-		m4wrist_send_bitstream(dd, &(cur_blk_data[0]), 44);
-
-		m4wrist_send_bitstream(dd, &(m4wrist_sync_disable[0]),
-			M4WRIST_SYNC_DISABLE_BITS);
-
-		m4wrist_send_bitstream(dd, &(m4wrist_program_and_verify[0]),
-			M4WRIST_PROGRAM_AND_VERIFY_BITS);
-
-		err = m4wrist_wait_poll(dd);
-		if (err < 0) {
-			printk(KERN_ERR "%s: %s for block 0x%02X.\n",
-				__func__, "Failed to wait-and-poll", blk_num);
-			goto m4wrist_program_image_fail;
-		}
-
-		m4wrist_send_bitstream(dd, &(m4wrist_sync_enable[0]),
-			M4WRIST_SYNC_ENABLE_BITS);
-
-		err = m4wrist_read_id_word(dd, &(status[0]));
-		if (err < 0) {
-			printk(KERN_ERR "%s: %s for block 0x%02X.\n",
-				__func__, "Failed to read status", blk_num);
-		}
-
-		m4wrist_send_bitstream(dd, &(m4wrist_sync_disable[0]),
-			M4WRIST_SYNC_DISABLE_BITS);
-
-		if (status[0] != 0x00) {
-			printk(KERN_ERR "%s: %s 0x%02X %s 0x%02X.\n", __func__,
-				"Programming block", blk_num,
-				"failed with error code", status[0]);
-			err = -EINVAL;
-			goto m4wrist_program_image_fail;
-		}
-
-		blk_num++;
-	}
-
-m4wrist_program_image_fail:
-	return err;
-}
-
-static void m4wrist_send_bitstream(struct m4wrist_driver_data *dd,
-		uint8_t *stream, uint32_t bits)
-{
-	int i = 0;
-	int j = 0;
-	uint32_t bits_sent = 0;
-
-	j = 7;
-	while (bits_sent < bits) {
-		if (stream[i] & (0x01 << j))
-			gpio_set_value(dd->gpio_data, 1);
-		else
-			gpio_set_value(dd->gpio_data, 0);
-
-		gpio_set_value(dd->gpio_clk, 1);
-		gpio_set_value(dd->gpio_clk, 0);
-
-		bits_sent++;
-		j--;
-		if (j < 0) {
-			j = 7;
-			i++;
-		}
-	}
-
-	return;
-}
-
-static void m4wrist_toggle_clock(struct m4wrist_driver_data *dd, int cycles)
-{
-	int i = 0;
-
-	for (i = 0; i < cycles; i++) {
-		gpio_set_value(dd->gpio_clk, 1);
-		gpio_set_value(dd->gpio_clk, 0);
-	}
-
-	return;
-}
-
-static int m4wrist_wait_poll(struct m4wrist_driver_data *dd)
-{
-	int err = 0;
-	int i = 0;
-	bool saw_event = false;
-	uint8_t clear[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
-
-	err = gpio_direction_input(dd->gpio_data);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to release data line.\n", __func__);
-		goto m4wrist_wait_poll_fail;
-	}
-
-	udelay(1);
-
-	for (i = 0; i < 200000; i++) {
-		if (gpio_get_value(dd->gpio_data) == 1) {
-			saw_event = true;
-			break;
-		} else {
-			m4wrist_toggle_clock(dd, 1);
-		}
-	}
-
-	if (!saw_event) {
-		printk(KERN_ERR "%s: Timeout waiting for data high.\n",
-			__func__);
-		err = -ETIME;
-		goto m4wrist_wait_poll_fail;
-	}
-
-	saw_event = false;
-	for (i = 0; i < 200000; i++) {
-		if (gpio_get_value(dd->gpio_data) == 0) {
-			saw_event = true;
-			break;
-		} else {
-			udelay(1);
-		}
-	}
-
-	if (!saw_event) {
-		printk(KERN_ERR "%s: Timeout waiting for data low.\n",
-			__func__);
-		err = -ETIME;
-		goto m4wrist_wait_poll_fail;
-	}
-
-	err = gpio_direction_output(dd->gpio_data, 0);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to acquire data line.\n",
-			__func__);
-		goto m4wrist_wait_poll_fail;
-	}
-
-	m4wrist_send_bitstream(dd, &(clear[0]), 40);
-
-m4wrist_wait_poll_fail:
-	return err;
-}
-
-static int m4wrist_read_id_word(struct m4wrist_driver_data *dd, uint8_t *data)
-{
-	int err = 0;
-	int i = 0;
-	int bit = 0;
-	uint8_t stream1[2] = {0xBF, 0x00};
-	uint8_t stream2[2] = {0xDF, 0x90};
-
-	m4wrist_send_bitstream(dd, &(stream1[0]), 11);
-
-	err = gpio_direction_input(dd->gpio_data);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to release initial data line.\n",
-			__func__);
-		goto m4wrist_read_id_word_fail;
-	}
-
-	m4wrist_toggle_clock(dd, 2);
-
-	data[0] = 0x00;
-	for (i = 0; i <= 7; i++) {
-		gpio_set_value(dd->gpio_clk, 1);
-		data[0] = (data[0] << 1);
-		bit = gpio_get_value(dd->gpio_data);
-		if (bit == 1)
-			(data[0])++;
-
-		gpio_set_value(dd->gpio_clk, 0);
-	}
-
-	gpio_set_value(dd->gpio_clk, 1);
-
-	err = gpio_direction_output(dd->gpio_data, 1);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to acquire initial data line.\n",
-			__func__);
-		goto m4wrist_read_id_word_fail;
-	}
-
-	m4wrist_send_bitstream(dd, &(stream2[0]), 12);
-
-	err = gpio_direction_input(dd->gpio_data);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to release final data line.\n",
-			__func__);
-		goto m4wrist_read_id_word_fail;
-	}
-
-	m4wrist_toggle_clock(dd, 2);
-
-	data[1] = 0x00;
-	for (i = 0; i <= 7; i++) {
-		gpio_set_value(dd->gpio_clk, 1);
-		data[1] = (data[1] << 1);
-		bit = gpio_get_value(dd->gpio_data);
-		if (bit == 1)
-			(data[1])++;
-
-		gpio_set_value(dd->gpio_clk, 0);
-	}
-
-	m4wrist_toggle_clock(dd, 1);
-
-	err = gpio_direction_output(dd->gpio_data, 0);
-	if (err < 0) {
-		printk(KERN_ERR "%s: Failed to acquire final data line.\n",
-			__func__);
-		goto m4wrist_read_id_word_fail;
-	}
-
-	m4wrist_toggle_clock(dd, 1);
-
-m4wrist_read_id_word_fail:
-	return err;
-}
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/misc/m4sensorhub_wrist.h b/drivers/misc/m4sensorhub_wrist.h
deleted file mode 100644
index 7065935cc17..00000000000
--- a/drivers/misc/m4sensorhub_wrist.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright (C) 2013 Motorola Mobility, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- * 02111-1307, USA
- */
-
-#ifndef _M4SENSORHUB_WRIST_H_
-#define _M4SENSORHUB_WRIST_H_
-
-#include <linux/types.h>
-#include <linux/platform_device.h>
-#include <linux/m4sensorhub.h>
-
-struct m4wrist_driver_data {
-	struct m4sensorhub_data  *client;
-	struct mutex             *mutex;
-	struct platform_device   *pdev;
-
-	int         gpio_xres;
-	int         gpio_clk;
-	int         gpio_data;
-
-	uint8_t     *img;
-	uint32_t    size;
-	uint8_t     si_id[2];
-	uint8_t     fw_ver[2];
-} __packed;
-
-#define M4WRIST_ID_SETUP_1_BITS 594
-static uint8_t m4wrist_id_setup_1[] = {
-	0xCA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x0D, 0xEE, 0x21, 0xF7, 0xF0, 0x27, 0xDC, 0x40,
-	0x9F, 0x70, 0x01, 0xFD, 0xEE, 0x01, 0xE7, 0xC1,
-	0xD7, 0x9F, 0x20, 0x7E, 0x7D, 0x88, 0x7D, 0xEE,
-	0x21, 0xF7, 0xF0, 0x07, 0xDC, 0x40, 0x1F, 0x70,
-	0x01, 0xFD, 0xEE, 0x01, 0xF7, 0xA0, 0x1F, 0xDE,
-	0xA0, 0x1F, 0x7B, 0x00, 0x7D, 0xE0, 0x13, 0xF7,
-	0xC0, 0x07, 0xDF, 0x28, 0x1F, 0x7D, 0x18, 0x7D,
-	0xFE, 0x25, 0x80,
-};
-
-#define M4WRIST_ID_SETUP_2_BITS 418
-static uint8_t m4wrist_id_setup_2[] = {
-	0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09,
-	0xF7, 0x00, 0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81,
-	0xF9, 0xF4, 0x01, 0xF7, 0xF0, 0x07, 0xDC, 0x40,
-	0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, 0xF7, 0xA0,
-	0x1F, 0xDE, 0xA0, 0x1F, 0x7B, 0x00, 0x7D, 0xE0,
-	0x0D, 0xF7, 0xC0, 0x07, 0xDF, 0x28, 0x1F, 0x7D,
-	0x18, 0x7D, 0xFE, 0x25, 0x80,
-};
-
-#define M4WRIST_SYNC_ENABLE_BITS 110
-static uint8_t m4wrist_sync_enable[] = {
-	0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09,
-	0xF7, 0x00, 0x1F, 0xDE, 0xE0, 0x1C,
-};
-
-#define M4WRIST_SYNC_DISABLE_BITS 110
-static uint8_t m4wrist_sync_disable[] = {
-	0xDE, 0xE2, 0x1F, 0x71, 0x00, 0x7D, 0xFC, 0x01,
-	0xF7, 0x00, 0x1F, 0xDE, 0xE0, 0x1C,
-};
-
-#define M4WRIST_ERASE_BITS 396
-static uint8_t m4wrist_erase[] = {
-	0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09,
-	0xF7, 0x00, 0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x85,
-	0xFD, 0xFC, 0x01, 0xF7, 0x10, 0x07, 0xDC, 0x00,
-	0x7F, 0x7B, 0x80, 0x7D, 0xE0, 0x0B, 0xF7, 0xA0,
-	0x1F, 0xDE, 0xA0, 0x1F, 0x7B, 0x04, 0x7D, 0xF0,
-	0x01, 0xF7, 0xC9, 0x87, 0xDF, 0x48, 0x1F, 0x7F,
-	0x89, 0x60,
-};
-
-#define M4WRIST_READ_WRITE_SETUP_BITS 66
-static uint8_t m4wrist_read_write_setup[] = {
-	0xDE, 0xF0, 0x1F, 0x78, 0x00, 0x7D, 0xA0, 0x03,
-	0xC0,
-};
-
-#define M4WRIST_PROGRAM_AND_VERIFY_BITS 440
-static uint8_t m4wrist_program_and_verify[] = {
-	0xDE, 0xE2, 0x1F, 0x7F, 0x02, 0x7D, 0xC4, 0x09,
-	0xF7, 0x00, 0x1F, 0x9F, 0x07, 0x5E, 0x7C, 0x81,
-	0xF9, 0xF7, 0x01, 0xF7, 0xF0, 0x07, 0xDC, 0x40,
-	0x1F, 0x70, 0x01, 0xFD, 0xEE, 0x01, 0xF6, 0xA0,
-	0x0F, 0xDE, 0x80, 0x7F, 0x7A, 0x80, 0x7D, 0xEC,
-	0x01, 0xF7, 0x80, 0x57, 0xDF, 0x00, 0x1F, 0x7C,
-	0xA0, 0x7D, 0xF4, 0x61, 0xF7, 0xF8, 0x96,
-};
-
-#endif /* _M4SENSORHUB_WRIST_H_ */
diff --git a/include/linux/m4sensorhub.h b/include/linux/m4sensorhub.h
index 266f2742d89..717e88b37a3 100644
--- a/include/linux/m4sensorhub.h
+++ b/include/linux/m4sensorhub.h
@@ -22,6 +22,7 @@
 #include <linux/platform_device.h>
 #include <linux/m4sensorhub/m4sensorhub_registers.h>
 #include <linux/m4sensorhub/m4sensorhub_irqs.h>
+#include <linux/firmware.h>
 
 #ifdef __KERNEL__
 
@@ -166,7 +167,8 @@ int m4sensorhub_i2c_write_read(struct m4sensorhub_data *m4sensorhub,
 				      u8 *buf, int writelen, int readlen);
 
 int m4sensorhub_load_firmware(struct m4sensorhub_data *m4sensorhub,
-	unsigned short force_upgrade);
+	unsigned short force_upgrade,
+	const struct firmware *firmware);
 
 /* Interrupt handler */
 int m4sensorhub_irq_init(struct m4sensorhub_data *m4sensorhub);
@@ -195,6 +197,10 @@ 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 *));
+void m4sensorhub_unregister_initcall(
+		int(*initfunc)(struct m4sensorhub_data *));
+
 
 #endif /* __KERNEL__ */
 #endif  /* __M4SENSORHUB_H__ */