[linux-block.git] / drivers / hid / hid-vivaldi.c

// SPDX-License-Identifier: GPL-2.0
/*
 * HID support for Vivaldi Keyboard
 *
 * Copyright 2020 Google LLC.
 * Author: Sean O'Brien <seobrien@chromium.org>
 */

#include <linux/hid.h>
#include <linux/module.h>

#define MIN_FN_ROW_KEY	1
#define MAX_FN_ROW_KEY	24
#define HID_VD_FN_ROW_PHYSMAP 0x00000001
#define HID_USAGE_FN_ROW_PHYSMAP (HID_UP_GOOGLEVENDOR | HID_VD_FN_ROW_PHYSMAP)

static struct hid_driver hid_vivaldi;

struct vivaldi_data {
	u32 function_row_physmap[MAX_FN_ROW_KEY - MIN_FN_ROW_KEY + 1];
	int max_function_row_key;
};

static ssize_t function_row_physmap_show(struct device *dev,
					 struct device_attribute *attr,
					 char *buf)
{
	struct hid_device *hdev = to_hid_device(dev);
	struct vivaldi_data *drvdata = hid_get_drvdata(hdev);
	ssize_t size = 0;
	int i;

	if (!drvdata->max_function_row_key)
		return 0;

	for (i = 0; i < drvdata->max_function_row_key; i++)
		size += sprintf(buf + size, "%02X ",
				drvdata->function_row_physmap[i]);
	size += sprintf(buf + size, "\n");
	return size;
}

DEVICE_ATTR_RO(function_row_physmap);
static struct attribute *sysfs_attrs[] = {
	&dev_attr_function_row_physmap.attr,
	NULL
};

static const struct attribute_group input_attribute_group = {
	.attrs = sysfs_attrs
};

static int vivaldi_probe(struct hid_device *hdev,
			 const struct hid_device_id *id)
{
	struct vivaldi_data *drvdata;
	int ret;

	drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL);
	hid_set_drvdata(hdev, drvdata);

	ret = hid_parse(hdev);
	if (ret)
		return ret;

	return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
}

static void vivaldi_feature_mapping(struct hid_device *hdev,
				    struct hid_field *field,
				    struct hid_usage *usage)
{
	struct vivaldi_data *drvdata = hid_get_drvdata(hdev);
	int fn_key;
	int ret;
	u32 report_len;
	u8 *buf;

	if (field->logical != HID_USAGE_FN_ROW_PHYSMAP ||
	    (usage->hid & HID_USAGE_PAGE) != HID_UP_ORDINAL)
		return;

	fn_key = (usage->hid & HID_USAGE);
	if (fn_key < MIN_FN_ROW_KEY || fn_key > MAX_FN_ROW_KEY)
		return;
	if (fn_key > drvdata->max_function_row_key)
		drvdata->max_function_row_key = fn_key;

	buf = hid_alloc_report_buf(field->report, GFP_KERNEL);
	if (!buf)
		return;

	report_len = hid_report_len(field->report);
	ret = hid_hw_raw_request(hdev, field->report->id, buf,
				 report_len, HID_FEATURE_REPORT,
				 HID_REQ_GET_REPORT);
	if (ret < 0) {
		dev_warn(&hdev->dev, "failed to fetch feature %d\n",
			 field->report->id);
		goto out;
	}

	ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
				   report_len, 0);
	if (ret) {
		dev_warn(&hdev->dev, "failed to report feature %d\n",
			 field->report->id);
		goto out;
	}

	drvdata->function_row_physmap[fn_key - MIN_FN_ROW_KEY] =
	    field->value[usage->usage_index];

out:
	kfree(buf);
}

static int vivaldi_input_configured(struct hid_device *hdev,
				    struct hid_input *hidinput)
{
	return sysfs_create_group(&hdev->dev.kobj, &input_attribute_group);
}

static const struct hid_device_id vivaldi_table[] = {
	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_VIVALDI, HID_ANY_ID,
		     HID_ANY_ID) },
	{ }
};

MODULE_DEVICE_TABLE(hid, vivaldi_table);

static struct hid_driver hid_vivaldi = {
	.name = "hid-vivaldi",
	.id_table = vivaldi_table,
	.probe = vivaldi_probe,
	.feature_mapping = vivaldi_feature_mapping,
	.input_configured = vivaldi_input_configured,
};

module_hid_driver(hid_vivaldi);

MODULE_AUTHOR("Sean O'Brien");
MODULE_DESCRIPTION("HID vivaldi driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
14c9c014 SB	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* HID support for Vivaldi Keyboard
	4	*
	5	* Copyright 2020 Google LLC.
	6	* Author: Sean O'Brien <seobrien@chromium.org>
	7	*/
	8
	9	#include <linux/hid.h>
	10	#include <linux/module.h>
	11
	12	#define MIN_FN_ROW_KEY 1
	13	#define MAX_FN_ROW_KEY 24
	14	#define HID_VD_FN_ROW_PHYSMAP 0x00000001
	15	#define HID_USAGE_FN_ROW_PHYSMAP (HID_UP_GOOGLEVENDOR \| HID_VD_FN_ROW_PHYSMAP)
	16
	17	static struct hid_driver hid_vivaldi;
	18
	19	struct vivaldi_data {
	20	u32 function_row_physmap[MAX_FN_ROW_KEY - MIN_FN_ROW_KEY + 1];
	21	int max_function_row_key;
	22	};
	23
	24	static ssize_t function_row_physmap_show(struct device *dev,
	25	struct device_attribute *attr,
	26	char *buf)
	27	{
	28	struct hid_device *hdev = to_hid_device(dev);
	29	struct vivaldi_data *drvdata = hid_get_drvdata(hdev);
	30	ssize_t size = 0;
	31	int i;
	32
	33	if (!drvdata->max_function_row_key)
	34	return 0;
	35
	36	for (i = 0; i < drvdata->max_function_row_key; i++)
	37	size += sprintf(buf + size, "%02X ",
	38	drvdata->function_row_physmap[i]);
	39	size += sprintf(buf + size, "\n");
	40	return size;
	41	}
	42
	43	DEVICE_ATTR_RO(function_row_physmap);
	44	static struct attribute *sysfs_attrs[] = {
	45	&dev_attr_function_row_physmap.attr,
	46	NULL
	47	};
	48
	49	static const struct attribute_group input_attribute_group = {
	50	.attrs = sysfs_attrs
	51	};
	52
	53	static int vivaldi_probe(struct hid_device *hdev,
	54	const struct hid_device_id *id)
	55	{
	56	struct vivaldi_data *drvdata;
	57	int ret;
	58
	59	drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL);
	60	hid_set_drvdata(hdev, drvdata);
	61
	62	ret = hid_parse(hdev);
	63	if (ret)
	64	return ret;
65
66	return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
67	}
68
69	static void vivaldi_feature_mapping(struct hid_device *hdev,
70	struct hid_field *field,
71	struct hid_usage *usage)
72	{
73	struct vivaldi_data *drvdata = hid_get_drvdata(hdev);
74	int fn_key;
75	int ret;
76	u32 report_len;
77	u8 *buf;
78
79	if (field->logical != HID_USAGE_FN_ROW_PHYSMAP \|\|
80	(usage->hid & HID_USAGE_PAGE) != HID_UP_ORDINAL)
81	return;
82
83	fn_key = (usage->hid & HID_USAGE);
84	if (fn_key < MIN_FN_ROW_KEY \|\| fn_key > MAX_FN_ROW_KEY)
85	return;
86	if (fn_key > drvdata->max_function_row_key)
87	drvdata->max_function_row_key = fn_key;
88
89	buf = hid_alloc_report_buf(field->report, GFP_KERNEL);
90	if (!buf)
91	return;
92
93	report_len = hid_report_len(field->report);
94	ret = hid_hw_raw_request(hdev, field->report->id, buf,
95	report_len, HID_FEATURE_REPORT,
96	HID_REQ_GET_REPORT);
97	if (ret < 0) {
98	dev_warn(&hdev->dev, "failed to fetch feature %d\n",
99	field->report->id);
100	goto out;
101	}
102
103	ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, buf,
104	report_len, 0);
105	if (ret) {
106	dev_warn(&hdev->dev, "failed to report feature %d\n",
107	field->report->id);
108	goto out;
109	}
110
111	drvdata->function_row_physmap[fn_key - MIN_FN_ROW_KEY] =
112	field->value[usage->usage_index];
113
114	out:
115	kfree(buf);
116	}
117
118	static int vivaldi_input_configured(struct hid_device *hdev,
119	struct hid_input *hidinput)
120	{
121	return sysfs_create_group(&hdev->dev.kobj, &input_attribute_group);
122	}
123
124	static const struct hid_device_id vivaldi_table[] = {
125	{ HID_DEVICE(HID_BUS_ANY, HID_GROUP_VIVALDI, HID_ANY_ID,
126	HID_ANY_ID) },
127	{ }
128	};
129
130	MODULE_DEVICE_TABLE(hid, vivaldi_table);
131
132	static struct hid_driver hid_vivaldi = {
133	.name = "hid-vivaldi",
134	.id_table = vivaldi_table,
135	.probe = vivaldi_probe,
136	.feature_mapping = vivaldi_feature_mapping,
137	.input_configured = vivaldi_input_configured,
138	};
139
140	module_hid_driver(hid_vivaldi);
141
142	MODULE_AUTHOR("Sean O'Brien");
143	MODULE_DESCRIPTION("HID vivaldi driver");
144	MODULE_LICENSE("GPL");