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
13void 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(hid: hdev);
27 hid_hw_request(hdev, report: field->report, reqtype: HID_REQ_GET_REPORT);
28 hid_hw_wait(hdev);
29 hid_device_io_stop(hid: 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}
49EXPORT_SYMBOL_GPL(hid_haptic_feature_mapping);
50
51bool 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(dev: hi->input,
58 ABS_MT_PRESSURE);
59 return true;
60 }
61 return false;
62}
63EXPORT_SYMBOL_GPL(hid_haptic_check_pressure_unit);
64
65int 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}
79EXPORT_SYMBOL_GPL(hid_haptic_input_mapping);
80
81int 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}
96EXPORT_SYMBOL_GPL(hid_haptic_input_configured);
97
98static 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
147static 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(report: rep, data: buf);
198 mutex_unlock(lock: &haptic->manual_trigger_mutex);
199}
200
201static 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, report: rep, reqtype: HID_REQ_SET_REPORT);
229 mutex_unlock(lock: &haptic->auto_trigger_mutex);
230 haptic->mode = mode;
231}
232
233static 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: &effect->u.haptic, haptic_effect: &haptic->effect[effect->id],
261 waveform_ordinal: 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
276static 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, buf: effect->report_buf,
282 len: haptic->manual_trigger_report_len);
283 if (ret < 0) {
284 ret = hid_hw_raw_request(hdev,
285 reportnum: haptic->manual_trigger_report->id,
286 buf: effect->report_buf,
287 len: haptic->manual_trigger_report_len,
288 rtype: HID_OUTPUT_REPORT, reqtype: HID_REQ_SET_REPORT);
289 }
290
291 return ret;
292}
293
294static 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, effect: &haptic->stop_effect);
307
308 play_effect(hdev, haptic, effect);
309 mutex_unlock(lock: &haptic->manual_trigger_mutex);
310
311}
312
313static 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(wq: haptic->wq, work: &haptic->effect[effect_id].work);
319 else
320 queue_work(wq: haptic->wq, work: &haptic->stop_effect.work);
321
322 return 0;
323}
324
325static 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
335static 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: &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: &effect.u.haptic, haptic_effect: &haptic->effect[effect_id],
354 waveform_ordinal: 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: &effect.u.haptic, haptic_effect: &haptic->effect[effect_id],
366 waveform_ordinal: ordinal);
367 }
368
369 return 0;
370}
371
372static 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(dev: &hdev->dev);
380
381 kfree(objp: 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(objp: haptic->effect[r].report_buf);
387 kfree(objp: haptic->effect);
388 }
389 haptic->effect = NULL;
390
391 destroy_workqueue(wq: haptic->wq);
392 haptic->wq = NULL;
393
394 kfree(objp: haptic->duration_map);
395 haptic->duration_map = NULL;
396
397 kfree(objp: haptic->hid_usage_map);
398 haptic->hid_usage_map = NULL;
399
400 module_put(THIS_MODULE);
401}
402
403int 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, field: 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(report: 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(buf: name, fmt: "%s %s", prefix, hdev->name);
470 haptic->wq = create_singlethread_workqueue(name);
471 kfree(objp: name);
472 }
473 if (!haptic->wq) {
474 ret = -ENOMEM;
475 goto duration_map;
476 }
477 haptic->effect = kcalloc(FF_MAX_EFFECTS,
478 sizeof(struct hid_haptic_effect), GFP_KERNEL);
479 if (!haptic->effect) {
480 ret = -ENOMEM;
481 goto output_queue;
482 }
483 for (r = 0; r < FF_MAX_EFFECTS; r++) {
484 haptic->effect[r].report_buf =
485 hid_alloc_report_buf(report: haptic->manual_trigger_report,
486 GFP_KERNEL);
487 if (!haptic->effect[r].report_buf) {
488 dev_err(&hdev->dev,
489 "Failed to allocate a buffer for an effect.\n");
490 ret = -ENOMEM;
491 goto buffer_free;
492 }
493 haptic->effect[r].input_dev = dev;
494 INIT_WORK(&haptic->effect[r].work, haptic_work_handler);
495 }
496 haptic->stop_effect.report_buf =
497 hid_alloc_report_buf(report: haptic->manual_trigger_report,
498 GFP_KERNEL);
499 if (!haptic->stop_effect.report_buf) {
500 dev_err(&hdev->dev,
501 "Failed to allocate a buffer for stop effect.\n");
502 ret = -ENOMEM;
503 goto buffer_free;
504 }
505 haptic->stop_effect.input_dev = dev;
506 INIT_WORK(&haptic->stop_effect.work, haptic_work_handler);
507 fill_effect_buf(haptic, effect: &stop_effect, haptic_effect: &haptic->stop_effect,
508 HID_HAPTIC_ORDINAL_WAVEFORMSTOP);
509
510 input_set_capability(dev, EV_FF, FF_HAPTIC);
511
512 flush = dev->flush;
513 event = dev->event;
514 ret = input_ff_create(dev, FF_MAX_EFFECTS);
515 if (ret) {
516 dev_err(&hdev->dev, "Failed to create ff device.\n");
517 goto stop_buffer_free;
518 }
519
520 ff = dev->ff;
521 ff->private = haptic;
522 ff->upload = hid_haptic_upload_effect;
523 ff->playback = hid_haptic_playback;
524 ff->erase = hid_haptic_erase;
525 ff->destroy = hid_haptic_destroy;
526 if (!try_module_get(THIS_MODULE)) {
527 dev_err(&hdev->dev, "Failed to increase module count.\n");
528 goto input_free;
529 }
530 if (!get_device(dev: &hdev->dev)) {
531 dev_err(&hdev->dev, "Failed to get hdev device.\n");
532 module_put(THIS_MODULE);
533 goto input_free;
534 }
535 return 0;
536
537input_free:
538 input_ff_destroy(dev);
539 /* Do not let double free happen, input_ff_destroy will call
540 * hid_haptic_destroy.
541 */
542 *haptic_ptr = NULL;
543 /* Restore dev flush and event */
544 dev->flush = flush;
545 dev->event = event;
546 return ret;
547stop_buffer_free:
548 kfree(objp: haptic->stop_effect.report_buf);
549 haptic->stop_effect.report_buf = NULL;
550buffer_free:
551 while (--r >= 0)
552 kfree(objp: haptic->effect[r].report_buf);
553 kfree(objp: haptic->effect);
554 haptic->effect = NULL;
555output_queue:
556 destroy_workqueue(wq: haptic->wq);
557 haptic->wq = NULL;
558duration_map:
559 kfree(objp: haptic->duration_map);
560 haptic->duration_map = NULL;
561usage_map:
562 kfree(objp: haptic->hid_usage_map);
563 haptic->hid_usage_map = NULL;
564exit:
565 return ret;
566}
567EXPORT_SYMBOL_GPL(hid_haptic_init);
568
569void hid_haptic_pressure_reset(struct hid_haptic_device *haptic)
570{
571 haptic->pressure_sum = 0;
572}
573EXPORT_SYMBOL_GPL(hid_haptic_pressure_reset);
574
575void hid_haptic_pressure_increase(struct hid_haptic_device *haptic,
576 __s32 pressure)
577{
578 haptic->pressure_sum += pressure;
579}
580EXPORT_SYMBOL_GPL(hid_haptic_pressure_increase);
581

source code of linux/drivers/hid/hid-haptic.c