drivers/motor/isa1000.c - LeafOS-Devices/android_kernel_samsung_universal7904 - Gitiles

 /* drivers/motor/isa1000.c

  * Copyright (C) 2014 Samsung Electronics Co. Ltd. All Rights Reserved.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * 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.
  *
  */

 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/hrtimer.h>
 #include <linux/pwm.h>
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #include <linux/delay.h>
 #include <linux/isa1000.h>
 #include <linux/wakelock.h>
 #include <linux/regulator/consumer.h>

 #include "../staging/android/timed_output.h"

 // #ifdef DEBUG_MOTOR

 #define MAX_INTENSITY		10000

 struct isa1000_ddata {
 	struct isa1000_pdata *pdata;
 	struct pwm_device *pwm;
 	struct regulator *regulator;
 	struct timed_output_dev dev;
 	struct hrtimer timer;
 	struct work_struct work;
 	spinlock_t lock;
 	bool running;
 	u32 intensity;
 	u32 timeout;
 	int duty;
 	int gpio_en;
 };

 static enum hrtimer_restart isa1000_timer_func(struct hrtimer *timer)
 {
 	struct isa1000_ddata *ddata
 		= container_of(timer, struct isa1000_ddata, timer);

 	ddata->timeout = 0;

 	schedule_work(&ddata->work);
 	return HRTIMER_NORESTART;
 }

 static int isa1000_get_time(struct timed_output_dev *dev)
 {
 	struct isa1000_ddata *ddata
 		= container_of(dev, struct  isa1000_ddata, dev);

 	struct hrtimer *timer = &ddata->timer;
 	if (hrtimer_active(timer)) {
 		ktime_t remain = hrtimer_get_remaining(timer);
 		struct timeval t = ktime_to_timeval(remain);
 		return t.tv_sec * 1000 + t.tv_usec / 1000;
 	} else
 		return 0;
 }

 static void isa1000_enable(struct timed_output_dev *dev, int value)
 {
 	struct isa1000_ddata *ddata
 		= container_of(dev, struct isa1000_ddata, dev);
 	struct hrtimer *timer = &ddata->timer;
 	unsigned long flags;
 	cancel_work_sync(&ddata->work);
 	hrtimer_cancel(timer);

 	if (value > ddata->pdata->max_timeout)
 		value = ddata->pdata->max_timeout;
 	spin_lock_irqsave(&ddata->lock, flags);
 	ddata->timeout = value;
 	spin_unlock_irqrestore(&ddata->lock, flags);

 	schedule_work(&ddata->work);
 }

 static void isa1000_pwm_config(struct isa1000_ddata *ddata, int duty)
 {
 #if 0
 	int max_duty = ddata->pdata->duty;
 	int min_duty = ddata->pdata->period - max_duty;

 	/* check the max dury ragne */
 	if (duty > max_duty)
 		duty = max_duty;
 	else if (duty < min_duty)
 		duty = min_duty;
 #endif
 	printk("[VIB] : %s : pwm_duty = %d, pwm_period = %d \n", __func__, duty, ddata->pdata->period);
 	pwm_config(ddata->pwm, duty,
 		ddata->pdata->period);
 }

 static void isa1000_pwm_en(struct isa1000_ddata *ddata, bool en)
 {
 	if (en) {
 		pwm_enable(ddata->pwm);
 		pr_info("[VIB] pwm enable\n");
 	}
 	else {
 		pwm_disable(ddata->pwm);
 		pr_info("[VIB] pwm disable\n");
 	}
 }

 static void isa1000_regulator_en(struct isa1000_ddata *ddata, bool en)
 {
 	int ret;

 	if (!ddata->regulator)
 		return;

 	if (en && !regulator_is_enabled(ddata->regulator)) {
 		ret = regulator_enable(ddata->regulator);
 		pr_info("[VIB] regulator_enable returns %d\n", ret);
 	}
 	else if (!en && regulator_is_enabled(ddata->regulator)) {
 		ret = regulator_disable(ddata->regulator);
 		pr_info("[VIB] regulator_disable returns %d\n", ret);
 	}
 }

 static void isa1000_en(struct isa1000_ddata *ddata, bool en)
 {
 	printk(KERN_DEBUG "[VIB] %s\n", en ? "on" : "off");

 	gpio_direction_output(ddata->pdata->gpio_en, en);

 	if (en)
 		msleep(20);
 }

 static void isa1000_work_func(struct work_struct *work)
 {
 	struct isa1000_ddata *ddata =
 		container_of(work, struct isa1000_ddata, work);
 	struct hrtimer *timer = &ddata->timer;

 	if (ddata->timeout) {
 		ddata->running = true;

 		if (ddata->pdata->gpio_en > 0)
 			isa1000_en(ddata, true);

 		isa1000_pwm_config(ddata, ddata->duty);
 		isa1000_pwm_en(ddata, true);
 		isa1000_regulator_en(ddata, true);
 		hrtimer_start(timer, ns_to_ktime((u64)ddata->timeout * NSEC_PER_MSEC), HRTIMER_MODE_REL);
 	} else {
 		ddata->running = false;
 		isa1000_pwm_en(ddata, false);

 		if (ddata->pdata->gpio_en > 0)
 			isa1000_en(ddata, false);

 		isa1000_regulator_en(ddata, false);
 		hrtimer_cancel(timer);
 	}
 	return;
 }

 static ssize_t intensity_store(struct device *dev,
 	struct device_attribute *devattr, const char *buf, size_t count)
 {
 	struct timed_output_dev *tdev = dev_get_drvdata(dev);
 	struct isa1000_ddata *drvdata
 		= container_of(tdev, struct isa1000_ddata, dev);
 	int duty = drvdata->pdata->period >> 1;
 	int intensity = 0, ret = 0;

 	ret = kstrtoint(buf, 0, &intensity);

 	if (intensity < 0 || MAX_INTENSITY < intensity) {
 		pr_err("out of rage\n");
 		return -EINVAL;
 	}

 	if (MAX_INTENSITY == intensity)
 		duty = drvdata->pdata->duty;
 	else if (0 != intensity) {
 		long long tmp = drvdata->pdata->duty >> 1;

 		tmp *= (intensity / 100);
 		duty += (int)(tmp / 100);
 	}

 	drvdata->intensity = intensity;
 	drvdata->duty = duty;
 	printk("[VIB] : %s : intensity = %d, duty = %d \n",__func__, intensity, duty);
 	return count;
 }

 static ssize_t intensity_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	struct timed_output_dev *tdev = dev_get_drvdata(dev);
 	struct isa1000_ddata *drvdata
 		= container_of(tdev, struct isa1000_ddata, dev);

 	return sprintf(buf, "intensity: %u\n", drvdata->intensity);
 }

 static DEVICE_ATTR(intensity, 0660, intensity_show, intensity_store);

 #ifdef DEBUG_MOTOR
 static ssize_t duty_store(struct device *dev,
 	struct device_attribute *devattr, const char *buf, size_t count)
 {
 	struct timed_output_dev *tdev = dev_get_drvdata(dev);
 	struct isa1000_ddata *drvdata
 		= container_of(tdev, struct isa1000_ddata, dev);
 	int duty = drvdata->pdata->period >> 1;
 	int duty_rate = 0, ret = 0, temp=0;

 	ret = kstrtoint(buf, 0, &duty_rate);

 	if (duty_rate < 0 || duty_rate > 1000) {
 		pr_err("out of rage \n");
 		return -EINVAL;
 	}

 	temp = duty * duty_rate /1000;
 	duty = duty + temp;

 	drvdata->duty = duty;
 	printk("[VIB] : %s : duty_rate = %d, duty = %d, temp = %d \n",__func__, duty_rate, duty, temp);
 	return count;
 }

 static ssize_t duty_show(struct device *dev,
 			struct device_attribute *attr, char *buf)
 {
 	struct timed_output_dev *tdev = dev_get_drvdata(dev);
 	struct isa1000_ddata *drvdata
 		= container_of(tdev, struct isa1000_ddata, dev);


 	int duty = drvdata->pdata->period >> 1;
 	int duty_rate=0;
 	duty_rate = ((drvdata->duty-duty)*1000 / duty);

 	printk("[VIB] : %s : duty = %d, drvdata->duty=%d, duty_rate = %d \n",__func__, duty, drvdata->duty, duty_rate);
 	return sprintf(buf, "current duty rate : %u %% \n", duty_rate);
 }

 static DEVICE_ATTR(duty, 0660, duty_show, duty_store);
 #endif

 static struct isa1000_pdata *
 	isa1000_get_devtree_pdata(struct device *dev)
 {
 	struct device_node *node, *child_node=NULL;
 	struct isa1000_pdata *pdata;
 	const char *dt_status;
 	int ret = 0;

 	node = dev->of_node;
 	if (!node) {
 		ret = -ENODEV;
 		goto err_out;
 	}

 	child_node = of_get_next_child(node, child_node);
 	if (!child_node) {
 		printk("[VIB] failed to get dt node\n");
 		ret = -EINVAL;
 		goto err_out;
 	}

 	if (of_property_read_string(child_node, "status", &dt_status) < 0) {
 		printk("[VIB] isa1000 dt status read fail \n");
 	} else {
 		printk("[VIB] isa1000 dt status : %s \n", dt_status);
 		if (strcmp(dt_status, "okay")) {
 			printk("[VIB] isa1000 dt status is disabled so return error \n");
 			ret = -ENODEV;
 			goto err_out;
 		}
 	}
 	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
 	if (!pdata) {
 		printk("[VIB] failed to alloc\n");
 		ret = -ENOMEM;
 		goto err_out;
 	}

 	of_property_read_u32(child_node, "isa1000,max_timeout", &pdata->max_timeout);
 	of_property_read_u32(child_node, "isa1000,duty", &pdata->duty);
 	of_property_read_u32(child_node, "isa1000,period", &pdata->period);
 	of_property_read_u32(child_node, "isa1000,pwm_id", &pdata->pwm_id);
 	of_property_read_u32(child_node, "isa1000,pwm_use", &pdata->pwm_use);


 	if (of_property_read_string(child_node, "isa1000,regulator_name", &pdata->regulator_name) < 0) {
 		pr_err("%s - get regulator error\n", __func__);
 		pdata->regulator_name = NULL;
 	}

 	pdata->gpio_en = of_get_named_gpio(child_node, "isa1000,gpio_en", 0);

 	if (pdata->gpio_en > 0)
 		gpio_request(pdata->gpio_en, "isa1000,gpio_en");

 	printk("[VIB] max_timeout = %d\n", pdata->max_timeout);
 	printk("[VIB] duty = %d\n", pdata->duty);
 	printk("[VIB] period = %d\n", pdata->period);
 	printk("[VIB] pwm_id = %d\n", pdata->pwm_id);
 	printk("[VIB] gpio_en = %d\n", pdata->gpio_en);
 	printk("[VIB] pwm_use = %d\n", pdata->pwm_use);
 	printk("[VIB] %s : regulator_name = %s \n",__func__, pdata->regulator_name);

 	return pdata;

 err_out:
 	return ERR_PTR(ret);
 }

 static int isa1000_probe(struct platform_device *pdev)
 {
 	struct isa1000_pdata *pdata = dev_get_platdata(&pdev->dev);
 	struct isa1000_ddata *ddata;
 	int ret = 0;

 	if (!pdata) {
 #if defined(CONFIG_OF)
 		pdata = isa1000_get_devtree_pdata(&pdev->dev);
 		if (IS_ERR(pdata)) {
 			printk(KERN_ERR "[VIB] there is no device tree!\n");
 			ret = -ENODEV;
 			goto err_pdata;
 		}
 #else
 		printk(KERN_ERR "[VIB] there is no platform data!\n");
 #endif
 	}

 	ddata = kzalloc(sizeof(*ddata), GFP_KERNEL);
 	if (!ddata) {
 		printk(KERN_ERR "[VIB] failed to alloc\n");
 		ret = -ENOMEM;
 		goto err_alloc;
 	}

 	hrtimer_init(&ddata->timer, CLOCK_MONOTONIC,
 			HRTIMER_MODE_REL);
 	spin_lock_init(&ddata->lock);
 	INIT_WORK(&ddata->work, isa1000_work_func);

 	ddata->pdata = pdata;
 	ddata->timer.function = isa1000_timer_func;
 	ddata->pwm = pwm_request(ddata->pdata->pwm_id, "vibrator");
 	if (IS_ERR(ddata->pwm)) {
 		printk(KERN_ERR "[VIB] failed to request pwm\n");
 		ret = -EFAULT;
 		goto err_pwm_request;
 	}


 	if (ddata->pdata->regulator_name) {
 		ddata->regulator = regulator_get(NULL, ddata->pdata->regulator_name);
 		if (IS_ERR(ddata->regulator)) {
 			ret = -EFAULT;
 			pr_err("[VIB] Failed to get vmoter regulator, err num: %d\n", ret);
 			goto err_regulator_get;
 		}
 	} else
 		ddata->regulator = NULL;

 	ddata->dev.name = "vibrator";
 	ddata->dev.get_time = isa1000_get_time;
 	ddata->dev.enable = isa1000_enable;

 	ret = timed_output_dev_register(&ddata->dev);
 	if (ret < 0) {
 		printk(KERN_ERR "[VIB] failed to register timed output\n");
 		goto err_dev_reg;
 	}

 	if(ddata->pdata->pwm_use)
 	{
 		ret = sysfs_create_file(&ddata->dev.dev->kobj, &dev_attr_intensity.attr);
 		if (ret < 0) {
 			pr_err("Failed to register intensity sysfs : %d\n", ret);
 			goto err_dev_reg;
 		}
 #ifdef DEBUG_MOTOR
 		ret = sysfs_create_file(&ddata->dev.dev->kobj, &dev_attr_duty.attr);
 		if (ret < 0) {
 			pr_err("Failed to register duty sysfs : %d\n", ret);
 			goto err_dev_reg;
 		}
 #endif
 	}

 	platform_set_drvdata(pdev, ddata);

 	return ret;

 err_dev_reg:
 	if (!ddata->regulator)
 		regulator_put(ddata->regulator);
 err_regulator_get:
 	pwm_free(ddata->pwm);
 err_pwm_request:
 	kfree(ddata);
 err_alloc:
 err_pdata:
 	return ret;
 }

 static int isa1000_remove(struct platform_device *pdev)
 {
 	struct isa1000_ddata *ddata = platform_get_drvdata(pdev);
 	if (!ddata->regulator)
 		regulator_put(ddata->regulator);
 	pwm_free(ddata->pwm);
 	timed_output_dev_unregister(&ddata->dev);
 	kfree(ddata);
 	return 0;
 }

 static int isa1000_suspend(struct platform_device *pdev,
 			pm_message_t state)
 {
 	struct isa1000_ddata *ddata = platform_get_drvdata(pdev);

 	isa1000_regulator_en(ddata, false);
 	isa1000_pwm_en(ddata, false);

 	if (ddata->pdata->gpio_en > 0)
 		isa1000_en(ddata, false);

 	return 0;
 }

 static int isa1000_resume(struct platform_device *pdev)
 {
 	return 0;
 }

 #if defined(CONFIG_OF)
 static struct of_device_id isa1000_dt_ids[] = {
 	{ .compatible = "isa1000" },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, isa1000_dt_ids);
 #endif /* CONFIG_OF */

 static struct platform_driver isa1000_driver = {
 	.probe		= isa1000_probe,
 	.remove		= isa1000_remove,
 	.suspend	= isa1000_suspend,
 	.resume		= isa1000_resume,
 	.driver = {
 		.name	= "isa1000",
 		.owner	= THIS_MODULE,
 		.of_match_table	= of_match_ptr(isa1000_dt_ids),
 	},
 };

 static int __init isa1000_init(void)
 {
 	return platform_driver_register(&isa1000_driver);
 }
 module_init(isa1000_init);

 static void __exit isa1000_exit(void)
 {
 	platform_driver_unregister(&isa1000_driver);
 }
 module_exit(isa1000_exit);

 MODULE_AUTHOR("Samsung Electronics");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("isa1000 vibrator driver");
	/* drivers/motor/isa1000.c

	* Copyright (C) 2014 Samsung Electronics Co. Ltd. All Rights Reserved.
	*
	* This software is licensed under the terms of the GNU General Public
	* License version 2, as published by the Free Software Foundation, and
	* may be copied, distributed, and modified under those terms.
	*
	* 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.
	*
	*/

	#include <linux/module.h>
	#include <linux/kernel.h>
	#include <linux/hrtimer.h>
	#include <linux/pwm.h>
	#include <linux/platform_device.h>
	#include <linux/err.h>
	#include <linux/slab.h>
	#include <linux/clk.h>
	#include <linux/gpio.h>
	#include <linux/of_gpio.h>
	#include <linux/delay.h>
	#include <linux/isa1000.h>
	#include <linux/wakelock.h>
	#include <linux/regulator/consumer.h>

	#include "../staging/android/timed_output.h"

	// #ifdef DEBUG_MOTOR

	#define MAX_INTENSITY 10000

	struct isa1000_ddata {
	struct isa1000_pdata *pdata;
	struct pwm_device *pwm;
	struct regulator *regulator;
	struct timed_output_dev dev;
	struct hrtimer timer;
	struct work_struct work;
	spinlock_t lock;
	bool running;
	u32 intensity;
	u32 timeout;
	int duty;
	int gpio_en;
	};

	static enum hrtimer_restart isa1000_timer_func(struct hrtimer *timer)
	{
	struct isa1000_ddata *ddata
	= container_of(timer, struct isa1000_ddata, timer);

	ddata->timeout = 0;

	schedule_work(&ddata->work);
	return HRTIMER_NORESTART;
	}

	static int isa1000_get_time(struct timed_output_dev *dev)
	{
	struct isa1000_ddata *ddata
	= container_of(dev, struct isa1000_ddata, dev);

	struct hrtimer *timer = &ddata->timer;
	if (hrtimer_active(timer)) {
	ktime_t remain = hrtimer_get_remaining(timer);
	struct timeval t = ktime_to_timeval(remain);
	return t.tv_sec * 1000 + t.tv_usec / 1000;
	} else
	return 0;
	}

	static void isa1000_enable(struct timed_output_dev *dev, int value)
	{
	struct isa1000_ddata *ddata
	= container_of(dev, struct isa1000_ddata, dev);
	struct hrtimer *timer = &ddata->timer;
	unsigned long flags;
	cancel_work_sync(&ddata->work);
	hrtimer_cancel(timer);

	if (value > ddata->pdata->max_timeout)
	value = ddata->pdata->max_timeout;
	spin_lock_irqsave(&ddata->lock, flags);
	ddata->timeout = value;
	spin_unlock_irqrestore(&ddata->lock, flags);

	schedule_work(&ddata->work);
	}

	static void isa1000_pwm_config(struct isa1000_ddata *ddata, int duty)
	{
	#if 0
	int max_duty = ddata->pdata->duty;
	int min_duty = ddata->pdata->period - max_duty;

	/* check the max dury ragne */
	if (duty > max_duty)
	duty = max_duty;
	else if (duty < min_duty)
	duty = min_duty;
	#endif
	printk("[VIB] : %s : pwm_duty = %d, pwm_period = %d \n", __func__, duty, ddata->pdata->period);
	pwm_config(ddata->pwm, duty,
	ddata->pdata->period);
	}

	static void isa1000_pwm_en(struct isa1000_ddata *ddata, bool en)
	{
	if (en) {
	pwm_enable(ddata->pwm);
	pr_info("[VIB] pwm enable\n");
	}
	else {
	pwm_disable(ddata->pwm);
	pr_info("[VIB] pwm disable\n");
	}
	}

	static void isa1000_regulator_en(struct isa1000_ddata *ddata, bool en)
	{
	int ret;

	if (!ddata->regulator)
	return;

	if (en && !regulator_is_enabled(ddata->regulator)) {
	ret = regulator_enable(ddata->regulator);
	pr_info("[VIB] regulator_enable returns %d\n", ret);
	}
	else if (!en && regulator_is_enabled(ddata->regulator)) {
	ret = regulator_disable(ddata->regulator);
	pr_info("[VIB] regulator_disable returns %d\n", ret);
	}
	}

	static void isa1000_en(struct isa1000_ddata *ddata, bool en)
	{
	printk(KERN_DEBUG "[VIB] %s\n", en ? "on" : "off");

	gpio_direction_output(ddata->pdata->gpio_en, en);

	if (en)
	msleep(20);
	}

	static void isa1000_work_func(struct work_struct *work)
	{
	struct isa1000_ddata *ddata =
	container_of(work, struct isa1000_ddata, work);
	struct hrtimer *timer = &ddata->timer;

	if (ddata->timeout) {
	ddata->running = true;

	if (ddata->pdata->gpio_en > 0)
	isa1000_en(ddata, true);

	isa1000_pwm_config(ddata, ddata->duty);
	isa1000_pwm_en(ddata, true);
	isa1000_regulator_en(ddata, true);
	hrtimer_start(timer, ns_to_ktime((u64)ddata->timeout * NSEC_PER_MSEC), HRTIMER_MODE_REL);
	} else {
	ddata->running = false;
	isa1000_pwm_en(ddata, false);

	if (ddata->pdata->gpio_en > 0)
	isa1000_en(ddata, false);

	isa1000_regulator_en(ddata, false);
	hrtimer_cancel(timer);
	}
	return;
	}

	static ssize_t intensity_store(struct device *dev,
	struct device_attribute devattr, const char buf, size_t count)
	{
	struct timed_output_dev *tdev = dev_get_drvdata(dev);
	struct isa1000_ddata *drvdata
	= container_of(tdev, struct isa1000_ddata, dev);
	int duty = drvdata->pdata->period >> 1;
	int intensity = 0, ret = 0;

	ret = kstrtoint(buf, 0, &intensity);

	if (intensity < 0 \|\| MAX_INTENSITY < intensity) {
	pr_err("out of rage\n");
	return -EINVAL;
	}

	if (MAX_INTENSITY == intensity)
	duty = drvdata->pdata->duty;
	else if (0 != intensity) {
	long long tmp = drvdata->pdata->duty >> 1;

	tmp *= (intensity / 100);
	duty += (int)(tmp / 100);
	}

	drvdata->intensity = intensity;
	drvdata->duty = duty;
	printk("[VIB] : %s : intensity = %d, duty = %d \n",__func__, intensity, duty);
	return count;
	}

	static ssize_t intensity_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct timed_output_dev *tdev = dev_get_drvdata(dev);
	struct isa1000_ddata *drvdata
	= container_of(tdev, struct isa1000_ddata, dev);

	return sprintf(buf, "intensity: %u\n", drvdata->intensity);
	}

	static DEVICE_ATTR(intensity, 0660, intensity_show, intensity_store);

	#ifdef DEBUG_MOTOR
	static ssize_t duty_store(struct device *dev,
	struct device_attribute devattr, const char buf, size_t count)
	{
	struct timed_output_dev *tdev = dev_get_drvdata(dev);
	struct isa1000_ddata *drvdata
	= container_of(tdev, struct isa1000_ddata, dev);
	int duty = drvdata->pdata->period >> 1;
	int duty_rate = 0, ret = 0, temp=0;

	ret = kstrtoint(buf, 0, &duty_rate);

	if (duty_rate < 0 \|\| duty_rate > 1000) {
	pr_err("out of rage \n");
	return -EINVAL;
	}

	temp = duty * duty_rate /1000;
	duty = duty + temp;

	drvdata->duty = duty;
	printk("[VIB] : %s : duty_rate = %d, duty = %d, temp = %d \n",__func__, duty_rate, duty, temp);
	return count;
	}

	static ssize_t duty_show(struct device *dev,
	struct device_attribute attr, char buf)
	{
	struct timed_output_dev *tdev = dev_get_drvdata(dev);
	struct isa1000_ddata *drvdata
	= container_of(tdev, struct isa1000_ddata, dev);


	int duty = drvdata->pdata->period >> 1;
	int duty_rate=0;
	duty_rate = ((drvdata->duty-duty)*1000 / duty);

	printk("[VIB] : %s : duty = %d, drvdata->duty=%d, duty_rate = %d \n",__func__, duty, drvdata->duty, duty_rate);
	return sprintf(buf, "current duty rate : %u %% \n", duty_rate);
	}

	static DEVICE_ATTR(duty, 0660, duty_show, duty_store);
	#endif

	static struct isa1000_pdata *
	isa1000_get_devtree_pdata(struct device *dev)
	{
	struct device_node node, child_node=NULL;
	struct isa1000_pdata *pdata;
	const char *dt_status;
	int ret = 0;

	node = dev->of_node;
	if (!node) {
	ret = -ENODEV;
	goto err_out;
	}

	child_node = of_get_next_child(node, child_node);
	if (!child_node) {
	printk("[VIB] failed to get dt node\n");
	ret = -EINVAL;
	goto err_out;
	}

	if (of_property_read_string(child_node, "status", &dt_status) < 0) {
	printk("[VIB] isa1000 dt status read fail \n");
	} else {
	printk("[VIB] isa1000 dt status : %s \n", dt_status);
	if (strcmp(dt_status, "okay")) {
	printk("[VIB] isa1000 dt status is disabled so return error \n");
	ret = -ENODEV;
	goto err_out;
	}
	}
	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
	printk("[VIB] failed to alloc\n");
	ret = -ENOMEM;
	goto err_out;
	}

	of_property_read_u32(child_node, "isa1000,max_timeout", &pdata->max_timeout);
	of_property_read_u32(child_node, "isa1000,duty", &pdata->duty);
	of_property_read_u32(child_node, "isa1000,period", &pdata->period);
	of_property_read_u32(child_node, "isa1000,pwm_id", &pdata->pwm_id);
	of_property_read_u32(child_node, "isa1000,pwm_use", &pdata->pwm_use);


	if (of_property_read_string(child_node, "isa1000,regulator_name", &pdata->regulator_name) < 0) {
	pr_err("%s - get regulator error\n", __func__);
	pdata->regulator_name = NULL;
	}

	pdata->gpio_en = of_get_named_gpio(child_node, "isa1000,gpio_en", 0);

	if (pdata->gpio_en > 0)
	gpio_request(pdata->gpio_en, "isa1000,gpio_en");

	printk("[VIB] max_timeout = %d\n", pdata->max_timeout);
	printk("[VIB] duty = %d\n", pdata->duty);
	printk("[VIB] period = %d\n", pdata->period);
	printk("[VIB] pwm_id = %d\n", pdata->pwm_id);
	printk("[VIB] gpio_en = %d\n", pdata->gpio_en);
	printk("[VIB] pwm_use = %d\n", pdata->pwm_use);
	printk("[VIB] %s : regulator_name = %s \n",__func__, pdata->regulator_name);

	return pdata;

	err_out:
	return ERR_PTR(ret);
	}

	static int isa1000_probe(struct platform_device *pdev)
	{
	struct isa1000_pdata *pdata = dev_get_platdata(&pdev->dev);
	struct isa1000_ddata *ddata;
	int ret = 0;

	if (!pdata) {
	#if defined(CONFIG_OF)
	pdata = isa1000_get_devtree_pdata(&pdev->dev);
	if (IS_ERR(pdata)) {
	printk(KERN_ERR "[VIB] there is no device tree!\n");
	ret = -ENODEV;
	goto err_pdata;
	}
	#else
	printk(KERN_ERR "[VIB] there is no platform data!\n");
	#endif
	}

	ddata = kzalloc(sizeof(*ddata), GFP_KERNEL);
	if (!ddata) {
	printk(KERN_ERR "[VIB] failed to alloc\n");
	ret = -ENOMEM;
	goto err_alloc;
	}

	hrtimer_init(&ddata->timer, CLOCK_MONOTONIC,
	HRTIMER_MODE_REL);
	spin_lock_init(&ddata->lock);
	INIT_WORK(&ddata->work, isa1000_work_func);

	ddata->pdata = pdata;
	ddata->timer.function = isa1000_timer_func;
	ddata->pwm = pwm_request(ddata->pdata->pwm_id, "vibrator");
	if (IS_ERR(ddata->pwm)) {
	printk(KERN_ERR "[VIB] failed to request pwm\n");
	ret = -EFAULT;
	goto err_pwm_request;
	}


	if (ddata->pdata->regulator_name) {
	ddata->regulator = regulator_get(NULL, ddata->pdata->regulator_name);
	if (IS_ERR(ddata->regulator)) {
	ret = -EFAULT;
	pr_err("[VIB] Failed to get vmoter regulator, err num: %d\n", ret);
	goto err_regulator_get;
	}
	} else
	ddata->regulator = NULL;

	ddata->dev.name = "vibrator";
	ddata->dev.get_time = isa1000_get_time;
	ddata->dev.enable = isa1000_enable;

	ret = timed_output_dev_register(&ddata->dev);
	if (ret < 0) {
	printk(KERN_ERR "[VIB] failed to register timed output\n");
	goto err_dev_reg;
	}

	if(ddata->pdata->pwm_use)
	{
	ret = sysfs_create_file(&ddata->dev.dev->kobj, &dev_attr_intensity.attr);
	if (ret < 0) {
	pr_err("Failed to register intensity sysfs : %d\n", ret);
	goto err_dev_reg;
	}
	#ifdef DEBUG_MOTOR
	ret = sysfs_create_file(&ddata->dev.dev->kobj, &dev_attr_duty.attr);
	if (ret < 0) {
	pr_err("Failed to register duty sysfs : %d\n", ret);
	goto err_dev_reg;
	}
	#endif
	}

	platform_set_drvdata(pdev, ddata);

	return ret;

	err_dev_reg:
	if (!ddata->regulator)
	regulator_put(ddata->regulator);
	err_regulator_get:
	pwm_free(ddata->pwm);
	err_pwm_request:
	kfree(ddata);
	err_alloc:
	err_pdata:
	return ret;
	}

	static int isa1000_remove(struct platform_device *pdev)
	{
	struct isa1000_ddata *ddata = platform_get_drvdata(pdev);
	if (!ddata->regulator)
	regulator_put(ddata->regulator);
	pwm_free(ddata->pwm);
	timed_output_dev_unregister(&ddata->dev);
	kfree(ddata);
	return 0;
	}

	static int isa1000_suspend(struct platform_device *pdev,
	pm_message_t state)
	{
	struct isa1000_ddata *ddata = platform_get_drvdata(pdev);

	isa1000_regulator_en(ddata, false);
	isa1000_pwm_en(ddata, false);

	if (ddata->pdata->gpio_en > 0)
	isa1000_en(ddata, false);

	return 0;
	}

	static int isa1000_resume(struct platform_device *pdev)
	{
	return 0;
	}

	#if defined(CONFIG_OF)
	static struct of_device_id isa1000_dt_ids[] = {
	{ .compatible = "isa1000" },
	{ }
	};
	MODULE_DEVICE_TABLE(of, isa1000_dt_ids);
	#endif /* CONFIG_OF */

	static struct platform_driver isa1000_driver = {
	.probe = isa1000_probe,
	.remove = isa1000_remove,
	.suspend = isa1000_suspend,
	.resume = isa1000_resume,
	.driver = {
	.name = "isa1000",
	.owner = THIS_MODULE,
	.of_match_table = of_match_ptr(isa1000_dt_ids),
	},
	};

	static int __init isa1000_init(void)
	{
	return platform_driver_register(&isa1000_driver);
	}
	module_init(isa1000_init);

	static void __exit isa1000_exit(void)
	{
	platform_driver_unregister(&isa1000_driver);
	}
	module_exit(isa1000_exit);

	MODULE_AUTHOR("Samsung Electronics");
	MODULE_LICENSE("GPL");
	MODULE_DESCRIPTION("isa1000 vibrator driver");