drivers/misc/m4sensorhub_als.c - kernel/omap - Git at Google

 /*
  *  Copyright (C) 2012-2014 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/platform_device.h>
 #include <linux/fs.h>
 #include <linux/m4sensorhub.h>
 #include <linux/input.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
 #include <linux/notifier.h>
 #include <linux/als_notify.h>
 #ifdef CONFIG_ALS_WHILE_CHARGING
 #include <linux/wakeup_source_notify.h>
 #endif /* CONFIG_ALS_WHILE_CHARGING */
 #endif

 #define m4als_err(format, args...)  KDEBUG(M4SH_ERROR, format, ## args)

 #define M4ALS_DRIVER_NAME           "m4sensorhub_als"

 #define M4ALS_IRQ_ENABLED_BIT       0
 #define ALS_SAMPLERATE_WHILE_DOCKED	10 /* in seconds */

 struct m4als_driver_data {
 	struct platform_device      *pdev;
 	struct m4sensorhub_data     *m4;
 	struct mutex                mutex; /* controls driver entry points */
 	struct input_dev            *indev;
 	struct delayed_work         m4als_work;

 	/* Beware of changing this from uint16, check als_notify.h
 	since notifier uses values outside luminosity range for
 	conveying enable/disable status */
 	uint16_t        luminosity;
 	int16_t         samplerate;
 	int16_t         latest_samplerate;
 	int16_t         fastest_rate;
 	uint16_t        status;
 #ifdef CONFIG_ALS_WHILE_CHARGING
 	struct          notifier_block charger_nb;
 	bool            chargerstatus;
 #endif
 };

 #ifdef CONFIG_ALS_WHILE_CHARGING
 static int charger_notify(struct notifier_block *self,
 			unsigned long action, void *dev)
 {
 	struct m4als_driver_data *dd =
 		container_of(self, struct m4als_driver_data, charger_nb);
 	switch (action) {
 	case DISPLAY_WAKE_EVENT_DOCKON:
 	case DISPLAY_WAKE_EVENT_DOCKOFF:
 		dd->chargerstatus = (action == DISPLAY_WAKE_EVENT_DOCKON);
 		pr_info("%s: dd->chargerstatus is %d\n",
 			__func__, dd->chargerstatus);
 		break;
 	}

 	return NOTIFY_OK;
 }
 #endif

 static void m4als_work_func(struct work_struct *work)
 {
 	int err = 0;
 	struct m4als_driver_data *dd = container_of(work,
 						    struct m4als_driver_data,
 						    m4als_work.work);
 	int size = 0;
 	uint16_t luminosity = 0;

 	mutex_lock(&(dd->mutex));

 	size = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL);
 	if (size < 0) {
 		m4als_err("%s: Reading from invalid register %d.\n",
 			  __func__, size);
 		err = size;
 		goto m4als_isr_fail;
 	}

 	err = m4sensorhub_reg_read(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL,
 		(char *)&luminosity);
 	if (err < 0) {
 		m4als_err("%s: Failed to read luminosity data.\n", __func__);
 		goto m4als_isr_fail;
 	} else if (err != size) {
 		m4als_err("%s: Read %d bytes instead of %d.\n",
 			  __func__, err, size);
 		goto m4als_isr_fail;
 	}

 	dd->luminosity = luminosity;

 #ifdef CONFIG_ALS_WHILE_CHARGING
 	if (dd->chargerstatus == true) {
 		als_notify_subscriber(luminosity);
 	} else {
 		input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
 		input_sync(dd->indev);
 	}
 #else
 		input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
 		input_sync(dd->indev);
 #endif

 	if (dd->samplerate > 0)
 		queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
 				      msecs_to_jiffies(dd->samplerate));

 m4als_isr_fail:
 	if (err < 0)
 		m4als_err("%s: Failed with error code %d.\n", __func__, err);

 	mutex_unlock(&(dd->mutex));

 	return;
 }

 static int m4als_set_samplerate(struct m4als_driver_data *dd, int16_t rate)
 {
 	int err = 0;
 	int size = 0;

 #ifdef CONFIG_ALS_WHILE_CHARGING
 	if (rate == -1 && dd->chargerstatus == true) {
 		rate = ALS_SAMPLERATE_WHILE_DOCKED * 1000;
 	}
 #endif

 	if ((rate >= 0) && (rate <= dd->fastest_rate))
 		rate = dd->fastest_rate;

 	/* This variabled is to be always updated ireespective of the
 	   transaction status */
 	dd->latest_samplerate = rate;

 	if (rate == dd->samplerate)
 		goto m4als_set_samplerate_fail;

 	size = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE);
 	if (size < 0) {
 		m4als_err("%s: Writing to invalid register %d.\n",
 			  __func__, size);
 		err = size;
 		goto m4als_set_samplerate_fail;
 	}

 	err = m4sensorhub_reg_write(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE,
 		(char *)&rate, m4sh_no_mask);
 	if (err < 0) {
 		m4als_err("%s: Failed to set sample rate.\n", __func__);
 		goto m4als_set_samplerate_fail;
 	} else if (err != size) {
 		m4als_err("%s: Wrote %d bytes instead of %d.\n",
 			  __func__, err, size);
 		err = -EBADE;
 		goto m4als_set_samplerate_fail;
 	}
 	cancel_delayed_work(&(dd->m4als_work));
 	dd->samplerate = rate;
 	if (dd->samplerate > 0) {
 		queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
 				      msecs_to_jiffies(rate));
 #ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
 		als_notify_subscriber(ALS_ENABLED);
 #endif
 	} else {
 #ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
 		als_notify_subscriber(ALS_DISABLED);
 #endif
 	}

 m4als_set_samplerate_fail:
 	return err;
 }

 static ssize_t m4als_setrate_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct m4als_driver_data *dd = dev_get_drvdata(dev);

 	return sprintf(buf, "Current rate: %hd\n", dd->samplerate);
 }
 static ssize_t m4als_setrate_store(struct device *dev,
 		struct device_attribute *attr, const char *buf, size_t size)
 {
 	int err = 0;
 	struct m4als_driver_data *dd = dev_get_drvdata(dev);
 	int value = 0;
 	int regsize = 0;
 	uint16_t luminosity = 0;

 	mutex_lock(&(dd->mutex));

 	err = kstrtoint(buf, 10, &value);
 	if (err < 0) {
 		m4als_err("%s: Failed to convert value.\n", __func__);
 		goto m4als_enable_store_exit;
 	}

 	if ((value < -1) || (value > 32767)) {
 		m4als_err("%s: Invalid sample rate requested = %d\n",
 			  __func__, value);
 		err = -EOVERFLOW;
 		goto m4als_enable_store_exit;
 	}

 	err = m4als_set_samplerate(dd, value);
 	if (err < 0) {
 		m4als_err("%s: Failed to set sample rate.\n", __func__);
 		goto m4als_enable_store_exit;
 	}

 	/* Read and send raw value for gesture wakeup */
 	msleep(120);
 	regsize = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL);
 	if (regsize < 0) {
 		m4als_err("%s: Reading from invalid register %d.\n",
 			  __func__, regsize);
 		err = regsize;
 		goto m4als_enable_store_exit;
 	}

 	err = m4sensorhub_reg_read(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL,
 		(char *)&luminosity);
 	if (err < 0) {
 		m4als_err("%s: Failed to read luminosity data.\n", __func__);
 		goto m4als_enable_store_exit;
 	} else if (err != regsize) {
 		m4als_err("%s: Read %d bytes instead of %d.\n",
 			  __func__, err, regsize);
 		goto m4als_enable_store_exit;
 	}

 	dd->luminosity = luminosity;

 	input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
 	input_sync(dd->indev);

 m4als_enable_store_exit:
 	if (err < 0)
 		m4als_err("%s: Failed with error code %d.\n", __func__, err);

 	mutex_unlock(&(dd->mutex));

 	return size;
 }
 static DEVICE_ATTR(als_setrate, S_IRUSR | S_IWUSR,
 		m4als_setrate_show, m4als_setrate_store);

 static ssize_t m4als_luminosity_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct m4als_driver_data *dd = dev_get_drvdata(dev);

 	return sprintf(buf, "Current luminosity: %hd\n", dd->luminosity);
 }
 static DEVICE_ATTR(luminosity, S_IRUGO, m4als_luminosity_show, NULL);

 static int m4als_create_sysfs(struct m4als_driver_data *dd)
 {
 	int err = 0;

 	err = device_create_file(&(dd->pdev->dev), &dev_attr_als_setrate);
 	if (err < 0) {
 		m4als_err("%s: Failed to create als_setrate %s %d.\n",
 			  __func__, "with error", err);
 		goto m4als_create_sysfs_als_exit;
 	}

 	err = device_create_file(&(dd->pdev->dev), &dev_attr_luminosity);
 	if (err < 0) {
 		m4als_err("%s: Failed to create luminosity %s %d.\n",
 			  __func__, "with error", err);
 		goto m4als_create_sysfs_luminosity_fail;
 	}

 	goto m4als_create_sysfs_als_exit;

 m4als_create_sysfs_luminosity_fail:
 	device_remove_file(&(dd->pdev->dev), &dev_attr_als_setrate);
 m4als_create_sysfs_als_exit:
 	return err;
 }

 static int m4als_remove_sysfs(struct m4als_driver_data *dd)
 {
 	int err = 0;

 	device_remove_file(&(dd->pdev->dev), &dev_attr_als_setrate);
 	device_remove_file(&(dd->pdev->dev), &dev_attr_luminosity);

 	return err;
 }

 static int m4als_create_m4eventdev(struct m4als_driver_data *dd)
 {
 	int err = 0;

 	dd->indev = input_allocate_device();
 	if (dd->indev == NULL) {
 		m4als_err("%s: Failed to allocate input device.\n",
 			  __func__);
 		err = -ENODATA;
 		goto m4als_create_m4eventdev_fail;
 	}

 	dd->indev->name = M4ALS_DRIVER_NAME;
 	input_set_drvdata(dd->indev, dd);
 	input_set_capability(dd->indev, EV_MSC, MSC_RAW);

 	err = input_register_device(dd->indev);
 	if (err < 0) {
 		m4als_err("%s: Failed to register input device.\n",
 			  __func__);
 		input_free_device(dd->indev);
 		dd->indev = NULL;
 		goto m4als_create_m4eventdev_fail;
 	}

 m4als_create_m4eventdev_fail:
 	return err;
 }

 static void m4als_panic_restore(struct m4sensorhub_data *m4sensorhub,
 				void *data)
 {
 	int size, err;
 	struct m4als_driver_data *dd = (struct m4als_driver_data *)data;

 	if (dd == NULL) {
 		m4als_err("%s: Driver data is null, unable to restore\n",
 			  __func__);
 		return;
 	}

 	mutex_lock(&(dd->mutex));

 	size = m4sensorhub_reg_getsize(dd->m4,
 				       M4SH_REG_LIGHTSENSOR_SAMPLERATE);
 	err = m4sensorhub_reg_write(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE,
 				   (char *)&dd->samplerate, m4sh_no_mask);
 	if (err < 0) {
 		m4als_err("%s: Failed to set sample rate.\n", __func__);
 	} else if (err != size) {
 		m4als_err("%s: Wrote %d bytes instead of %d.\n",
 			  __func__, err, size);
 	}
 	cancel_delayed_work(&(dd->m4als_work));
 	if (dd->samplerate > 0)
 		queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
 				      msecs_to_jiffies(dd->samplerate));
 	mutex_unlock(&(dd->mutex));
 }

 static int m4als_driver_init(struct init_calldata *p_arg)
 {
 	struct m4als_driver_data *dd = p_arg->p_data;
 	int err = 0;

 	mutex_lock(&(dd->mutex));

 	err = m4als_create_m4eventdev(dd);
 	if (err < 0) {
 		m4als_err("%s: Failed to create M4 event device.\n", __func__);
 		goto m4als_driver_init_fail;
 	}

 	INIT_DELAYED_WORK(&(dd->m4als_work), m4als_work_func);

 	err = m4sensorhub_panic_register(dd->m4, PANICHDL_ALS_RESTORE,
 					 m4als_panic_restore, dd);
 	if (err < 0)
 		KDEBUG(M4SH_ERROR, "Als panic callback register failed\n");
 	goto m4als_driver_init_exit;

 m4als_driver_init_fail:
 	m4als_err("%s: Init failed with error code %d.\n", __func__, err);
 m4als_driver_init_exit:
 	mutex_unlock(&(dd->mutex));
 	return err;
 }

 static int m4als_probe(struct platform_device *pdev)
 {
 	struct m4als_driver_data *dd = NULL;
 	int err = 0;

 	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
 	if (dd == NULL) {
 		m4als_err("%s: Failed to allocate driver data.\n", __func__);
 		err = -ENOMEM;
 		goto m4als_probe_fail_nodd;
 	}

 	dd->pdev = pdev;
 	mutex_init(&(dd->mutex));
 	platform_set_drvdata(pdev, dd);
 	dd->samplerate = -1; /* We always start disabled */
 	dd->latest_samplerate = dd->samplerate;
 	dd->fastest_rate = 80; /* in milli secs */

 	dd->m4 = m4sensorhub_client_get_drvdata();
 	if (dd->m4 == NULL) {
 		m4als_err("%s: M4 sensor data is NULL.\n", __func__);
 		err = -ENODATA;
 		goto m4als_probe_fail;
 	}

 	err = m4sensorhub_register_initcall(m4als_driver_init, dd);
 	if (err < 0) {
 		m4als_err("%s: Failed to register initcall.\n", __func__);
 		goto m4als_probe_fail;
 	}

 	err = m4als_create_sysfs(dd);
 	if (err < 0) {
 		m4als_err("%s: Failed to create sysfs.\n", __func__);
 		goto m4als_driver_init_sysfs_fail;
 	}

 #ifdef CONFIG_ALS_WHILE_CHARGING
 	dd->chargerstatus = false;
 	dd->charger_nb.notifier_call = charger_notify;
 	wakeup_source_register_notify(&dd->charger_nb);
 #endif

 	return 0;

 m4als_driver_init_sysfs_fail:
 	m4sensorhub_unregister_initcall(m4als_driver_init);
 m4als_probe_fail:
 	mutex_destroy(&(dd->mutex));
 	kfree(dd);
 m4als_probe_fail_nodd:
 	m4als_err("%s: Probe failed with error code %d.\n", __func__, err);
 	return err;
 }

 static int __exit m4als_remove(struct platform_device *pdev)
 {
 	struct m4als_driver_data *dd = platform_get_drvdata(pdev);

 	mutex_lock(&(dd->mutex));
 	cancel_delayed_work(&(dd->m4als_work));
 	m4als_remove_sysfs(dd);
 	m4sensorhub_unregister_initcall(m4als_driver_init);
 #ifdef CONFIG_ALS_WHILE_CHARGING
 	wakeup_source_unregister_notify(&dd->charger_nb);
 #endif
 	if (dd->indev != NULL)
 		input_unregister_device(dd->indev);
 	mutex_destroy(&(dd->mutex));
 	kfree(dd);

 	return 0;
 }

 static int m4als_suspend(struct platform_device *pdev, pm_message_t state)
 {
 	struct m4als_driver_data *dd = platform_get_drvdata(pdev);
 	if (m4als_set_samplerate(dd, dd->latest_samplerate) < 0)
 		m4als_err("%s: setrate retry failed\n", __func__);
 	return 0;
 }

 static struct of_device_id m4als_match_tbl[] = {
 	{ .compatible = "mot,m4als" },
 	{},
 };

 static struct platform_driver m4als_driver = {
 	.probe		= m4als_probe,
 	.remove		= __exit_p(m4als_remove),
 	.shutdown	= NULL,
 	.suspend        = m4als_suspend,
 	.resume         = NULL,
 	.driver		= {
 		.name	= M4ALS_DRIVER_NAME,
 		.owner	= THIS_MODULE,
 		.of_match_table = of_match_ptr(m4als_match_tbl),
 	},
 };

 static int __init m4als_init(void)
 {
 	return platform_driver_register(&m4als_driver);
 }

 static void __exit m4als_exit(void)
 {
 	platform_driver_unregister(&m4als_driver);
 }

 module_init(m4als_init);
 module_exit(m4als_exit);

 MODULE_ALIAS("platform:m4als");
 MODULE_DESCRIPTION("M4 Sensor Hub Ambient Light client driver");
 MODULE_AUTHOR("Motorola");
 MODULE_LICENSE("GPL");
	/*
	* Copyright (C) 2012-2014 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/platform_device.h>
	#include <linux/fs.h>
	#include <linux/m4sensorhub.h>
	#include <linux/input.h>
	#include <linux/slab.h>
	#include <linux/delay.h>
	#ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
	#include <linux/notifier.h>
	#include <linux/als_notify.h>
	#ifdef CONFIG_ALS_WHILE_CHARGING
	#include <linux/wakeup_source_notify.h>
	#endif /* CONFIG_ALS_WHILE_CHARGING */
	#endif

	#define m4als_err(format, args...) KDEBUG(M4SH_ERROR, format, ## args)

	#define M4ALS_DRIVER_NAME "m4sensorhub_als"

	#define M4ALS_IRQ_ENABLED_BIT 0
	#define ALS_SAMPLERATE_WHILE_DOCKED 10 /* in seconds */

	struct m4als_driver_data {
	struct platform_device *pdev;
	struct m4sensorhub_data *m4;
	struct mutex mutex; /* controls driver entry points */
	struct input_dev *indev;
	struct delayed_work m4als_work;

	/* Beware of changing this from uint16, check als_notify.h
	since notifier uses values outside luminosity range for
	conveying enable/disable status */
	uint16_t luminosity;
	int16_t samplerate;
	int16_t latest_samplerate;
	int16_t fastest_rate;
	uint16_t status;
	#ifdef CONFIG_ALS_WHILE_CHARGING
	struct notifier_block charger_nb;
	bool chargerstatus;
	#endif
	};

	#ifdef CONFIG_ALS_WHILE_CHARGING
	static int charger_notify(struct notifier_block *self,
	unsigned long action, void *dev)
	{
	struct m4als_driver_data *dd =
	container_of(self, struct m4als_driver_data, charger_nb);
	switch (action) {
	case DISPLAY_WAKE_EVENT_DOCKON:
	case DISPLAY_WAKE_EVENT_DOCKOFF:
	dd->chargerstatus = (action == DISPLAY_WAKE_EVENT_DOCKON);
	pr_info("%s: dd->chargerstatus is %d\n",
	__func__, dd->chargerstatus);
	break;
	}

	return NOTIFY_OK;
	}
	#endif

	static void m4als_work_func(struct work_struct *work)
	{
	int err = 0;
	struct m4als_driver_data *dd = container_of(work,
	struct m4als_driver_data,
	m4als_work.work);
	int size = 0;
	uint16_t luminosity = 0;

	mutex_lock(&(dd->mutex));

	size = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL);
	if (size < 0) {
	m4als_err("%s: Reading from invalid register %d.\n",
	__func__, size);
	err = size;
	goto m4als_isr_fail;
	}

	err = m4sensorhub_reg_read(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL,
	(char *)&luminosity);
	if (err < 0) {
	m4als_err("%s: Failed to read luminosity data.\n", __func__);
	goto m4als_isr_fail;
	} else if (err != size) {
	m4als_err("%s: Read %d bytes instead of %d.\n",
	__func__, err, size);
	goto m4als_isr_fail;
	}

	dd->luminosity = luminosity;

	#ifdef CONFIG_ALS_WHILE_CHARGING
	if (dd->chargerstatus == true) {
	als_notify_subscriber(luminosity);
	} else {
	input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
	input_sync(dd->indev);
	}
	#else
	input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
	input_sync(dd->indev);
	#endif

	if (dd->samplerate > 0)
	queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
	msecs_to_jiffies(dd->samplerate));

	m4als_isr_fail:
	if (err < 0)
	m4als_err("%s: Failed with error code %d.\n", __func__, err);

	mutex_unlock(&(dd->mutex));

	return;
	}

	static int m4als_set_samplerate(struct m4als_driver_data *dd, int16_t rate)
	{
	int err = 0;
	int size = 0;

	#ifdef CONFIG_ALS_WHILE_CHARGING
	if (rate == -1 && dd->chargerstatus == true) {
	rate = ALS_SAMPLERATE_WHILE_DOCKED * 1000;
	}
	#endif

	if ((rate >= 0) && (rate <= dd->fastest_rate))
	rate = dd->fastest_rate;

	/* This variabled is to be always updated ireespective of the
	transaction status */
	dd->latest_samplerate = rate;

	if (rate == dd->samplerate)
	goto m4als_set_samplerate_fail;

	size = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE);
	if (size < 0) {
	m4als_err("%s: Writing to invalid register %d.\n",
	__func__, size);
	err = size;
	goto m4als_set_samplerate_fail;
	}

	err = m4sensorhub_reg_write(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE,
	(char *)&rate, m4sh_no_mask);
	if (err < 0) {
	m4als_err("%s: Failed to set sample rate.\n", __func__);
	goto m4als_set_samplerate_fail;
	} else if (err != size) {
	m4als_err("%s: Wrote %d bytes instead of %d.\n",
	__func__, err, size);
	err = -EBADE;
	goto m4als_set_samplerate_fail;
	}
	cancel_delayed_work(&(dd->m4als_work));
	dd->samplerate = rate;
	if (dd->samplerate > 0) {
	queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
	msecs_to_jiffies(rate));
	#ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
	als_notify_subscriber(ALS_ENABLED);
	#endif
	} else {
	#ifdef CONFIG_WAKEUP_SOURCE_NOTIFY
	als_notify_subscriber(ALS_DISABLED);
	#endif
	}

	m4als_set_samplerate_fail:
	return err;
	}

	static ssize_t m4als_setrate_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct m4als_driver_data *dd = dev_get_drvdata(dev);

	return sprintf(buf, "Current rate: %hd\n", dd->samplerate);
	}
	static ssize_t m4als_setrate_store(struct device *dev,
	struct device_attribute attr, const char buf, size_t size)
	{
	int err = 0;
	struct m4als_driver_data *dd = dev_get_drvdata(dev);
	int value = 0;
	int regsize = 0;
	uint16_t luminosity = 0;

	mutex_lock(&(dd->mutex));

	err = kstrtoint(buf, 10, &value);
	if (err < 0) {
	m4als_err("%s: Failed to convert value.\n", __func__);
	goto m4als_enable_store_exit;
	}

	if ((value < -1) \|\| (value > 32767)) {
	m4als_err("%s: Invalid sample rate requested = %d\n",
	__func__, value);
	err = -EOVERFLOW;
	goto m4als_enable_store_exit;
	}

	err = m4als_set_samplerate(dd, value);
	if (err < 0) {
	m4als_err("%s: Failed to set sample rate.\n", __func__);
	goto m4als_enable_store_exit;
	}

	/* Read and send raw value for gesture wakeup */
	msleep(120);
	regsize = m4sensorhub_reg_getsize(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL);
	if (regsize < 0) {
	m4als_err("%s: Reading from invalid register %d.\n",
	__func__, regsize);
	err = regsize;
	goto m4als_enable_store_exit;
	}

	err = m4sensorhub_reg_read(dd->m4, M4SH_REG_LIGHTSENSOR_SIGNAL,
	(char *)&luminosity);
	if (err < 0) {
	m4als_err("%s: Failed to read luminosity data.\n", __func__);
	goto m4als_enable_store_exit;
	} else if (err != regsize) {
	m4als_err("%s: Read %d bytes instead of %d.\n",
	__func__, err, regsize);
	goto m4als_enable_store_exit;
	}

	dd->luminosity = luminosity;

	input_event(dd->indev, EV_MSC, MSC_RAW, dd->luminosity);
	input_sync(dd->indev);

	m4als_enable_store_exit:
	if (err < 0)
	m4als_err("%s: Failed with error code %d.\n", __func__, err);

	mutex_unlock(&(dd->mutex));

	return size;
	}
	static DEVICE_ATTR(als_setrate, S_IRUSR \| S_IWUSR,
	m4als_setrate_show, m4als_setrate_store);

	static ssize_t m4als_luminosity_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct m4als_driver_data *dd = dev_get_drvdata(dev);

	return sprintf(buf, "Current luminosity: %hd\n", dd->luminosity);
	}
	static DEVICE_ATTR(luminosity, S_IRUGO, m4als_luminosity_show, NULL);

	static int m4als_create_sysfs(struct m4als_driver_data *dd)
	{
	int err = 0;

	err = device_create_file(&(dd->pdev->dev), &dev_attr_als_setrate);
	if (err < 0) {
	m4als_err("%s: Failed to create als_setrate %s %d.\n",
	__func__, "with error", err);
	goto m4als_create_sysfs_als_exit;
	}

	err = device_create_file(&(dd->pdev->dev), &dev_attr_luminosity);
	if (err < 0) {
	m4als_err("%s: Failed to create luminosity %s %d.\n",
	__func__, "with error", err);
	goto m4als_create_sysfs_luminosity_fail;
	}

	goto m4als_create_sysfs_als_exit;

	m4als_create_sysfs_luminosity_fail:
	device_remove_file(&(dd->pdev->dev), &dev_attr_als_setrate);
	m4als_create_sysfs_als_exit:
	return err;
	}

	static int m4als_remove_sysfs(struct m4als_driver_data *dd)
	{
	int err = 0;

	device_remove_file(&(dd->pdev->dev), &dev_attr_als_setrate);
	device_remove_file(&(dd->pdev->dev), &dev_attr_luminosity);

	return err;
	}

	static int m4als_create_m4eventdev(struct m4als_driver_data *dd)
	{
	int err = 0;

	dd->indev = input_allocate_device();
	if (dd->indev == NULL) {
	m4als_err("%s: Failed to allocate input device.\n",
	__func__);
	err = -ENODATA;
	goto m4als_create_m4eventdev_fail;
	}

	dd->indev->name = M4ALS_DRIVER_NAME;
	input_set_drvdata(dd->indev, dd);
	input_set_capability(dd->indev, EV_MSC, MSC_RAW);

	err = input_register_device(dd->indev);
	if (err < 0) {
	m4als_err("%s: Failed to register input device.\n",
	__func__);
	input_free_device(dd->indev);
	dd->indev = NULL;
	goto m4als_create_m4eventdev_fail;
	}

	m4als_create_m4eventdev_fail:
	return err;
	}

	static void m4als_panic_restore(struct m4sensorhub_data *m4sensorhub,
	void *data)
	{
	int size, err;
	struct m4als_driver_data dd = (struct m4als_driver_data )data;

	if (dd == NULL) {
	m4als_err("%s: Driver data is null, unable to restore\n",
	__func__);
	return;
	}

	mutex_lock(&(dd->mutex));

	size = m4sensorhub_reg_getsize(dd->m4,
	M4SH_REG_LIGHTSENSOR_SAMPLERATE);
	err = m4sensorhub_reg_write(dd->m4, M4SH_REG_LIGHTSENSOR_SAMPLERATE,
	(char *)&dd->samplerate, m4sh_no_mask);
	if (err < 0) {
	m4als_err("%s: Failed to set sample rate.\n", __func__);
	} else if (err != size) {
	m4als_err("%s: Wrote %d bytes instead of %d.\n",
	__func__, err, size);
	}
	cancel_delayed_work(&(dd->m4als_work));
	if (dd->samplerate > 0)
	queue_delayed_work(system_freezable_wq, &(dd->m4als_work),
	msecs_to_jiffies(dd->samplerate));
	mutex_unlock(&(dd->mutex));
	}

	static int m4als_driver_init(struct init_calldata *p_arg)
	{
	struct m4als_driver_data *dd = p_arg->p_data;
	int err = 0;

	mutex_lock(&(dd->mutex));

	err = m4als_create_m4eventdev(dd);
	if (err < 0) {
	m4als_err("%s: Failed to create M4 event device.\n", __func__);
	goto m4als_driver_init_fail;
	}

	INIT_DELAYED_WORK(&(dd->m4als_work), m4als_work_func);

	err = m4sensorhub_panic_register(dd->m4, PANICHDL_ALS_RESTORE,
	m4als_panic_restore, dd);
	if (err < 0)
	KDEBUG(M4SH_ERROR, "Als panic callback register failed\n");
	goto m4als_driver_init_exit;

	m4als_driver_init_fail:
	m4als_err("%s: Init failed with error code %d.\n", __func__, err);
	m4als_driver_init_exit:
	mutex_unlock(&(dd->mutex));
	return err;
	}

	static int m4als_probe(struct platform_device *pdev)
	{
	struct m4als_driver_data *dd = NULL;
	int err = 0;

	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
	if (dd == NULL) {
	m4als_err("%s: Failed to allocate driver data.\n", __func__);
	err = -ENOMEM;
	goto m4als_probe_fail_nodd;
	}

	dd->pdev = pdev;
	mutex_init(&(dd->mutex));
	platform_set_drvdata(pdev, dd);
	dd->samplerate = -1; /* We always start disabled */
	dd->latest_samplerate = dd->samplerate;
	dd->fastest_rate = 80; /* in milli secs */

	dd->m4 = m4sensorhub_client_get_drvdata();
	if (dd->m4 == NULL) {
	m4als_err("%s: M4 sensor data is NULL.\n", __func__);
	err = -ENODATA;
	goto m4als_probe_fail;
	}

	err = m4sensorhub_register_initcall(m4als_driver_init, dd);
	if (err < 0) {
	m4als_err("%s: Failed to register initcall.\n", __func__);
	goto m4als_probe_fail;
	}

	err = m4als_create_sysfs(dd);
	if (err < 0) {
	m4als_err("%s: Failed to create sysfs.\n", __func__);
	goto m4als_driver_init_sysfs_fail;
	}

	#ifdef CONFIG_ALS_WHILE_CHARGING
	dd->chargerstatus = false;
	dd->charger_nb.notifier_call = charger_notify;
	wakeup_source_register_notify(&dd->charger_nb);
	#endif

	return 0;

	m4als_driver_init_sysfs_fail:
	m4sensorhub_unregister_initcall(m4als_driver_init);
	m4als_probe_fail:
	mutex_destroy(&(dd->mutex));
	kfree(dd);
	m4als_probe_fail_nodd:
	m4als_err("%s: Probe failed with error code %d.\n", __func__, err);
	return err;
	}

	static int __exit m4als_remove(struct platform_device *pdev)
	{
	struct m4als_driver_data *dd = platform_get_drvdata(pdev);

	mutex_lock(&(dd->mutex));
	cancel_delayed_work(&(dd->m4als_work));
	m4als_remove_sysfs(dd);
	m4sensorhub_unregister_initcall(m4als_driver_init);
	#ifdef CONFIG_ALS_WHILE_CHARGING
	wakeup_source_unregister_notify(&dd->charger_nb);
	#endif
	if (dd->indev != NULL)
	input_unregister_device(dd->indev);
	mutex_destroy(&(dd->mutex));
	kfree(dd);

	return 0;
	}

	static int m4als_suspend(struct platform_device *pdev, pm_message_t state)
	{
	struct m4als_driver_data *dd = platform_get_drvdata(pdev);
	if (m4als_set_samplerate(dd, dd->latest_samplerate) < 0)
	m4als_err("%s: setrate retry failed\n", __func__);
	return 0;
	}

	static struct of_device_id m4als_match_tbl[] = {
	{ .compatible = "mot,m4als" },
	{},
	};

	static struct platform_driver m4als_driver = {
	.probe = m4als_probe,
	.remove = __exit_p(m4als_remove),
	.shutdown = NULL,
	.suspend = m4als_suspend,
	.resume = NULL,
	.driver = {
	.name = M4ALS_DRIVER_NAME,
	.owner = THIS_MODULE,
	.of_match_table = of_match_ptr(m4als_match_tbl),
	},
	};

	static int __init m4als_init(void)
	{
	return platform_driver_register(&m4als_driver);
	}

	static void __exit m4als_exit(void)
	{
	platform_driver_unregister(&m4als_driver);
	}

	module_init(m4als_init);
	module_exit(m4als_exit);

	MODULE_ALIAS("platform:m4als");
	MODULE_DESCRIPTION("M4 Sensor Hub Ambient Light client driver");
	MODULE_AUTHOR("Motorola");
	MODULE_LICENSE("GPL");