[linux-2.6-block.git] / drivers / input / misc / max8997_haptic.c

/*
 * MAX8997-haptic controller driver
 *
 * Copyright (C) 2012 Samsung Electronics
 * Donggeun Kim <dg77.kim@samsung.com>
 *
 * This program is not provided / owned by Maxim Integrated Products.
 *
 * 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
 *
 */

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/pwm.h>
#include <linux/input.h>
#include <linux/mfd/max8997-private.h>
#include <linux/mfd/max8997.h>
#include <linux/regulator/consumer.h>

/* Haptic configuration 2 register */
#define MAX8997_MOTOR_TYPE_SHIFT	7
#define MAX8997_ENABLE_SHIFT		6
#define MAX8997_MODE_SHIFT		5

/* Haptic driver configuration register */
#define MAX8997_CYCLE_SHIFT		6
#define MAX8997_SIG_PERIOD_SHIFT	4
#define MAX8997_SIG_DUTY_SHIFT		2
#define MAX8997_PWM_DUTY_SHIFT		0

struct max8997_haptic {
	struct device *dev;
	struct i2c_client *client;
	struct input_dev *input_dev;
	struct regulator *regulator;

	struct work_struct work;
	struct mutex mutex;

	bool enabled;
	unsigned int level;

	struct pwm_device *pwm;
	unsigned int pwm_period;
	enum max8997_haptic_pwm_divisor pwm_divisor;

	enum max8997_haptic_motor_type type;
	enum max8997_haptic_pulse_mode mode;

	unsigned int internal_mode_pattern;
	unsigned int pattern_cycle;
	unsigned int pattern_signal_period;
};

static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
{
	int ret = 0;

	if (chip->mode == MAX8997_EXTERNAL_MODE) {
		unsigned int duty = chip->pwm_period * chip->level / 100;
		ret = pwm_config(chip->pwm, duty, chip->pwm_period);
	} else {
		int i;
		u8 duty_index = 0;

		for (i = 0; i <= 64; i++) {
			if (chip->level <= i * 100 / 64) {
				duty_index = i;
				break;
			}
		}
		switch (chip->internal_mode_pattern) {
		case 0:
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
			break;
		case 1:
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
			break;
		case 2:
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
			break;
		case 3:
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
			break;
		default:
			break;
		}
	}
	return ret;
}

static void max8997_haptic_configure(struct max8997_haptic *chip)
{
	u8 value;

	value = chip->type << MAX8997_MOTOR_TYPE_SHIFT |
		chip->enabled << MAX8997_ENABLE_SHIFT |
		chip->mode << MAX8997_MODE_SHIFT | chip->pwm_divisor;
	max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);

	if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
		value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT |
			chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT |
			chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT |
			chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
		max8997_write_reg(chip->client,
			MAX8997_HAPTIC_REG_DRVCONF, value);

		switch (chip->internal_mode_pattern) {
		case 0:
			value = chip->pattern_cycle << 4;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_CYCLECONF1, value);
			value = chip->pattern_signal_period;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGCONF1, value);
			break;

		case 1:
			value = chip->pattern_cycle;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_CYCLECONF1, value);
			value = chip->pattern_signal_period;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGCONF2, value);
			break;

		case 2:
			value = chip->pattern_cycle << 4;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_CYCLECONF2, value);
			value = chip->pattern_signal_period;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGCONF3, value);
			break;

		case 3:
			value = chip->pattern_cycle;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_CYCLECONF2, value);
			value = chip->pattern_signal_period;
			max8997_write_reg(chip->client,
				MAX8997_HAPTIC_REG_SIGCONF4, value);
			break;

		default:
			break;
		}
	}
}

static void max8997_haptic_enable(struct max8997_haptic *chip)
{
	int error;

	mutex_lock(&chip->mutex);

	error = max8997_haptic_set_duty_cycle(chip);
	if (error) {
		dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
		goto out;
	}

	if (!chip->enabled) {
		error = regulator_enable(chip->regulator);
		if (error) {
			dev_err(chip->dev, "Failed to enable regulator\n");
			goto out;
		}
		max8997_haptic_configure(chip);
		if (chip->mode == MAX8997_EXTERNAL_MODE) {
			error = pwm_enable(chip->pwm);
			if (error) {
				dev_err(chip->dev, "Failed to enable PWM\n");
				regulator_disable(chip->regulator);
				goto out;
			}
		}
		chip->enabled = true;
	}

out:
	mutex_unlock(&chip->mutex);
}

static void max8997_haptic_disable(struct max8997_haptic *chip)
{
	mutex_lock(&chip->mutex);

	if (chip->enabled) {
		chip->enabled = false;
		max8997_haptic_configure(chip);
		if (chip->mode == MAX8997_EXTERNAL_MODE)
			pwm_disable(chip->pwm);
		regulator_disable(chip->regulator);
	}

	mutex_unlock(&chip->mutex);
}

static void max8997_haptic_play_effect_work(struct work_struct *work)
{
	struct max8997_haptic *chip =
			container_of(work, struct max8997_haptic, work);

	if (chip->level)
		max8997_haptic_enable(chip);
	else
		max8997_haptic_disable(chip);
}

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

	chip->level = effect->u.rumble.strong_magnitude;
	if (!chip->level)
		chip->level = effect->u.rumble.weak_magnitude;

	schedule_work(&chip->work);

	return 0;
}

static void max8997_haptic_close(struct input_dev *dev)
{
	struct max8997_haptic *chip = input_get_drvdata(dev);

	cancel_work_sync(&chip->work);
	max8997_haptic_disable(chip);
}

static int max8997_haptic_probe(struct platform_device *pdev)
{
	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
	const struct max8997_platform_data *pdata =
					dev_get_platdata(iodev->dev);
	const struct max8997_haptic_platform_data *haptic_pdata = NULL;
	struct max8997_haptic *chip;
	struct input_dev *input_dev;
	int error;

	if (pdata)
		haptic_pdata = pdata->haptic_pdata;

	if (!haptic_pdata) {
		dev_err(&pdev->dev, "no haptic platform data\n");
		return -EINVAL;
	}

	chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!chip || !input_dev) {
		dev_err(&pdev->dev, "unable to allocate memory\n");
		error = -ENOMEM;
		goto err_free_mem;
	}

	INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
	mutex_init(&chip->mutex);

	chip->client = iodev->haptic;
	chip->dev = &pdev->dev;
	chip->input_dev = input_dev;
	chip->pwm_period = haptic_pdata->pwm_period;
	chip->type = haptic_pdata->type;
	chip->mode = haptic_pdata->mode;
	chip->pwm_divisor = haptic_pdata->pwm_divisor;

	switch (chip->mode) {
	case MAX8997_INTERNAL_MODE:
		chip->internal_mode_pattern =
				haptic_pdata->internal_mode_pattern;
		chip->pattern_cycle = haptic_pdata->pattern_cycle;
		chip->pattern_signal_period =
				haptic_pdata->pattern_signal_period;
		break;

	case MAX8997_EXTERNAL_MODE:
		chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
					"max8997-haptic");
		if (IS_ERR(chip->pwm)) {
			error = PTR_ERR(chip->pwm);
			dev_err(&pdev->dev,
				"unable to request PWM for haptic, error: %d\n",
				error);
			goto err_free_mem;
		}

		/*
		 * FIXME: pwm_apply_args() should be removed when switching to
		 * the atomic PWM API.
		 */
		pwm_apply_args(chip->pwm);
		break;

	default:
		dev_err(&pdev->dev,
			"Invalid chip mode specified (%d)\n", chip->mode);
		error = -EINVAL;
		goto err_free_mem;
	}

	chip->regulator = regulator_get(&pdev->dev, "inmotor");
	if (IS_ERR(chip->regulator)) {
		error = PTR_ERR(chip->regulator);
		dev_err(&pdev->dev,
			"unable to get regulator, error: %d\n",
			error);
		goto err_free_pwm;
	}

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

	error = input_ff_create_memless(input_dev, NULL,
				max8997_haptic_play_effect);
	if (error) {
		dev_err(&pdev->dev,
			"unable to create FF device, error: %d\n",
			error);
		goto err_put_regulator;
	}

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

	platform_set_drvdata(pdev, chip);
	return 0;

err_destroy_ff:
	input_ff_destroy(input_dev);
err_put_regulator:
	regulator_put(chip->regulator);
err_free_pwm:
	if (chip->mode == MAX8997_EXTERNAL_MODE)
		pwm_free(chip->pwm);
err_free_mem:
	input_free_device(input_dev);
	kfree(chip);

	return error;
}

static int max8997_haptic_remove(struct platform_device *pdev)
{
	struct max8997_haptic *chip = platform_get_drvdata(pdev);

	input_unregister_device(chip->input_dev);
	regulator_put(chip->regulator);

	if (chip->mode == MAX8997_EXTERNAL_MODE)
		pwm_free(chip->pwm);

	kfree(chip);

	return 0;
}

static int __maybe_unused max8997_haptic_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct max8997_haptic *chip = platform_get_drvdata(pdev);

	max8997_haptic_disable(chip);

	return 0;
}

static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);

static const struct platform_device_id max8997_haptic_id[] = {
	{ "max8997-haptic", 0 },
	{ },
};
MODULE_DEVICE_TABLE(platform, max8997_haptic_id);

static struct platform_driver max8997_haptic_driver = {
	.driver	= {
		.name	= "max8997-haptic",
		.pm	= &max8997_haptic_pm_ops,
	},
	.probe		= max8997_haptic_probe,
	.remove		= max8997_haptic_remove,
	.id_table	= max8997_haptic_id,
};
module_platform_driver(max8997_haptic_driver);

MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
MODULE_DESCRIPTION("max8997_haptic driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
104594b0 DK	1	/*
	2	* MAX8997-haptic controller driver
	3	*
	4	* Copyright (C) 2012 Samsung Electronics
	5	* Donggeun Kim <dg77.kim@samsung.com>
	6	*
	7	* This program is not provided / owned by Maxim Integrated Products.
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	22	*
	23	*/
	24
	25	#include <linux/module.h>
104594b0 DK	26	#include <linux/slab.h>
	27	#include <linux/platform_device.h>
	28	#include <linux/err.h>
	29	#include <linux/pwm.h>
	30	#include <linux/input.h>
	31	#include <linux/mfd/max8997-private.h>
	32	#include <linux/mfd/max8997.h>
	33	#include <linux/regulator/consumer.h>
	34
	35	/* Haptic configuration 2 register */
	36	#define MAX8997_MOTOR_TYPE_SHIFT 7
	37	#define MAX8997_ENABLE_SHIFT 6
	38	#define MAX8997_MODE_SHIFT 5
	39
	40	/* Haptic driver configuration register */
	41	#define MAX8997_CYCLE_SHIFT 6
	42	#define MAX8997_SIG_PERIOD_SHIFT 4
	43	#define MAX8997_SIG_DUTY_SHIFT 2
	44	#define MAX8997_PWM_DUTY_SHIFT 0
	45
	46	struct max8997_haptic {
	47	struct device *dev;
	48	struct i2c_client *client;
	49	struct input_dev *input_dev;
	50	struct regulator *regulator;
	51
	52	struct work_struct work;
	53	struct mutex mutex;
	54
	55	bool enabled;
	56	unsigned int level;
	57
	58	struct pwm_device *pwm;
	59	unsigned int pwm_period;
	60	enum max8997_haptic_pwm_divisor pwm_divisor;
	61
	62	enum max8997_haptic_motor_type type;
	63	enum max8997_haptic_pulse_mode mode;
	64
	65	unsigned int internal_mode_pattern;
	66	unsigned int pattern_cycle;
	67	unsigned int pattern_signal_period;
	68	};
	69
	70	static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
	71	{
	72	int ret = 0;
	73
	74	if (chip->mode == MAX8997_EXTERNAL_MODE) {
	75	unsigned int duty = chip->pwm_period * chip->level / 100;
	76	ret = pwm_config(chip->pwm, duty, chip->pwm_period);
	77	} else {
	78	int i;
	79	u8 duty_index = 0;
	80
	81	for (i = 0; i <= 64; i++) {
	82	if (chip->level <= i * 100 / 64) {
	83	duty_index = i;
	84	break;
	85	}
	86	}
	87	switch (chip->internal_mode_pattern) {
	88	case 0:
	89	max8997_write_reg(chip->client,
90	MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
91	break;
92	case 1:
93	max8997_write_reg(chip->client,
94	MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
95	break;
96	case 2:
97	max8997_write_reg(chip->client,
98	MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
99	break;
100	case 3:
101	max8997_write_reg(chip->client,
102	MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
103	break;
104	default:
105	break;
106	}
107	}
108	return ret;
109	}
110
111	static void max8997_haptic_configure(struct max8997_haptic *chip)
112	{
113	u8 value;
114
115	value = chip->type << MAX8997_MOTOR_TYPE_SHIFT \|
116	chip->enabled << MAX8997_ENABLE_SHIFT \|
117	chip->mode << MAX8997_MODE_SHIFT \| chip->pwm_divisor;
118	max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);
119
120	if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
121	value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT \|
122	chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT \|
123	chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT \|
124	chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
125	max8997_write_reg(chip->client,
126	MAX8997_HAPTIC_REG_DRVCONF, value);
127
128	switch (chip->internal_mode_pattern) {
129	case 0:
130	value = chip->pattern_cycle << 4;
131	max8997_write_reg(chip->client,
132	MAX8997_HAPTIC_REG_CYCLECONF1, value);
133	value = chip->pattern_signal_period;
134	max8997_write_reg(chip->client,
135	MAX8997_HAPTIC_REG_SIGCONF1, value);
136	break;
137
138	case 1:
139	value = chip->pattern_cycle;
140	max8997_write_reg(chip->client,
141	MAX8997_HAPTIC_REG_CYCLECONF1, value);
142	value = chip->pattern_signal_period;
143	max8997_write_reg(chip->client,
144	MAX8997_HAPTIC_REG_SIGCONF2, value);
145	break;
146
147	case 2:
148	value = chip->pattern_cycle << 4;
149	max8997_write_reg(chip->client,
150	MAX8997_HAPTIC_REG_CYCLECONF2, value);
151	value = chip->pattern_signal_period;
152	max8997_write_reg(chip->client,
153	MAX8997_HAPTIC_REG_SIGCONF3, value);
154	break;
155
156	case 3:
157	value = chip->pattern_cycle;
158	max8997_write_reg(chip->client,
159	MAX8997_HAPTIC_REG_CYCLECONF2, value);
160	value = chip->pattern_signal_period;
161	max8997_write_reg(chip->client,
162	MAX8997_HAPTIC_REG_SIGCONF4, value);
163	break;
164
165	default:
166	break;
167	}
168	}
169	}
170
171	static void max8997_haptic_enable(struct max8997_haptic *chip)
172	{
173	int error;
174
175	mutex_lock(&chip->mutex);
176
177	error = max8997_haptic_set_duty_cycle(chip);
178	if (error) {
179	dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
180	goto out;
181	}
182
183	if (!chip->enabled) {
b1bc3031 SK	184	error = regulator_enable(chip->regulator);
	185	if (error) {
	186	dev_err(chip->dev, "Failed to enable regulator\n");
	187	goto out;
	188	}
104594b0	189	max8997_haptic_configure(chip);
b1bc3031 SK	190	if (chip->mode == MAX8997_EXTERNAL_MODE) {
	191	error = pwm_enable(chip->pwm);
	192	if (error) {
	193	dev_err(chip->dev, "Failed to enable PWM\n");
	194	regulator_disable(chip->regulator);
	195	goto out;
	196	}
	197	}
	198	chip->enabled = true;
104594b0 DK	199	}
	200
	201	out:
	202	mutex_unlock(&chip->mutex);
	203	}
	204
	205	static void max8997_haptic_disable(struct max8997_haptic *chip)
	206	{
	207	mutex_lock(&chip->mutex);
	208
	209	if (chip->enabled) {
	210	chip->enabled = false;
	211	max8997_haptic_configure(chip);
	212	if (chip->mode == MAX8997_EXTERNAL_MODE)
	213	pwm_disable(chip->pwm);
	214	regulator_disable(chip->regulator);
	215	}
	216
	217	mutex_unlock(&chip->mutex);
	218	}
	219
	220	static void max8997_haptic_play_effect_work(struct work_struct *work)
	221	{
	222	struct max8997_haptic *chip =
	223	container_of(work, struct max8997_haptic, work);
	224
	225	if (chip->level)
	226	max8997_haptic_enable(chip);
	227	else
	228	max8997_haptic_disable(chip);
	229	}
	230
	231	static int max8997_haptic_play_effect(struct input_dev dev, void data,
	232	struct ff_effect *effect)
	233	{
	234	struct max8997_haptic *chip = input_get_drvdata(dev);
	235
	236	chip->level = effect->u.rumble.strong_magnitude;
	237	if (!chip->level)
	238	chip->level = effect->u.rumble.weak_magnitude;
	239
	240	schedule_work(&chip->work);
	241
	242	return 0;
	243	}
	244
	245	static void max8997_haptic_close(struct input_dev *dev)
	246	{
	247	struct max8997_haptic *chip = input_get_drvdata(dev);
	248
	249	cancel_work_sync(&chip->work);
	250	max8997_haptic_disable(chip);
	251	}
	252
5298cc4c	253	static int max8997_haptic_probe(struct platform_device *pdev)
104594b0 DK	254	{
	255	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
	256	const struct max8997_platform_data *pdata =
	257	dev_get_platdata(iodev->dev);
6ae645d5	258	const struct max8997_haptic_platform_data *haptic_pdata = NULL;
104594b0 DK	259	struct max8997_haptic *chip;
	260	struct input_dev *input_dev;
	261	int error;
	262
6ae645d5 MS	263	if (pdata)
	264	haptic_pdata = pdata->haptic_pdata;
	265
104594b0 DK	266	if (!haptic_pdata) {
	267	dev_err(&pdev->dev, "no haptic platform data\n");
	268	return -EINVAL;
	269	}
	270
	271	chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
	272	input_dev = input_allocate_device();
	273	if (!chip \|\| !input_dev) {
	274	dev_err(&pdev->dev, "unable to allocate memory\n");
	275	error = -ENOMEM;
	276	goto err_free_mem;
	277	}
	278
	279	INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
	280	mutex_init(&chip->mutex);
	281
	282	chip->client = iodev->haptic;
	283	chip->dev = &pdev->dev;
	284	chip->input_dev = input_dev;
	285	chip->pwm_period = haptic_pdata->pwm_period;
	286	chip->type = haptic_pdata->type;
	287	chip->mode = haptic_pdata->mode;
	288	chip->pwm_divisor = haptic_pdata->pwm_divisor;
	289
	290	switch (chip->mode) {
	291	case MAX8997_INTERNAL_MODE:
	292	chip->internal_mode_pattern =
	293	haptic_pdata->internal_mode_pattern;
	294	chip->pattern_cycle = haptic_pdata->pattern_cycle;
	295	chip->pattern_signal_period =
	296	haptic_pdata->pattern_signal_period;
	297	break;
	298
	299	case MAX8997_EXTERNAL_MODE:
	300	chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
	301	"max8997-haptic");
	302	if (IS_ERR(chip->pwm)) {
	303	error = PTR_ERR(chip->pwm);
	304	dev_err(&pdev->dev,
	305	"unable to request PWM for haptic, error: %d\n",
	306	error);
	307	goto err_free_mem;
	308	}
de93170b BB	309
	310	/*
	311	* FIXME: pwm_apply_args() should be removed when switching to
	312	* the atomic PWM API.
	313	*/
	314	pwm_apply_args(chip->pwm);
104594b0 DK	315	break;
	316
	317	default:
	318	dev_err(&pdev->dev,
	319	"Invalid chip mode specified (%d)\n", chip->mode);
	320	error = -EINVAL;
	321	goto err_free_mem;
	322	}
	323
	324	chip->regulator = regulator_get(&pdev->dev, "inmotor");
	325	if (IS_ERR(chip->regulator)) {
	326	error = PTR_ERR(chip->regulator);
	327	dev_err(&pdev->dev,
	328	"unable to get regulator, error: %d\n",
	329	error);
	330	goto err_free_pwm;
	331	}
	332
	333	input_dev->name = "max8997-haptic";
	334	input_dev->id.version = 1;
	335	input_dev->dev.parent = &pdev->dev;
	336	input_dev->close = max8997_haptic_close;
	337	input_set_drvdata(input_dev, chip);
	338	input_set_capability(input_dev, EV_FF, FF_RUMBLE);
	339
	340	error = input_ff_create_memless(input_dev, NULL,
	341	max8997_haptic_play_effect);
	342	if (error) {
	343	dev_err(&pdev->dev,
	344	"unable to create FF device, error: %d\n",
	345	error);
	346	goto err_put_regulator;
	347	}
	348
	349	error = input_register_device(input_dev);
	350	if (error) {
	351	dev_err(&pdev->dev,
	352	"unable to register input device, error: %d\n",
	353	error);
	354	goto err_destroy_ff;
	355	}
	356
	357	platform_set_drvdata(pdev, chip);
	358	return 0;
	359
	360	err_destroy_ff:
	361	input_ff_destroy(input_dev);
	362	err_put_regulator:
	363	regulator_put(chip->regulator);
	364	err_free_pwm:
	365	if (chip->mode == MAX8997_EXTERNAL_MODE)
	366	pwm_free(chip->pwm);
	367	err_free_mem:
	368	input_free_device(input_dev);
	369	kfree(chip);
	370
	371	return error;
	372	}
	373
e2619cf7	374	static int max8997_haptic_remove(struct platform_device *pdev)
104594b0 DK	375	{
	376	struct max8997_haptic *chip = platform_get_drvdata(pdev);
	377
	378	input_unregister_device(chip->input_dev);
	379	regulator_put(chip->regulator);
	380
	381	if (chip->mode == MAX8997_EXTERNAL_MODE)
	382	pwm_free(chip->pwm);
	383
	384	kfree(chip);
	385
	386	return 0;
	387	}
	388
97a652a8	389	static int __maybe_unused max8997_haptic_suspend(struct device *dev)
104594b0 DK	390	{
	391	struct platform_device *pdev = to_platform_device(dev);
	392	struct max8997_haptic *chip = platform_get_drvdata(pdev);
	393
	394	max8997_haptic_disable(chip);
	395
	396	return 0;
	397	}
104594b0 DK	398
	399	static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);
	400
	401	static const struct platform_device_id max8997_haptic_id[] = {
	402	{ "max8997-haptic", 0 },
	403	{ },
	404	};
d6f5aef2	405	MODULE_DEVICE_TABLE(platform, max8997_haptic_id);
104594b0 DK	406
	407	static struct platform_driver max8997_haptic_driver = {
	408	.driver = {
	409	.name = "max8997-haptic",
104594b0 DK	410	.pm = &max8997_haptic_pm_ops,
	411	},
	412	.probe = max8997_haptic_probe,
1cb0aa88	413	.remove = max8997_haptic_remove,
104594b0 DK	414	.id_table = max8997_haptic_id,
	415	};
	416	module_platform_driver(max8997_haptic_driver);
	417
104594b0 DK	418	MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
	419	MODULE_DESCRIPTION("max8997_haptic driver");
	420	MODULE_LICENSE("GPL");