hid-haptic.c

  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(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}
 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(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(rep, buf);
198	mutex_unlock(&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, rep, HID_REQ_SET_REPORT);
229	mutex_unlock(&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->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
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, 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
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, &haptic->stop_effect);
307
308	play_effect(hdev, haptic, effect);
309	mutex_unlock(&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(haptic->wq, &haptic->effect[effect_id].work);
319	else
320		queue_work(haptic->wq, &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);
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
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(&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
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, 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 = 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(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(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, &stop_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(&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(haptic->stop_effect.report_buf);
549	haptic->stop_effect.report_buf = NULL;
550buffer_free:
551	while (--r >= 0)
552		kfree(haptic->effect[r].report_buf);
553	kfree(haptic->effect);
554	haptic->effect = NULL;
555output_queue:
556	destroy_workqueue(haptic->wq);
557	haptic->wq = NULL;
558duration_map:
559	kfree(haptic->duration_map);
560	haptic->duration_map = NULL;
561usage_map:
562	kfree(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);