This source file includes following definitions.
- drv2665_worker
- drv2665_haptics_play
- drv2665_close
- drv2665_init
- drv2665_probe
- drv2665_suspend
- drv2665_resume
1
2
3
4
5
6
7
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
19 #define DRV2665_STATUS 0x00
20 #define DRV2665_CTRL_1 0x01
21 #define DRV2665_CTRL_2 0x02
22 #define DRV2665_FIFO 0x0b
23
24
25 #define DRV2665_FIFO_FULL BIT(0)
26 #define DRV2665_FIFO_EMPTY BIT(1)
27
28
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
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
47
48
49
50
51
52
53 struct 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
62 static 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
69 static 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
76 static 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
103 static 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
113 static 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
127 static 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
132 static 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
149 static 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
159 static int drv2665_probe(struct i2c_client *client,
160 const struct i2c_device_id *id)
161 {
162 struct drv2665_data *haptics;
163 int error;
164
165 haptics = devm_kzalloc(&client->dev, sizeof(*haptics), GFP_KERNEL);
166 if (!haptics)
167 return -ENOMEM;
168
169 haptics->regulator = devm_regulator_get(&client->dev, "vbat");
170 if (IS_ERR(haptics->regulator)) {
171 error = PTR_ERR(haptics->regulator);
172 dev_err(&client->dev,
173 "unable to get regulator, error: %d\n", error);
174 return error;
175 }
176
177 haptics->input_dev = devm_input_allocate_device(&client->dev);
178 if (!haptics->input_dev) {
179 dev_err(&client->dev, "Failed to allocate input device\n");
180 return -ENOMEM;
181 }
182
183 haptics->input_dev->name = "drv2665:haptics";
184 haptics->input_dev->dev.parent = client->dev.parent;
185 haptics->input_dev->close = drv2665_close;
186 input_set_drvdata(haptics->input_dev, haptics);
187 input_set_capability(haptics->input_dev, EV_FF, FF_RUMBLE);
188
189 error = input_ff_create_memless(haptics->input_dev, NULL,
190 drv2665_haptics_play);
191 if (error) {
192 dev_err(&client->dev, "input_ff_create() failed: %d\n",
193 error);
194 return error;
195 }
196
197 INIT_WORK(&haptics->work, drv2665_worker);
198
199 haptics->client = client;
200 i2c_set_clientdata(client, haptics);
201
202 haptics->regmap = devm_regmap_init_i2c(client, &drv2665_regmap_config);
203 if (IS_ERR(haptics->regmap)) {
204 error = PTR_ERR(haptics->regmap);
205 dev_err(&client->dev, "Failed to allocate register map: %d\n",
206 error);
207 return error;
208 }
209
210 error = drv2665_init(haptics);
211 if (error) {
212 dev_err(&client->dev, "Device init failed: %d\n", error);
213 return error;
214 }
215
216 error = input_register_device(haptics->input_dev);
217 if (error) {
218 dev_err(&client->dev, "couldn't register input device: %d\n",
219 error);
220 return error;
221 }
222
223 return 0;
224 }
225
226 static int __maybe_unused drv2665_suspend(struct device *dev)
227 {
228 struct drv2665_data *haptics = dev_get_drvdata(dev);
229 int ret = 0;
230
231 mutex_lock(&haptics->input_dev->mutex);
232
233 if (haptics->input_dev->users) {
234 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
235 DRV2665_STANDBY, DRV2665_STANDBY);
236 if (ret) {
237 dev_err(dev, "Failed to set standby mode\n");
238 regulator_disable(haptics->regulator);
239 goto out;
240 }
241
242 ret = regulator_disable(haptics->regulator);
243 if (ret) {
244 dev_err(dev, "Failed to disable regulator\n");
245 regmap_update_bits(haptics->regmap,
246 DRV2665_CTRL_2,
247 DRV2665_STANDBY, 0);
248 }
249 }
250 out:
251 mutex_unlock(&haptics->input_dev->mutex);
252 return ret;
253 }
254
255 static int __maybe_unused drv2665_resume(struct device *dev)
256 {
257 struct drv2665_data *haptics = dev_get_drvdata(dev);
258 int ret = 0;
259
260 mutex_lock(&haptics->input_dev->mutex);
261
262 if (haptics->input_dev->users) {
263 ret = regulator_enable(haptics->regulator);
264 if (ret) {
265 dev_err(dev, "Failed to enable regulator\n");
266 goto out;
267 }
268
269 ret = regmap_update_bits(haptics->regmap, DRV2665_CTRL_2,
270 DRV2665_STANDBY, 0);
271 if (ret) {
272 dev_err(dev, "Failed to unset standby mode\n");
273 regulator_disable(haptics->regulator);
274 goto out;
275 }
276
277 }
278
279 out:
280 mutex_unlock(&haptics->input_dev->mutex);
281 return ret;
282 }
283
284 static SIMPLE_DEV_PM_OPS(drv2665_pm_ops, drv2665_suspend, drv2665_resume);
285
286 static const struct i2c_device_id drv2665_id[] = {
287 { "drv2665", 0 },
288 { }
289 };
290 MODULE_DEVICE_TABLE(i2c, drv2665_id);
291
292 #ifdef CONFIG_OF
293 static const struct of_device_id drv2665_of_match[] = {
294 { .compatible = "ti,drv2665", },
295 { }
296 };
297 MODULE_DEVICE_TABLE(of, drv2665_of_match);
298 #endif
299
300 static struct i2c_driver drv2665_driver = {
301 .probe = drv2665_probe,
302 .driver = {
303 .name = "drv2665-haptics",
304 .of_match_table = of_match_ptr(drv2665_of_match),
305 .pm = &drv2665_pm_ops,
306 },
307 .id_table = drv2665_id,
308 };
309 module_i2c_driver(drv2665_driver);
310
311 MODULE_DESCRIPTION("TI DRV2665 haptics driver");
312 MODULE_LICENSE("GPL");
313 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");