Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * DRV2665 haptics driver family
4 *
5 * Author: Dan Murphy <dmurphy@ti.com>
6 *
7 * Copyright: (C) 2015 Texas Instruments, Inc.
8 */
9
10#include <linux/i2c.h>
11#include <linux/input.h>
12#include <linux/module.h>
13#include <linux/regmap.h>
14#include <linux/slab.h>
15#include <linux/delay.h>
16#include <linux/regulator/consumer.h>
17
18/* Contol registers */
19#define DRV2665_STATUS 0x00
20#define DRV2665_CTRL_1 0x01
21#define DRV2665_CTRL_2 0x02
22#define DRV2665_FIFO 0x0b
23
24/* Status Register */
25#define DRV2665_FIFO_FULL BIT(0)
26#define DRV2665_FIFO_EMPTY BIT(1)
27
28/* Control 1 Register */
29#define DRV2665_25_VPP_GAIN 0x00
30#define DRV2665_50_VPP_GAIN 0x01
31#define DRV2665_75_VPP_GAIN 0x02
32#define DRV2665_100_VPP_GAIN 0x03
33#define DRV2665_DIGITAL_IN 0xfc
34#define DRV2665_ANALOG_IN BIT(2)
35
36/* Control 2 Register */
37#define DRV2665_BOOST_EN BIT(1)
38#define DRV2665_STANDBY BIT(6)
39#define DRV2665_DEV_RST BIT(7)
40#define DRV2665_5_MS_IDLE_TOUT 0x00
41#define DRV2665_10_MS_IDLE_TOUT 0x04
42#define DRV2665_15_MS_IDLE_TOUT 0x08
43#define DRV2665_20_MS_IDLE_TOUT 0x0c
44
45/**
46 * struct drv2665_data -
47 * @input_dev: Pointer to the input device
48 * @client: Pointer to the I2C client
49 * @regmap: Register map of the device
50 * @work: Work item used to off load the enable/disable of the vibration
51 * @regulator: Pointer to the regulator for the IC
52 */
53struct drv2665_data {
54 struct input_dev *input_dev;
55 struct i2c_client *client;
56 struct regmap *regmap;
57 struct work_struct work;
58 struct regulator *regulator;
59};
60
61/* 8kHz Sine wave to stream to the FIFO */
62static const u8 drv2665_sine_wave_form[] = {
63 0x00, 0x10, 0x20, 0x2e, 0x3c, 0x48, 0x53, 0x5b, 0x61, 0x65, 0x66,
64 0x65, 0x61, 0x5b, 0x53, 0x48, 0x3c, 0x2e, 0x20, 0x10,
65 0x00, 0xf0, 0xe0, 0xd2, 0xc4, 0xb8, 0xad, 0xa5, 0x9f, 0x9b, 0x9a,
66 0x9b, 0x9f, 0xa5, 0xad, 0xb8, 0xc4, 0xd2, 0xe0, 0xf0, 0x00,
67};
68
69static const struct reg_default drv2665_reg_defs[] = {
70 { DRV2665_STATUS, 0x02 },
71 { DRV2665_CTRL_1, 0x28 },
72 { DRV2665_CTRL_2, 0x40 },
73 { DRV2665_FIFO, 0x00 },
74};
75
76static void drv2665_worker(struct work_struct *work)
77{
78 struct drv2665_data *haptics =
79 container_of(work, struct drv2665_data, work);
80 unsigned int read_buf;
81 int error;
82
83 error = regmap_read(haptics->regmap, DRV2665_STATUS, &read_buf);
84 if (error) {
85 dev_err(&haptics->client->dev,
86 "Failed to read status: %d\n", error);
87 return;
88 }
89
90 if (read_buf & DRV2665_FIFO_EMPTY) {
91 error = regmap_bulk_write(haptics->regmap,
92 DRV2665_FIFO,
93 drv2665_sine_wave_form,
94 ARRAY_SIZE(drv2665_sine_wave_form));
95 if (error) {
96 dev_err(&haptics->client->dev,
97 "Failed to write FIFO: %d\n", error);
98 return;
99 }
100 }
101}
102
103static int drv2665_haptics_play(struct input_dev *input, void *data,
104 struct ff_effect *effect)
105{
106 struct drv2665_data *haptics = input_get_drvdata(input);
107
108 schedule_work(&haptics->work);
109
110 return 0;
111}
112
113static void drv2665_close(struct input_dev *input)
114{
115 struct drv2665_data *haptics = input_get_drvdata(input);
116 int error;
117
118 cancel_work_sync(&haptics->work);
119
120 error = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
121 DRV2665_STANDBY, DRV2665_STANDBY);
122 if (error)
123 dev_err(&haptics->client->dev,
124 "Failed to enter standby mode: %d\n", error);
125}
126
127static const struct reg_sequence drv2665_init_regs[] = {
128 { DRV2665_CTRL_2, 0 | DRV2665_10_MS_IDLE_TOUT },
129 { DRV2665_CTRL_1, DRV2665_25_VPP_GAIN },
130};
131
132static int drv2665_init(struct drv2665_data *haptics)
133{
134 int error;
135
136 error = regmap_register_patch(haptics->regmap,
137 drv2665_init_regs,
138 ARRAY_SIZE(drv2665_init_regs));
139 if (error) {
140 dev_err(&haptics->client->dev,
141 "Failed to write init registers: %d\n",
142 error);
143 return error;
144 }
145
146 return 0;
147}
148
149static const struct regmap_config drv2665_regmap_config = {
150 .reg_bits = 8,
151 .val_bits = 8,
152
153 .max_register = DRV2665_FIFO,
154 .reg_defaults = drv2665_reg_defs,
155 .num_reg_defaults = ARRAY_SIZE(drv2665_reg_defs),
156 .cache_type = REGCACHE_NONE,
157};
158
159static int drv2665_probe(struct i2c_client *client)
160{
161 struct drv2665_data *haptics;
162 int error;
163
164 haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL);
165 if (!haptics)
166 return -ENOMEM;
167
168 haptics->regulator = devm_regulator_get(&client->dev, "vbat");
169 if (IS_ERR(haptics->regulator)) {
170 error = PTR_ERR(haptics->regulator);
171 dev_err(&client->dev,
172 "unable to get regulator, error: %d\n", error);
173 return error;
174 }
175
176 haptics->input_dev = devm_input_allocate_device(&client->dev);
177 if (!haptics->input_dev) {
178 dev_err(&client->dev, "Failed to allocate input device\n");
179 return -ENOMEM;
180 }
181
182 haptics->input_dev->name = "drv2665:haptics";
183 haptics->input_dev->dev.parent = client->dev.parent;
184 haptics->input_dev->close = drv2665_close;
185 input_set_drvdata(haptics->input_dev, haptics);
186 input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE);
187
188 error = input_ff_create_memless(haptics->input_dev, NULL,
189 drv2665_haptics_play);
190 if (error) {
191 dev_err(&client->dev, "input_ff_create() failed: %d\n",
192 error);
193 return error;
194 }
195
196 INIT_WORK(&haptics->work, drv2665_worker);
197
198 haptics->client = client;
199 i2c_set_clientdata(client, haptics);
200
201 haptics->regmap = devm_regmap_init_i2c(client, &drv2665_regmap_config);
202 if (IS_ERR(haptics->regmap)) {
203 error = PTR_ERR(haptics->regmap);
204 dev_err(&client->dev, "Failed to allocate register map: %d\n",
205 error);
206 return error;
207 }
208
209 error = drv2665_init(haptics);
210 if (error) {
211 dev_err(&client->dev, "Device init failed: %d\n", error);
212 return error;
213 }
214
215 error = input_register_device(haptics->input_dev);
216 if (error) {
217 dev_err(&client->dev, "couldn't register input device: %d\n",
218 error);
219 return error;
220 }
221
222 return 0;
223}
224
225static int drv2665_suspend(struct device *dev)
226{
227 struct drv2665_data *haptics = dev_get_drvdata(dev);
228 int ret = 0;
229
230 mutex_lock(&haptics->input_dev->mutex);
231
232 if (input_device_enabled(haptics->input_dev)) {
233 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
234 DRV2665_STANDBY, DRV2665_STANDBY);
235 if (ret) {
236 dev_err(dev, "Failed to set standby mode\n");
237 regulator_disable(haptics->regulator);
238 goto out;
239 }
240
241 ret = regulator_disable(haptics->regulator);
242 if (ret) {
243 dev_err(dev, "Failed to disable regulator\n");
244 regmap_update_bits(haptics->regmap,
245 DRV2665_CTRL_2,
246 DRV2665_STANDBY, 0);
247 }
248 }
249out:
250 mutex_unlock(&haptics->input_dev->mutex);
251 return ret;
252}
253
254static int drv2665_resume(struct device *dev)
255{
256 struct drv2665_data *haptics = dev_get_drvdata(dev);
257 int ret = 0;
258
259 mutex_lock(&haptics->input_dev->mutex);
260
261 if (input_device_enabled(haptics->input_dev)) {
262 ret = regulator_enable(haptics->regulator);
263 if (ret) {
264 dev_err(dev, "Failed to enable regulator\n");
265 goto out;
266 }
267
268 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
269 DRV2665_STANDBY, 0);
270 if (ret) {
271 dev_err(dev, "Failed to unset standby mode\n");
272 regulator_disable(haptics->regulator);
273 goto out;
274 }
275
276 }
277
278out:
279 mutex_unlock(&haptics->input_dev->mutex);
280 return ret;
281}
282
283static DEFINE_SIMPLE_DEV_PM_OPS(drv2665_pm_ops, drv2665_suspend, drv2665_resume);
284
285static const struct i2c_device_id drv2665_id[] = {
286 { "drv2665", 0 },
287 { }
288};
289MODULE_DEVICE_TABLE(i2c, drv2665_id);
290
291#ifdef CONFIG_OF
292static const struct of_device_id drv2665_of_match[] = {
293 { .compatible = "ti,drv2665", },
294 { }
295};
296MODULE_DEVICE_TABLE(of, drv2665_of_match);
297#endif
298
299static struct i2c_driver drv2665_driver = {
300 .probe = drv2665_probe,
301 .driver = {
302 .name = "drv2665-haptics",
303 .of_match_table = of_match_ptr(drv2665_of_match),
304 .pm = pm_sleep_ptr(&drv2665_pm_ops),
305 },
306 .id_table = drv2665_id,
307};
308module_i2c_driver(drv2665_driver);
309
310MODULE_DESCRIPTION("TI DRV2665 haptics driver");
311MODULE_LICENSE("GPL");
312MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
1/*
2 * DRV2665 haptics driver family
3 *
4 * Author: Dan Murphy <dmurphy@ti.com>
5 *
6 * Copyright: (C) 2015 Texas Instruments, Inc.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 */
17
18#include <linux/i2c.h>
19#include <linux/input.h>
20#include <linux/module.h>
21#include <linux/regmap.h>
22#include <linux/slab.h>
23#include <linux/delay.h>
24#include <linux/regulator/consumer.h>
25
26/* Contol registers */
27#define DRV2665_STATUS 0x00
28#define DRV2665_CTRL_1 0x01
29#define DRV2665_CTRL_2 0x02
30#define DRV2665_FIFO 0x0b
31
32/* Status Register */
33#define DRV2665_FIFO_FULL BIT(0)
34#define DRV2665_FIFO_EMPTY BIT(1)
35
36/* Control 1 Register */
37#define DRV2665_25_VPP_GAIN 0x00
38#define DRV2665_50_VPP_GAIN 0x01
39#define DRV2665_75_VPP_GAIN 0x02
40#define DRV2665_100_VPP_GAIN 0x03
41#define DRV2665_DIGITAL_IN 0xfc
42#define DRV2665_ANALOG_IN BIT(2)
43
44/* Control 2 Register */
45#define DRV2665_BOOST_EN BIT(1)
46#define DRV2665_STANDBY BIT(6)
47#define DRV2665_DEV_RST BIT(7)
48#define DRV2665_5_MS_IDLE_TOUT 0x00
49#define DRV2665_10_MS_IDLE_TOUT 0x04
50#define DRV2665_15_MS_IDLE_TOUT 0x08
51#define DRV2665_20_MS_IDLE_TOUT 0x0c
52
53/**
54 * struct drv2665_data -
55 * @input_dev - Pointer to the input device
56 * @client - Pointer to the I2C client
57 * @regmap - Register map of the device
58 * @work - Work item used to off load the enable/disable of the vibration
59 * @regulator - Pointer to the regulator for the IC
60 */
61struct drv2665_data {
62 struct input_dev *input_dev;
63 struct i2c_client *client;
64 struct regmap *regmap;
65 struct work_struct work;
66 struct regulator *regulator;
67};
68
69/* 8kHz Sine wave to stream to the FIFO */
70static const u8 drv2665_sine_wave_form[] = {
71 0x00, 0x10, 0x20, 0x2e, 0x3c, 0x48, 0x53, 0x5b, 0x61, 0x65, 0x66,
72 0x65, 0x61, 0x5b, 0x53, 0x48, 0x3c, 0x2e, 0x20, 0x10,
73 0x00, 0xf0, 0xe0, 0xd2, 0xc4, 0xb8, 0xad, 0xa5, 0x9f, 0x9b, 0x9a,
74 0x9b, 0x9f, 0xa5, 0xad, 0xb8, 0xc4, 0xd2, 0xe0, 0xf0, 0x00,
75};
76
77static const struct reg_default drv2665_reg_defs[] = {
78 { DRV2665_STATUS, 0x02 },
79 { DRV2665_CTRL_1, 0x28 },
80 { DRV2665_CTRL_2, 0x40 },
81 { DRV2665_FIFO, 0x00 },
82};
83
84static void drv2665_worker(struct work_struct *work)
85{
86 struct drv2665_data *haptics =
87 container_of(work, struct drv2665_data, work);
88 unsigned int read_buf;
89 int error;
90
91 error = regmap_read(haptics->regmap, DRV2665_STATUS, &read_buf);
92 if (error) {
93 dev_err(&haptics->client->dev,
94 "Failed to read status: %d\n", error);
95 return;
96 }
97
98 if (read_buf & DRV2665_FIFO_EMPTY) {
99 error = regmap_bulk_write(haptics->regmap,
100 DRV2665_FIFO,
101 drv2665_sine_wave_form,
102 ARRAY_SIZE(drv2665_sine_wave_form));
103 if (error) {
104 dev_err(&haptics->client->dev,
105 "Failed to write FIFO: %d\n", error);
106 return;
107 }
108 }
109}
110
111static int drv2665_haptics_play(struct input_dev *input, void *data,
112 struct ff_effect *effect)
113{
114 struct drv2665_data *haptics = input_get_drvdata(input);
115
116 schedule_work(&haptics->work);
117
118 return 0;
119}
120
121static void drv2665_close(struct input_dev *input)
122{
123 struct drv2665_data *haptics = input_get_drvdata(input);
124 int error;
125
126 cancel_work_sync(&haptics->work);
127
128 error = regmap_update_bits(haptics->regmap,
129 DRV2665_CTRL_2, DRV2665_STANDBY, 1);
130 if (error)
131 dev_err(&haptics->client->dev,
132 "Failed to enter standby mode: %d\n", error);
133}
134
135static const struct reg_sequence drv2665_init_regs[] = {
136 { DRV2665_CTRL_2, 0 | DRV2665_10_MS_IDLE_TOUT },
137 { DRV2665_CTRL_1, DRV2665_25_VPP_GAIN },
138};
139
140static int drv2665_init(struct drv2665_data *haptics)
141{
142 int error;
143
144 error = regmap_register_patch(haptics->regmap,
145 drv2665_init_regs,
146 ARRAY_SIZE(drv2665_init_regs));
147 if (error) {
148 dev_err(&haptics->client->dev,
149 "Failed to write init registers: %d\n",
150 error);
151 return error;
152 }
153
154 return 0;
155}
156
157static const struct regmap_config drv2665_regmap_config = {
158 .reg_bits = 8,
159 .val_bits = 8,
160
161 .max_register = DRV2665_FIFO,
162 .reg_defaults = drv2665_reg_defs,
163 .num_reg_defaults = ARRAY_SIZE(drv2665_reg_defs),
164 .cache_type = REGCACHE_NONE,
165};
166
167static int drv2665_probe(struct i2c_client *client,
168 const struct i2c_device_id *id)
169{
170 struct drv2665_data *haptics;
171 int error;
172
173 haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL);
174 if (!haptics)
175 return -ENOMEM;
176
177 haptics->regulator = devm_regulator_get(&client->dev, "vbat");
178 if (IS_ERR(haptics->regulator)) {
179 error = PTR_ERR(haptics->regulator);
180 dev_err(&client->dev,
181 "unable to get regulator, error: %d\n", error);
182 return error;
183 }
184
185 haptics->input_dev = devm_input_allocate_device(&client->dev);
186 if (!haptics->input_dev) {
187 dev_err(&client->dev, "Failed to allocate input device\n");
188 return -ENOMEM;
189 }
190
191 haptics->input_dev->name = "drv2665:haptics";
192 haptics->input_dev->dev.parent = client->dev.parent;
193 haptics->input_dev->close = drv2665_close;
194 input_set_drvdata(haptics->input_dev, haptics);
195 input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE);
196
197 error = input_ff_create_memless(haptics->input_dev, NULL,
198 drv2665_haptics_play);
199 if (error) {
200 dev_err(&client->dev, "input_ff_create() failed: %d\n",
201 error);
202 return error;
203 }
204
205 INIT_WORK(&haptics->work, drv2665_worker);
206
207 haptics->client = client;
208 i2c_set_clientdata(client, haptics);
209
210 haptics->regmap = devm_regmap_init_i2c(client, &drv2665_regmap_config);
211 if (IS_ERR(haptics->regmap)) {
212 error = PTR_ERR(haptics->regmap);
213 dev_err(&client->dev, "Failed to allocate register map: %d\n",
214 error);
215 return error;
216 }
217
218 error = drv2665_init(haptics);
219 if (error) {
220 dev_err(&client->dev, "Device init failed: %d\n", error);
221 return error;
222 }
223
224 error = input_register_device(haptics->input_dev);
225 if (error) {
226 dev_err(&client->dev, "couldn't register input device: %d\n",
227 error);
228 return error;
229 }
230
231 return 0;
232}
233
234static int __maybe_unused drv2665_suspend(struct device *dev)
235{
236 struct drv2665_data *haptics = dev_get_drvdata(dev);
237 int ret = 0;
238
239 mutex_lock(&haptics->input_dev->mutex);
240
241 if (haptics->input_dev->users) {
242 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
243 DRV2665_STANDBY, 1);
244 if (ret) {
245 dev_err(dev, "Failed to set standby mode\n");
246 regulator_disable(haptics->regulator);
247 goto out;
248 }
249
250 ret = regulator_disable(haptics->regulator);
251 if (ret) {
252 dev_err(dev, "Failed to disable regulator\n");
253 regmap_update_bits(haptics->regmap,
254 DRV2665_CTRL_2,
255 DRV2665_STANDBY, 0);
256 }
257 }
258out:
259 mutex_unlock(&haptics->input_dev->mutex);
260 return ret;
261}
262
263static int __maybe_unused drv2665_resume(struct device *dev)
264{
265 struct drv2665_data *haptics = dev_get_drvdata(dev);
266 int ret = 0;
267
268 mutex_lock(&haptics->input_dev->mutex);
269
270 if (haptics->input_dev->users) {
271 ret = regulator_enable(haptics->regulator);
272 if (ret) {
273 dev_err(dev, "Failed to enable regulator\n");
274 goto out;
275 }
276
277 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
278 DRV2665_STANDBY, 0);
279 if (ret) {
280 dev_err(dev, "Failed to unset standby mode\n");
281 regulator_disable(haptics->regulator);
282 goto out;
283 }
284
285 }
286
287out:
288 mutex_unlock(&haptics->input_dev->mutex);
289 return ret;
290}
291
292static SIMPLE_DEV_PM_OPS(drv2665_pm_ops, drv2665_suspend, drv2665_resume);
293
294static const struct i2c_device_id drv2665_id[] = {
295 { "drv2665", 0 },
296 { }
297};
298MODULE_DEVICE_TABLE(i2c, drv2665_id);
299
300#ifdef CONFIG_OF
301static const struct of_device_id drv2665_of_match[] = {
302 { .compatible = "ti,drv2665", },
303 { }
304};
305MODULE_DEVICE_TABLE(of, drv2665_of_match);
306#endif
307
308static struct i2c_driver drv2665_driver = {
309 .probe = drv2665_probe,
310 .driver = {
311 .name = "drv2665-haptics",
312 .of_match_table = of_match_ptr(drv2665_of_match),
313 .pm = &drv2665_pm_ops,
314 },
315 .id_table = drv2665_id,
316};
317module_i2c_driver(drv2665_driver);
318
319MODULE_DESCRIPTION("TI DRV2665 haptics driver");
320MODULE_LICENSE("GPL");
321MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");