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>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/platform_device.h>
29 #include <linux/err.h>
30 #include <linux/pwm.h>
31 #include <linux/input.h>
32 #include <linux/mfd/max8997-private.h>
33 #include <linux/mfd/max8997.h>
34 #include <linux/regulator/consumer.h>
35 
36 /* Haptic configuration 2 register */
37 #define MAX8997_MOTOR_TYPE_SHIFT	7
38 #define MAX8997_ENABLE_SHIFT		6
39 #define MAX8997_MODE_SHIFT		5
40 
41 /* Haptic driver configuration register */
42 #define MAX8997_CYCLE_SHIFT		6
43 #define MAX8997_SIG_PERIOD_SHIFT	4
44 #define MAX8997_SIG_DUTY_SHIFT		2
45 #define MAX8997_PWM_DUTY_SHIFT		0
46 
47 struct max8997_haptic {
48 	struct device *dev;
49 	struct i2c_client *client;
50 	struct input_dev *input_dev;
51 	struct regulator *regulator;
52 
53 	struct work_struct work;
54 	struct mutex mutex;
55 
56 	bool enabled;
57 	unsigned int level;
58 
59 	struct pwm_device *pwm;
60 	unsigned int pwm_period;
61 	enum max8997_haptic_pwm_divisor pwm_divisor;
62 
63 	enum max8997_haptic_motor_type type;
64 	enum max8997_haptic_pulse_mode mode;
65 
66 	unsigned int internal_mode_pattern;
67 	unsigned int pattern_cycle;
68 	unsigned int pattern_signal_period;
69 };
70 
71 static int max8997_haptic_set_duty_cycle(struct max8997_haptic *chip)
72 {
73 	int ret = 0;
74 
75 	if (chip->mode == MAX8997_EXTERNAL_MODE) {
76 		unsigned int duty = chip->pwm_period * chip->level / 100;
77 		ret = pwm_config(chip->pwm, duty, chip->pwm_period);
78 	} else {
79 		int i;
80 		u8 duty_index = 0;
81 
82 		for (i = 0; i <= 64; i++) {
83 			if (chip->level <= i * 100 / 64) {
84 				duty_index = i;
85 				break;
86 			}
87 		}
88 		switch (chip->internal_mode_pattern) {
89 		case 0:
90 			max8997_write_reg(chip->client,
91 				MAX8997_HAPTIC_REG_SIGPWMDC1, duty_index);
92 			break;
93 		case 1:
94 			max8997_write_reg(chip->client,
95 				MAX8997_HAPTIC_REG_SIGPWMDC2, duty_index);
96 			break;
97 		case 2:
98 			max8997_write_reg(chip->client,
99 				MAX8997_HAPTIC_REG_SIGPWMDC3, duty_index);
100 			break;
101 		case 3:
102 			max8997_write_reg(chip->client,
103 				MAX8997_HAPTIC_REG_SIGPWMDC4, duty_index);
104 			break;
105 		default:
106 			break;
107 		}
108 	}
109 	return ret;
110 }
111 
112 static void max8997_haptic_configure(struct max8997_haptic *chip)
113 {
114 	u8 value;
115 
116 	value = chip->type << MAX8997_MOTOR_TYPE_SHIFT |
117 		chip->enabled << MAX8997_ENABLE_SHIFT |
118 		chip->mode << MAX8997_MODE_SHIFT | chip->pwm_divisor;
119 	max8997_write_reg(chip->client, MAX8997_HAPTIC_REG_CONF2, value);
120 
121 	if (chip->mode == MAX8997_INTERNAL_MODE && chip->enabled) {
122 		value = chip->internal_mode_pattern << MAX8997_CYCLE_SHIFT |
123 			chip->internal_mode_pattern << MAX8997_SIG_PERIOD_SHIFT |
124 			chip->internal_mode_pattern << MAX8997_SIG_DUTY_SHIFT |
125 			chip->internal_mode_pattern << MAX8997_PWM_DUTY_SHIFT;
126 		max8997_write_reg(chip->client,
127 			MAX8997_HAPTIC_REG_DRVCONF, value);
128 
129 		switch (chip->internal_mode_pattern) {
130 		case 0:
131 			value = chip->pattern_cycle << 4;
132 			max8997_write_reg(chip->client,
133 				MAX8997_HAPTIC_REG_CYCLECONF1, value);
134 			value = chip->pattern_signal_period;
135 			max8997_write_reg(chip->client,
136 				MAX8997_HAPTIC_REG_SIGCONF1, value);
137 			break;
138 
139 		case 1:
140 			value = chip->pattern_cycle;
141 			max8997_write_reg(chip->client,
142 				MAX8997_HAPTIC_REG_CYCLECONF1, value);
143 			value = chip->pattern_signal_period;
144 			max8997_write_reg(chip->client,
145 				MAX8997_HAPTIC_REG_SIGCONF2, value);
146 			break;
147 
148 		case 2:
149 			value = chip->pattern_cycle << 4;
150 			max8997_write_reg(chip->client,
151 				MAX8997_HAPTIC_REG_CYCLECONF2, value);
152 			value = chip->pattern_signal_period;
153 			max8997_write_reg(chip->client,
154 				MAX8997_HAPTIC_REG_SIGCONF3, value);
155 			break;
156 
157 		case 3:
158 			value = chip->pattern_cycle;
159 			max8997_write_reg(chip->client,
160 				MAX8997_HAPTIC_REG_CYCLECONF2, value);
161 			value = chip->pattern_signal_period;
162 			max8997_write_reg(chip->client,
163 				MAX8997_HAPTIC_REG_SIGCONF4, value);
164 			break;
165 
166 		default:
167 			break;
168 		}
169 	}
170 }
171 
172 static void max8997_haptic_enable(struct max8997_haptic *chip)
173 {
174 	int error;
175 
176 	mutex_lock(&chip->mutex);
177 
178 	error = max8997_haptic_set_duty_cycle(chip);
179 	if (error) {
180 		dev_err(chip->dev, "set_pwm_cycle failed, error: %d\n", error);
181 		goto out;
182 	}
183 
184 	if (!chip->enabled) {
185 		chip->enabled = true;
186 		regulator_enable(chip->regulator);
187 		max8997_haptic_configure(chip);
188 		if (chip->mode == MAX8997_EXTERNAL_MODE)
189 			pwm_enable(chip->pwm);
190 	}
191 
192 out:
193 	mutex_unlock(&chip->mutex);
194 }
195 
196 static void max8997_haptic_disable(struct max8997_haptic *chip)
197 {
198 	mutex_lock(&chip->mutex);
199 
200 	if (chip->enabled) {
201 		chip->enabled = false;
202 		max8997_haptic_configure(chip);
203 		if (chip->mode == MAX8997_EXTERNAL_MODE)
204 			pwm_disable(chip->pwm);
205 		regulator_disable(chip->regulator);
206 	}
207 
208 	mutex_unlock(&chip->mutex);
209 }
210 
211 static void max8997_haptic_play_effect_work(struct work_struct *work)
212 {
213 	struct max8997_haptic *chip =
214 			container_of(work, struct max8997_haptic, work);
215 
216 	if (chip->level)
217 		max8997_haptic_enable(chip);
218 	else
219 		max8997_haptic_disable(chip);
220 }
221 
222 static int max8997_haptic_play_effect(struct input_dev *dev, void *data,
223 				  struct ff_effect *effect)
224 {
225 	struct max8997_haptic *chip = input_get_drvdata(dev);
226 
227 	chip->level = effect->u.rumble.strong_magnitude;
228 	if (!chip->level)
229 		chip->level = effect->u.rumble.weak_magnitude;
230 
231 	schedule_work(&chip->work);
232 
233 	return 0;
234 }
235 
236 static void max8997_haptic_close(struct input_dev *dev)
237 {
238 	struct max8997_haptic *chip = input_get_drvdata(dev);
239 
240 	cancel_work_sync(&chip->work);
241 	max8997_haptic_disable(chip);
242 }
243 
244 static int max8997_haptic_probe(struct platform_device *pdev)
245 {
246 	struct max8997_dev *iodev = dev_get_drvdata(pdev->dev.parent);
247 	const struct max8997_platform_data *pdata =
248 					dev_get_platdata(iodev->dev);
249 	const struct max8997_haptic_platform_data *haptic_pdata =
250 					pdata->haptic_pdata;
251 	struct max8997_haptic *chip;
252 	struct input_dev *input_dev;
253 	int error;
254 
255 	if (!haptic_pdata) {
256 		dev_err(&pdev->dev, "no haptic platform data\n");
257 		return -EINVAL;
258 	}
259 
260 	chip = kzalloc(sizeof(struct max8997_haptic), GFP_KERNEL);
261 	input_dev = input_allocate_device();
262 	if (!chip || !input_dev) {
263 		dev_err(&pdev->dev, "unable to allocate memory\n");
264 		error = -ENOMEM;
265 		goto err_free_mem;
266 	}
267 
268 	INIT_WORK(&chip->work, max8997_haptic_play_effect_work);
269 	mutex_init(&chip->mutex);
270 
271 	chip->client = iodev->haptic;
272 	chip->dev = &pdev->dev;
273 	chip->input_dev = input_dev;
274 	chip->pwm_period = haptic_pdata->pwm_period;
275 	chip->type = haptic_pdata->type;
276 	chip->mode = haptic_pdata->mode;
277 	chip->pwm_divisor = haptic_pdata->pwm_divisor;
278 
279 	switch (chip->mode) {
280 	case MAX8997_INTERNAL_MODE:
281 		chip->internal_mode_pattern =
282 				haptic_pdata->internal_mode_pattern;
283 		chip->pattern_cycle = haptic_pdata->pattern_cycle;
284 		chip->pattern_signal_period =
285 				haptic_pdata->pattern_signal_period;
286 		break;
287 
288 	case MAX8997_EXTERNAL_MODE:
289 		chip->pwm = pwm_request(haptic_pdata->pwm_channel_id,
290 					"max8997-haptic");
291 		if (IS_ERR(chip->pwm)) {
292 			error = PTR_ERR(chip->pwm);
293 			dev_err(&pdev->dev,
294 				"unable to request PWM for haptic, error: %d\n",
295 				error);
296 			goto err_free_mem;
297 		}
298 		break;
299 
300 	default:
301 		dev_err(&pdev->dev,
302 			"Invalid chip mode specified (%d)\n", chip->mode);
303 		error = -EINVAL;
304 		goto err_free_mem;
305 	}
306 
307 	chip->regulator = regulator_get(&pdev->dev, "inmotor");
308 	if (IS_ERR(chip->regulator)) {
309 		error = PTR_ERR(chip->regulator);
310 		dev_err(&pdev->dev,
311 			"unable to get regulator, error: %d\n",
312 			error);
313 		goto err_free_pwm;
314 	}
315 
316 	input_dev->name = "max8997-haptic";
317 	input_dev->id.version = 1;
318 	input_dev->dev.parent = &pdev->dev;
319 	input_dev->close = max8997_haptic_close;
320 	input_set_drvdata(input_dev, chip);
321 	input_set_capability(input_dev, EV_FF, FF_RUMBLE);
322 
323 	error = input_ff_create_memless(input_dev, NULL,
324 				max8997_haptic_play_effect);
325 	if (error) {
326 		dev_err(&pdev->dev,
327 			"unable to create FF device, error: %d\n",
328 			error);
329 		goto err_put_regulator;
330 	}
331 
332 	error = input_register_device(input_dev);
333 	if (error) {
334 		dev_err(&pdev->dev,
335 			"unable to register input device, error: %d\n",
336 			error);
337 		goto err_destroy_ff;
338 	}
339 
340 	platform_set_drvdata(pdev, chip);
341 	return 0;
342 
343 err_destroy_ff:
344 	input_ff_destroy(input_dev);
345 err_put_regulator:
346 	regulator_put(chip->regulator);
347 err_free_pwm:
348 	if (chip->mode == MAX8997_EXTERNAL_MODE)
349 		pwm_free(chip->pwm);
350 err_free_mem:
351 	input_free_device(input_dev);
352 	kfree(chip);
353 
354 	return error;
355 }
356 
357 static int max8997_haptic_remove(struct platform_device *pdev)
358 {
359 	struct max8997_haptic *chip = platform_get_drvdata(pdev);
360 
361 	input_unregister_device(chip->input_dev);
362 	regulator_put(chip->regulator);
363 
364 	if (chip->mode == MAX8997_EXTERNAL_MODE)
365 		pwm_free(chip->pwm);
366 
367 	kfree(chip);
368 
369 	return 0;
370 }
371 
372 #ifdef CONFIG_PM_SLEEP
373 static int max8997_haptic_suspend(struct device *dev)
374 {
375 	struct platform_device *pdev = to_platform_device(dev);
376 	struct max8997_haptic *chip = platform_get_drvdata(pdev);
377 
378 	max8997_haptic_disable(chip);
379 
380 	return 0;
381 }
382 #endif
383 
384 static SIMPLE_DEV_PM_OPS(max8997_haptic_pm_ops, max8997_haptic_suspend, NULL);
385 
386 static const struct platform_device_id max8997_haptic_id[] = {
387 	{ "max8997-haptic", 0 },
388 	{ },
389 };
390 MODULE_DEVICE_TABLE(i2c, max8997_haptic_id);
391 
392 static struct platform_driver max8997_haptic_driver = {
393 	.driver	= {
394 		.name	= "max8997-haptic",
395 		.owner	= THIS_MODULE,
396 		.pm	= &max8997_haptic_pm_ops,
397 	},
398 	.probe		= max8997_haptic_probe,
399 	.remove		= max8997_haptic_remove,
400 	.id_table	= max8997_haptic_id,
401 };
402 module_platform_driver(max8997_haptic_driver);
403 
404 MODULE_ALIAS("platform:max8997-haptic");
405 MODULE_AUTHOR("Donggeun Kim <dg77.kim@samsung.com>");
406 MODULE_DESCRIPTION("max8997_haptic driver");
407 MODULE_LICENSE("GPL");
408