path: root/drivers/input/misc/drv2603-vibrator.c

/*
 * DRV2603 haptic driver for LRA and ERM vibrator motor
 *
 * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/pwm.h>
#include <linux/input.h>
#include <linux/gpio.h>
#include <linux/pm.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>
#include <linux/input/drv2603-vibrator.h>
#include <linux/edp.h>

#define DEFAULT_DUTY_CYCLE 80

enum drv2603_state {
	VIBRATOR_OFF,
	VIBRATOR_ON,
};

struct drv2603_chip {
	int pwm_id;
	struct pwm_device *pwm_device;
	struct device *dev;
	struct input_dev *input_dev;
	struct regulator *regulator;
	struct work_struct work;
	int gpio;
	int duty_cycle;
	enum drv2603_mode vibrator_mode;
	enum drv2603_state state;
	struct edp_client *haptic_edp_client;
};

static int drv2603_set_duty_cycle(struct drv2603_chip *chip, int val)
{
	return pwm_config(chip->pwm_device, val * 100, 10000);
}

static int drv2603_vibrator_initialize(struct drv2603_chip *chip)
{
	int ret;

	chip->duty_cycle = DEFAULT_DUTY_CYCLE;
	ret = drv2603_set_duty_cycle(chip, chip->duty_cycle);
	if (ret) {
		dev_err(chip->dev, "Failed to initialize pwm config\n");
		return ret;
	}

	ret = gpio_request_one(chip->gpio, GPIOF_OUT_INIT_LOW, NULL);
	if (ret) {
		dev_err(chip->dev, "Failed to request gpio\n");
		return ret;
	}

	return 0;
}

static int drv2603_vibrate(struct drv2603_chip *chip)
{
	int ret;
	unsigned int approved;

	switch (chip->state) {
	case VIBRATOR_OFF:
		if (chip->haptic_edp_client) {
			ret = edp_update_client_request(chip->haptic_edp_client,
				DRV2603_HAPTIC_EDP_LOW, &approved);
			if (ret) {
				dev_err(chip->dev,
					"E state transition failed\n");
				return ret;
			}
		}
		gpio_set_value_cansleep(chip->gpio, 0);
		drv2603_set_duty_cycle(chip, 0);
		pwm_disable(chip->pwm_device);
		regulator_disable(chip->regulator);
	break;
	case VIBRATOR_ON:
		if (chip->haptic_edp_client) {
			ret = edp_update_client_request(chip->haptic_edp_client,
				DRV2603_HAPTIC_EDP_HIGH, &approved);
			if (ret || approved != DRV2603_HAPTIC_EDP_HIGH) {
				dev_err(chip->dev,
					"E state transition failed\n");
				return ret;
			}
		}
		regulator_enable(chip->regulator);
		drv2603_set_duty_cycle(chip, chip->duty_cycle);
		gpio_set_value_cansleep(chip->gpio, 1);
		pwm_enable(chip->pwm_device);
	break;
	}
	return 0;
}

static void drv2603_haptic_play_effect_work(struct work_struct *work)
{
	struct drv2603_chip *chip =
		container_of(work, struct drv2603_chip, work);

	drv2603_vibrate(chip);
}

static int drv2603_haptic_play_effect(struct input_dev *dev, void *data,
					struct ff_effect *effect)
{
	struct drv2603_chip *chip = input_get_drvdata(dev);

	if (chip->state == VIBRATOR_OFF) {
		chip->state = VIBRATOR_ON;
		schedule_work(&chip->work);
	}
	return 0;
}

static ssize_t drv2603_vibrator_enable_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct drv2603_chip *chip = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", chip->state);
}

static ssize_t drv2603_vibrator_enable_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct drv2603_chip *chip = dev_get_drvdata(dev);
	int var;

	sscanf(buf, "%d", &var);
	if (var == 0 && chip->state == VIBRATOR_ON) {
		cancel_work_sync(&chip->work);
		chip->state = VIBRATOR_OFF;
		schedule_work(&chip->work);
	} else if (var == 1 && chip->state == VIBRATOR_OFF) {
		cancel_work_sync(&chip->work);
		chip->state = VIBRATOR_ON;
		schedule_work(&chip->work);
	}

	return count;
}

static ssize_t drv2603_vibrator_duty_cycle_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct drv2603_chip *chip = dev_get_drvdata(dev);

	return sprintf(buf, "%d\n", chip->duty_cycle);
}

static ssize_t drv2603_vibrator_duty_cycle_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct drv2603_chip *chip = dev_get_drvdata(dev);
	int duty_cycle;

	sscanf(buf, "%d", &duty_cycle);

	if (duty_cycle >= 0 && duty_cycle <= 100)
		chip->duty_cycle = duty_cycle;
	else
		dev_err(dev, "Duty cycle should be in range 0-100\n");

	return count;
}

static void drv2603_vibrator_throttle(unsigned int new_state, void *priv_data)
{
	struct drv2603_chip *chip = priv_data;

	if (!chip)
		return;

	if (chip->state == VIBRATOR_ON) {
		chip->state = VIBRATOR_OFF;
		drv2603_vibrate(chip);
	}
}

static DEVICE_ATTR(vibrator_enable, 0640, drv2603_vibrator_enable_show,
					drv2603_vibrator_enable_store);
static DEVICE_ATTR(duty_cycle, 0640, drv2603_vibrator_duty_cycle_show,
					drv2603_vibrator_duty_cycle_store);

static struct attribute *drv2603_vibrator_attr[] = {
	&dev_attr_vibrator_enable.attr,
	&dev_attr_duty_cycle.attr,
	NULL,
};

static const struct attribute_group drv2603_vibrator_attr_group = {
	.attrs = drv2603_vibrator_attr,
};

static int drv2603_probe(struct platform_device *pdev)
{
	int ret;

	struct drv2603_chip *chip;
	struct input_dev *input_dev;
	struct edp_manager *battery_manager = NULL;
	struct drv2603_platform_data *drv2603_pdata =
				dev_get_platdata(&pdev->dev);

	chip = devm_kzalloc(&pdev->dev, sizeof(*chip),
					GFP_KERNEL);
	if (!chip) {
		dev_err(&pdev->dev, "Memory allocation failed for chip\n");
		return -ENOMEM;
	}

	input_dev = input_allocate_device();
	if (!input_dev) {
		dev_err(&pdev->dev,
			"unable to allocate memory for input dev\n");
		return PTR_ERR(input_dev);
	}

	chip->pwm_id = drv2603_pdata->pwm_id;
	chip->gpio = drv2603_pdata->gpio;
	chip->duty_cycle = drv2603_pdata->duty_cycle;
	chip->vibrator_mode = drv2603_pdata->vibrator_mode;
	chip->dev = &pdev->dev;
	chip->input_dev = input_dev;
	dev_set_drvdata(&pdev->dev, chip);

	chip->regulator = regulator_get(&pdev->dev, "vdd_vbrtr");
	if (IS_ERR_OR_NULL(chip->regulator)) {
		dev_err(&pdev->dev, "Failed to get regulator\n");
		ret = PTR_ERR(chip->regulator);
		goto err_regulator;
	}

	chip->pwm_device = pwm_request(chip->pwm_id, "drv2603-vibrator");

	if (IS_ERR_OR_NULL(chip->pwm_device)) {
		dev_err(&pdev->dev, "Failed to get pwm device\n");
		ret = PTR_ERR(chip->pwm_device);
		goto err_pwm;
	}

	if (drv2603_pdata->edp_states[0] == 0) {
		dev_err(&pdev->dev, "EDP states invalid or not present");
		goto register_input;
	}

	chip->haptic_edp_client = devm_kzalloc(&pdev->dev,
				sizeof(struct edp_client), GFP_KERNEL);

	if (IS_ERR_OR_NULL(chip->haptic_edp_client)) {
		dev_err(&pdev->dev, "Could not allocate edp client\n");
		goto register_input;
	}

	strncpy(chip->haptic_edp_client->name, "drv2603-haptic",
						EDP_NAME_LEN - 1);
	chip->haptic_edp_client->name[EDP_NAME_LEN - 1] = '\0';
	chip->haptic_edp_client->states = drv2603_pdata->edp_states;
	chip->haptic_edp_client->num_states = DRV2603_HAPTIC_EDP_NUM_STATES;
	chip->haptic_edp_client->e0_index = DRV2603_HAPTIC_EDP_LOW;
	chip->haptic_edp_client->priority = EDP_MAX_PRIO + 2;
	chip->haptic_edp_client->throttle = drv2603_vibrator_throttle;
	chip->haptic_edp_client->private_data = chip;

	battery_manager = edp_get_manager("battery");
	if (IS_ERR_OR_NULL(battery_manager)) {
		dev_err(&pdev->dev, "Unable to get edp manager\n");
	} else {
		ret = edp_register_client(battery_manager,
				chip->haptic_edp_client);
		if (ret) {
			dev_err(&pdev->dev, "Unable to register edp client\n");
		} else {
			ret = edp_update_client_request(chip->haptic_edp_client,
					DRV2603_HAPTIC_EDP_LOW, NULL);
			if (ret) {
				dev_err(&pdev->dev,
					"Unable to set E0 EDP state\n");
				edp_unregister_client(chip->haptic_edp_client);
			} else {
				goto register_input;
			}
		}
	}

	devm_kfree(&pdev->dev, chip->haptic_edp_client);
	chip->haptic_edp_client = NULL;

register_input:
	input_dev->name = "drv2603-haptic";
	input_dev->id.version = 1;
	input_dev->dev.parent = &pdev->dev;
	input_set_drvdata(input_dev, chip);
	input_set_capability(input_dev, EV_FF, FF_RUMBLE);

	ret = input_ff_create_memless(input_dev, NULL,
				drv2603_haptic_play_effect);
	if (ret) {
		dev_err(&pdev->dev,
			"unable to create FF device(ret : %d)\n", ret);
		goto err_input_create;
	}
	INIT_WORK(&chip->work, drv2603_haptic_play_effect_work);

	ret = input_register_device(input_dev);
	if (ret) {
		dev_err(&pdev->dev,
			"unable to register input device(ret : %d)\n", ret);
		goto err_input_register;
	}

	ret = drv2603_vibrator_initialize(chip);
	if (ret) {
		dev_err(&pdev->dev, "Failed to initialize resources\n");
		goto err_vibrator_init;
	}

	ret = sysfs_create_group(&pdev->dev.kobj,
				&drv2603_vibrator_attr_group);
	if (ret) {
		dev_err(&pdev->dev, "Failed to create sysfs group\n");
		goto err_sysfs_create;
	}

	chip->state = VIBRATOR_OFF;
	return 0;

err_sysfs_create:
	gpio_free(chip->gpio);
err_vibrator_init:
	input_unregister_device(input_dev);
err_input_register:
	destroy_work_on_stack(&chip->work);
err_input_create:
	edp_unregister_client(chip->haptic_edp_client);
	pwm_free(chip->pwm_device);
err_pwm:
	regulator_put(chip->regulator);
err_regulator:
	input_free_device(input_dev);

	return ret;
}

static int drv2603_remove(struct platform_device *pdev)
{
	struct drv2603_chip *chip = dev_get_drvdata(&pdev->dev);

	pwm_free(chip->pwm_device);
	gpio_free(chip->gpio);
	destroy_work_on_stack(&chip->work);
	edp_unregister_client(chip->haptic_edp_client);
	input_unregister_device(chip->input_dev);
	input_free_device(chip->input_dev);
	regulator_put(chip->regulator);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static int drv2603_suspend(struct device *dev)
{
	struct drv2603_chip *chip = dev_get_drvdata(dev);

	if (chip->state == VIBRATOR_ON) {
		chip->state = VIBRATOR_OFF;
		drv2603_vibrate(chip);
	}

	return 0;
}

static int drv2603_resume(struct device *dev)
{
	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(drv2603_pm_ops, drv2603_suspend, drv2603_resume);

static struct platform_driver drv2603_driver = {
	.probe = drv2603_probe,
	.remove = drv2603_remove,
	.driver = {
		.name = "drv2603-vibrator",
		.owner = THIS_MODULE,
		.pm = &drv2603_pm_ops,
	},
};

static int __init drv2603_vibrator_init(void)
{
	return platform_driver_register(&drv2603_driver);
}
module_init(drv2603_vibrator_init);

static void __exit drv2603_vibrator_exit(void)
{
	platform_driver_unregister(&drv2603_driver);
}
module_exit(drv2603_vibrator_exit);

MODULE_DESCRIPTION("Drv2603 vibrator driver");
MODULE_AUTHOR("Sumit Sharma <sumsharma@nvidia.com>");
MODULE_LICENSE("GPL v2");