1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * HID Haptic support for Linux
4 *
5 * Copyright (c) 2021 Angela Czubak <acz@semihalf.com>
6 */
7
8 #include <linux/input/mt.h>
9 #include <linux/module.h>
10
11 #include "hid-haptic.h"
12
hid_haptic_feature_mapping(struct hid_device * hdev,struct hid_haptic_device * haptic,struct hid_field * field,struct hid_usage * usage)13 void hid_haptic_feature_mapping(struct hid_device *hdev,
14 struct hid_haptic_device *haptic,
15 struct hid_field *field, struct hid_usage *usage)
16 {
17 u16 usage_hid;
18
19 if (usage->hid == HID_HP_AUTOTRIGGER) {
20 if (usage->usage_index >= field->report_count) {
21 dev_err(&hdev->dev,
22 "HID_HP_AUTOTRIGGER out of range\n");
23 return;
24 }
25
26 hid_device_io_start(hdev);
27 hid_hw_request(hdev, field->report, HID_REQ_GET_REPORT);
28 hid_hw_wait(hdev);
29 hid_device_io_stop(hdev);
30 haptic->default_auto_trigger =
31 field->value[usage->usage_index];
32 haptic->auto_trigger_report = field->report;
33 } else if ((usage->hid & HID_USAGE_PAGE) == HID_UP_ORDINAL) {
34 usage_hid = usage->hid & HID_USAGE;
35 switch (field->logical) {
36 case HID_HP_WAVEFORMLIST:
37 if (usage_hid > haptic->max_waveform_id)
38 haptic->max_waveform_id = usage_hid;
39 break;
40 case HID_HP_DURATIONLIST:
41 if (usage_hid > haptic->max_duration_id)
42 haptic->max_duration_id = usage_hid;
43 break;
44 default:
45 break;
46 }
47 }
48 }
49 EXPORT_SYMBOL_GPL(hid_haptic_feature_mapping);
50
hid_haptic_check_pressure_unit(struct hid_haptic_device * haptic,struct hid_input * hi,struct hid_field * field)51 bool hid_haptic_check_pressure_unit(struct hid_haptic_device *haptic,
52 struct hid_input *hi, struct hid_field *field)
53 {
54 if (field->unit == HID_UNIT_GRAM || field->unit == HID_UNIT_NEWTON) {
55 haptic->force_logical_minimum = field->logical_minimum;
56 haptic->force_physical_minimum = field->physical_minimum;
57 haptic->force_resolution = input_abs_get_res(hi->input,
58 ABS_MT_PRESSURE);
59 return true;
60 }
61 return false;
62 }
63 EXPORT_SYMBOL_GPL(hid_haptic_check_pressure_unit);
64
hid_haptic_input_mapping(struct hid_device * hdev,struct hid_haptic_device * haptic,struct hid_input * hi,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max)65 int hid_haptic_input_mapping(struct hid_device *hdev,
66 struct hid_haptic_device *haptic,
67 struct hid_input *hi,
68 struct hid_field *field, struct hid_usage *usage,
69 unsigned long **bit, int *max)
70 {
71 if (usage->hid == HID_HP_MANUALTRIGGER) {
72 haptic->manual_trigger_report = field->report;
73 /* we don't really want to map these fields */
74 return -1;
75 }
76
77 return 0;
78 }
79 EXPORT_SYMBOL_GPL(hid_haptic_input_mapping);
80
hid_haptic_input_configured(struct hid_device * hdev,struct hid_haptic_device * haptic,struct hid_input * hi)81 int hid_haptic_input_configured(struct hid_device *hdev,
82 struct hid_haptic_device *haptic,
83 struct hid_input *hi)
84 {
85
86 if (hi->application == HID_DG_TOUCHPAD) {
87 if (haptic->auto_trigger_report &&
88 haptic->manual_trigger_report) {
89 __set_bit(INPUT_PROP_PRESSUREPAD, hi->input->propbit);
90 return 1;
91 }
92 return 0;
93 }
94 return -1;
95 }
96 EXPORT_SYMBOL_GPL(hid_haptic_input_configured);
97
parse_auto_trigger_field(struct hid_haptic_device * haptic,struct hid_field * field)98 static void parse_auto_trigger_field(struct hid_haptic_device *haptic,
99 struct hid_field *field)
100 {
101 int count = field->report_count;
102 int n;
103 u16 usage_hid;
104
105 for (n = 0; n < count; n++) {
106 switch (field->usage[n].hid & HID_USAGE_PAGE) {
107 case HID_UP_ORDINAL:
108 usage_hid = field->usage[n].hid & HID_USAGE;
109 switch (field->logical) {
110 case HID_HP_WAVEFORMLIST:
111 haptic->hid_usage_map[usage_hid] = field->value[n];
112 if (field->value[n] ==
113 (HID_HP_WAVEFORMPRESS & HID_USAGE)) {
114 haptic->press_ordinal = usage_hid;
115 } else if (field->value[n] ==
116 (HID_HP_WAVEFORMRELEASE & HID_USAGE)) {
117 haptic->release_ordinal = usage_hid;
118 }
119 break;
120 case HID_HP_DURATIONLIST:
121 haptic->duration_map[usage_hid] =
122 field->value[n];
123 break;
124 default:
125 break;
126 }
127 break;
128 case HID_UP_HAPTIC:
129 switch (field->usage[n].hid) {
130 case HID_HP_WAVEFORMVENDORID:
131 haptic->vendor_id = field->value[n];
132 break;
133 case HID_HP_WAVEFORMVENDORPAGE:
134 haptic->vendor_page = field->value[n];
135 break;
136 default:
137 break;
138 }
139 break;
140 default:
141 /* Should not really happen */
142 break;
143 }
144 }
145 }
146
fill_effect_buf(struct hid_haptic_device * haptic,struct ff_haptic_effect * effect,struct hid_haptic_effect * haptic_effect,int waveform_ordinal)147 static void fill_effect_buf(struct hid_haptic_device *haptic,
148 struct ff_haptic_effect *effect,
149 struct hid_haptic_effect *haptic_effect,
150 int waveform_ordinal)
151 {
152 struct hid_report *rep = haptic->manual_trigger_report;
153 struct hid_usage *usage;
154 struct hid_field *field;
155 s32 value;
156 int i, j;
157 u8 *buf = haptic_effect->report_buf;
158
159 mutex_lock(&haptic->manual_trigger_mutex);
160 for (i = 0; i < rep->maxfield; i++) {
161 field = rep->field[i];
162 /* Ignore if report count is out of bounds. */
163 if (field->report_count < 1)
164 continue;
165
166 for (j = 0; j < field->maxusage; j++) {
167 usage = &field->usage[j];
168
169 switch (usage->hid) {
170 case HID_HP_INTENSITY:
171 if (effect->intensity > 100) {
172 value = field->logical_maximum;
173 } else {
174 value = field->logical_minimum +
175 effect->intensity *
176 (field->logical_maximum -
177 field->logical_minimum) / 100;
178 }
179 break;
180 case HID_HP_REPEATCOUNT:
181 value = effect->repeat_count;
182 break;
183 case HID_HP_RETRIGGERPERIOD:
184 value = effect->retrigger_period;
185 break;
186 case HID_HP_MANUALTRIGGER:
187 value = waveform_ordinal;
188 break;
189 default:
190 break;
191 }
192
193 field->value[j] = value;
194 }
195 }
196
197 hid_output_report(rep, buf);
198 mutex_unlock(&haptic->manual_trigger_mutex);
199 }
200
switch_mode(struct hid_device * hdev,struct hid_haptic_device * haptic,int mode)201 static void switch_mode(struct hid_device *hdev, struct hid_haptic_device *haptic,
202 int mode)
203 {
204 struct hid_report *rep = haptic->auto_trigger_report;
205 struct hid_field *field;
206 s32 value;
207 int i, j;
208
209 if (mode == HID_HAPTIC_MODE_HOST)
210 value = HID_HAPTIC_ORDINAL_WAVEFORMSTOP;
211 else
212 value = haptic->default_auto_trigger;
213
214 mutex_lock(&haptic->auto_trigger_mutex);
215 for (i = 0; i < rep->maxfield; i++) {
216 field = rep->field[i];
217 /* Ignore if report count is out of bounds. */
218 if (field->report_count < 1)
219 continue;
220
221 for (j = 0; j < field->maxusage; j++) {
222 if (field->usage[j].hid == HID_HP_AUTOTRIGGER)
223 field->value[j] = value;
224 }
225 }
226
227 /* send the report */
228 hid_hw_request(hdev, rep, HID_REQ_SET_REPORT);
229 mutex_unlock(&haptic->auto_trigger_mutex);
230 haptic->mode = mode;
231 }
232
hid_haptic_upload_effect(struct input_dev * dev,struct ff_effect * effect,struct ff_effect * old)233 static int hid_haptic_upload_effect(struct input_dev *dev, struct ff_effect *effect,
234 struct ff_effect *old)
235 {
236 struct hid_device *hdev = input_get_drvdata(dev);
237 struct ff_device *ff = dev->ff;
238 struct hid_haptic_device *haptic = ff->private;
239 int i, ordinal = 0;
240 bool switch_modes = false;
241
242 /* If vendor range, check vendor id and page */
243 if (effect->u.haptic.hid_usage >= (HID_HP_VENDORWAVEFORMMIN & HID_USAGE) &&
244 effect->u.haptic.hid_usage <= (HID_HP_VENDORWAVEFORMMAX & HID_USAGE) &&
245 (effect->u.haptic.vendor_id != haptic->vendor_id ||
246 effect->u.haptic.vendor_waveform_page != haptic->vendor_page))
247 return -EINVAL;
248
249 /* Check hid_usage */
250 for (i = 1; i <= haptic->max_waveform_id; i++) {
251 if (haptic->hid_usage_map[i] == effect->u.haptic.hid_usage) {
252 ordinal = i;
253 break;
254 }
255 }
256 if (ordinal < 1)
257 return -EINVAL;
258
259 /* Fill the buffer for the effect id */
260 fill_effect_buf(haptic, &effect->u.haptic, &haptic->effect[effect->id],
261 ordinal);
262
263 if (effect->u.haptic.hid_usage == (HID_HP_WAVEFORMPRESS & HID_USAGE) ||
264 effect->u.haptic.hid_usage == (HID_HP_WAVEFORMRELEASE & HID_USAGE))
265 switch_modes = true;
266
267 /* If device is in autonomous mode, and the uploaded effect signals userspace
268 * wants control of the device, change modes
269 */
270 if (switch_modes && haptic->mode == HID_HAPTIC_MODE_DEVICE)
271 switch_mode(hdev, haptic, HID_HAPTIC_MODE_HOST);
272
273 return 0;
274 }
275
play_effect(struct hid_device * hdev,struct hid_haptic_device * haptic,struct hid_haptic_effect * effect)276 static int play_effect(struct hid_device *hdev, struct hid_haptic_device *haptic,
277 struct hid_haptic_effect *effect)
278 {
279 int ret;
280
281 ret = hid_hw_output_report(hdev, effect->report_buf,
282 haptic->manual_trigger_report_len);
283 if (ret < 0) {
284 ret = hid_hw_raw_request(hdev,
285 haptic->manual_trigger_report->id,
286 effect->report_buf,
287 haptic->manual_trigger_report_len,
288 HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
289 }
290
291 return ret;
292 }
293
haptic_work_handler(struct work_struct * work)294 static void haptic_work_handler(struct work_struct *work)
295 {
296
297 struct hid_haptic_effect *effect = container_of(work,
298 struct hid_haptic_effect,
299 work);
300 struct input_dev *dev = effect->input_dev;
301 struct hid_device *hdev = input_get_drvdata(dev);
302 struct hid_haptic_device *haptic = dev->ff->private;
303
304 mutex_lock(&haptic->manual_trigger_mutex);
305 if (effect != &haptic->stop_effect)
306 play_effect(hdev, haptic, &haptic->stop_effect);
307
308 play_effect(hdev, haptic, effect);
309 mutex_unlock(&haptic->manual_trigger_mutex);
310
311 }
312
hid_haptic_playback(struct input_dev * dev,int effect_id,int value)313 static int hid_haptic_playback(struct input_dev *dev, int effect_id, int value)
314 {
315 struct hid_haptic_device *haptic = dev->ff->private;
316
317 if (value)
318 queue_work(haptic->wq, &haptic->effect[effect_id].work);
319 else
320 queue_work(haptic->wq, &haptic->stop_effect.work);
321
322 return 0;
323 }
324
effect_set_default(struct ff_effect * effect)325 static void effect_set_default(struct ff_effect *effect)
326 {
327 effect->type = FF_HAPTIC;
328 effect->id = -1;
329 effect->u.haptic.hid_usage = HID_HP_WAVEFORMNONE & HID_USAGE;
330 effect->u.haptic.intensity = 100;
331 effect->u.haptic.retrigger_period = 0;
332 effect->u.haptic.repeat_count = 0;
333 }
334
hid_haptic_erase(struct input_dev * dev,int effect_id)335 static int hid_haptic_erase(struct input_dev *dev, int effect_id)
336 {
337 struct hid_haptic_device *haptic = dev->ff->private;
338 struct hid_device *hdev = input_get_drvdata(dev);
339 struct ff_effect effect;
340 int ordinal;
341
342 effect_set_default(&effect);
343
344 if (effect.u.haptic.hid_usage == (HID_HP_WAVEFORMRELEASE & HID_USAGE)) {
345 ordinal = haptic->release_ordinal;
346 if (!ordinal) {
347 ordinal = HID_HAPTIC_ORDINAL_WAVEFORMNONE;
348 if (haptic->mode == HID_HAPTIC_MODE_HOST)
349 switch_mode(hdev, haptic, HID_HAPTIC_MODE_DEVICE);
350 } else
351 effect.u.haptic.hid_usage = HID_HP_WAVEFORMRELEASE & HID_USAGE;
352
353 fill_effect_buf(haptic, &effect.u.haptic, &haptic->effect[effect_id],
354 ordinal);
355 } else if (effect.u.haptic.hid_usage == (HID_HP_WAVEFORMPRESS & HID_USAGE)) {
356 ordinal = haptic->press_ordinal;
357 if (!ordinal) {
358 ordinal = HID_HAPTIC_ORDINAL_WAVEFORMNONE;
359 if (haptic->mode == HID_HAPTIC_MODE_HOST)
360 switch_mode(hdev, haptic, HID_HAPTIC_MODE_DEVICE);
361 }
362 else
363 effect.u.haptic.hid_usage = HID_HP_WAVEFORMPRESS & HID_USAGE;
364
365 fill_effect_buf(haptic, &effect.u.haptic, &haptic->effect[effect_id],
366 ordinal);
367 }
368
369 return 0;
370 }
371
hid_haptic_destroy(struct ff_device * ff)372 static void hid_haptic_destroy(struct ff_device *ff)
373 {
374 struct hid_haptic_device *haptic = ff->private;
375 struct hid_device *hdev = haptic->hdev;
376 int r;
377
378 if (hdev)
379 put_device(&hdev->dev);
380
381 kfree(haptic->stop_effect.report_buf);
382 haptic->stop_effect.report_buf = NULL;
383
384 if (haptic->effect) {
385 for (r = 0; r < ff->max_effects; r++)
386 kfree(haptic->effect[r].report_buf);
387 kfree(haptic->effect);
388 }
389 haptic->effect = NULL;
390
391 destroy_workqueue(haptic->wq);
392 haptic->wq = NULL;
393
394 kfree(haptic->duration_map);
395 haptic->duration_map = NULL;
396
397 kfree(haptic->hid_usage_map);
398 haptic->hid_usage_map = NULL;
399
400 module_put(THIS_MODULE);
401 }
402
hid_haptic_init(struct hid_device * hdev,struct hid_haptic_device ** haptic_ptr)403 int hid_haptic_init(struct hid_device *hdev,
404 struct hid_haptic_device **haptic_ptr)
405 {
406 struct hid_haptic_device *haptic = *haptic_ptr;
407 struct input_dev *dev = NULL;
408 struct hid_input *hidinput;
409 struct ff_device *ff;
410 int ret = 0, r;
411 struct ff_haptic_effect stop_effect = {
412 .hid_usage = HID_HP_WAVEFORMSTOP & HID_USAGE,
413 };
414 const char *prefix = "hid-haptic";
415 char *name;
416 int (*flush)(struct input_dev *dev, struct file *file);
417 int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
418
419 haptic->hdev = hdev;
420 haptic->max_waveform_id = max(2u, haptic->max_waveform_id);
421 haptic->max_duration_id = max(2u, haptic->max_duration_id);
422
423 haptic->hid_usage_map = kcalloc(haptic->max_waveform_id + 1,
424 sizeof(u16), GFP_KERNEL);
425 if (!haptic->hid_usage_map) {
426 ret = -ENOMEM;
427 goto exit;
428 }
429 haptic->duration_map = kcalloc(haptic->max_duration_id + 1,
430 sizeof(u32), GFP_KERNEL);
431 if (!haptic->duration_map) {
432 ret = -ENOMEM;
433 goto usage_map;
434 }
435
436 if (haptic->max_waveform_id != haptic->max_duration_id)
437 dev_warn(&hdev->dev,
438 "Haptic duration and waveform lists have different max id (%u and %u).\n",
439 haptic->max_duration_id, haptic->max_waveform_id);
440
441 haptic->hid_usage_map[HID_HAPTIC_ORDINAL_WAVEFORMNONE] =
442 HID_HP_WAVEFORMNONE & HID_USAGE;
443 haptic->hid_usage_map[HID_HAPTIC_ORDINAL_WAVEFORMSTOP] =
444 HID_HP_WAVEFORMSTOP & HID_USAGE;
445
446 mutex_init(&haptic->auto_trigger_mutex);
447 for (r = 0; r < haptic->auto_trigger_report->maxfield; r++)
448 parse_auto_trigger_field(haptic, haptic->auto_trigger_report->field[r]);
449
450 list_for_each_entry(hidinput, &hdev->inputs, list) {
451 if (hidinput->application == HID_DG_TOUCHPAD) {
452 dev = hidinput->input;
453 break;
454 }
455 }
456
457 if (!dev) {
458 dev_err(&hdev->dev, "Failed to find the input device\n");
459 ret = -ENODEV;
460 goto duration_map;
461 }
462
463 haptic->input_dev = dev;
464 haptic->manual_trigger_report_len =
465 hid_report_len(haptic->manual_trigger_report);
466 mutex_init(&haptic->manual_trigger_mutex);
467 name = kmalloc(strlen(prefix) + strlen(hdev->name) + 2, GFP_KERNEL);
468 if (name) {
469 sprintf(name, "%s %s", prefix, hdev->name);
470 haptic->wq = create_singlethread_workqueue(name);
471 kfree(name);
472 }
473 if (!haptic->wq) {
474 ret = -ENOMEM;
475 goto duration_map;
476 }
477 haptic->effect = kzalloc_objs(struct hid_haptic_effect, FF_MAX_EFFECTS);
478 if (!haptic->effect) {
479 ret = -ENOMEM;
480 goto output_queue;
481 }
482 for (r = 0; r < FF_MAX_EFFECTS; r++) {
483 haptic->effect[r].report_buf =
484 hid_alloc_report_buf(haptic->manual_trigger_report,
485 GFP_KERNEL);
486 if (!haptic->effect[r].report_buf) {
487 dev_err(&hdev->dev,
488 "Failed to allocate a buffer for an effect.\n");
489 ret = -ENOMEM;
490 goto buffer_free;
491 }
492 haptic->effect[r].input_dev = dev;
493 INIT_WORK(&haptic->effect[r].work, haptic_work_handler);
494 }
495 haptic->stop_effect.report_buf =
496 hid_alloc_report_buf(haptic->manual_trigger_report,
497 GFP_KERNEL);
498 if (!haptic->stop_effect.report_buf) {
499 dev_err(&hdev->dev,
500 "Failed to allocate a buffer for stop effect.\n");
501 ret = -ENOMEM;
502 goto buffer_free;
503 }
504 haptic->stop_effect.input_dev = dev;
505 INIT_WORK(&haptic->stop_effect.work, haptic_work_handler);
506 fill_effect_buf(haptic, &stop_effect, &haptic->stop_effect,
507 HID_HAPTIC_ORDINAL_WAVEFORMSTOP);
508
509 input_set_capability(dev, EV_FF, FF_HAPTIC);
510
511 flush = dev->flush;
512 event = dev->event;
513 ret = input_ff_create(dev, FF_MAX_EFFECTS);
514 if (ret) {
515 dev_err(&hdev->dev, "Failed to create ff device.\n");
516 goto stop_buffer_free;
517 }
518
519 ff = dev->ff;
520 ff->private = haptic;
521 ff->upload = hid_haptic_upload_effect;
522 ff->playback = hid_haptic_playback;
523 ff->erase = hid_haptic_erase;
524 ff->destroy = hid_haptic_destroy;
525 if (!try_module_get(THIS_MODULE)) {
526 dev_err(&hdev->dev, "Failed to increase module count.\n");
527 goto input_free;
528 }
529 if (!get_device(&hdev->dev)) {
530 dev_err(&hdev->dev, "Failed to get hdev device.\n");
531 module_put(THIS_MODULE);
532 goto input_free;
533 }
534 return 0;
535
536 input_free:
537 input_ff_destroy(dev);
538 /* Do not let double free happen, input_ff_destroy will call
539 * hid_haptic_destroy.
540 */
541 *haptic_ptr = NULL;
542 /* Restore dev flush and event */
543 dev->flush = flush;
544 dev->event = event;
545 return ret;
546 stop_buffer_free:
547 kfree(haptic->stop_effect.report_buf);
548 haptic->stop_effect.report_buf = NULL;
549 buffer_free:
550 while (--r >= 0)
551 kfree(haptic->effect[r].report_buf);
552 kfree(haptic->effect);
553 haptic->effect = NULL;
554 output_queue:
555 destroy_workqueue(haptic->wq);
556 haptic->wq = NULL;
557 duration_map:
558 kfree(haptic->duration_map);
559 haptic->duration_map = NULL;
560 usage_map:
561 kfree(haptic->hid_usage_map);
562 haptic->hid_usage_map = NULL;
563 exit:
564 return ret;
565 }
566 EXPORT_SYMBOL_GPL(hid_haptic_init);
567
hid_haptic_pressure_reset(struct hid_haptic_device * haptic)568 void hid_haptic_pressure_reset(struct hid_haptic_device *haptic)
569 {
570 haptic->pressure_sum = 0;
571 }
572 EXPORT_SYMBOL_GPL(hid_haptic_pressure_reset);
573
hid_haptic_pressure_increase(struct hid_haptic_device * haptic,__s32 pressure)574 void hid_haptic_pressure_increase(struct hid_haptic_device *haptic,
575 __s32 pressure)
576 {
577 haptic->pressure_sum += pressure;
578 }
579 EXPORT_SYMBOL_GPL(hid_haptic_pressure_increase);
580