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
function_row_physmap_show(struct device * dev,struct device_attribute * attr,char * buf)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
vivaldi_probe(struct hid_device * hdev,const struct hid_device_id * id)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 if (!drvdata)
61 return -ENOMEM;
62
63 hid_set_drvdata(hdev, drvdata);
64
65 ret = hid_parse(hdev);
66 if (ret)
67 return ret;
68
69 return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
70 }
71
vivaldi_feature_mapping(struct hid_device * hdev,struct hid_field * field,struct hid_usage * usage)72 static void vivaldi_feature_mapping(struct hid_device *hdev,
73 struct hid_field *field,
74 struct hid_usage *usage)
75 {
76 struct vivaldi_data *drvdata = hid_get_drvdata(hdev);
77 struct hid_report *report = field->report;
78 int fn_key;
79 int ret;
80 u32 report_len;
81 u8 *report_data, *buf;
82
83 if (field->logical != HID_USAGE_FN_ROW_PHYSMAP ||
84 (usage->hid & HID_USAGE_PAGE) != HID_UP_ORDINAL)
85 return;
86
87 fn_key = (usage->hid & HID_USAGE);
88 if (fn_key < MIN_FN_ROW_KEY || fn_key > MAX_FN_ROW_KEY)
89 return;
90 if (fn_key > drvdata->max_function_row_key)
91 drvdata->max_function_row_key = fn_key;
92
93 report_data = buf = hid_alloc_report_buf(report, GFP_KERNEL);
94 if (!report_data)
95 return;
96
97 report_len = hid_report_len(report);
98 if (!report->id) {
99 /*
100 * hid_hw_raw_request() will stuff report ID (which will be 0)
101 * into the first byte of the buffer even for unnumbered
102 * reports, so we need to account for this to avoid getting
103 * -EOVERFLOW in return.
104 * Note that hid_alloc_report_buf() adds 7 bytes to the size
105 * so we can safely say that we have space for an extra byte.
106 */
107 report_len++;
108 }
109
110 ret = hid_hw_raw_request(hdev, report->id, report_data,
111 report_len, HID_FEATURE_REPORT,
112 HID_REQ_GET_REPORT);
113 if (ret < 0) {
114 dev_warn(&hdev->dev, "failed to fetch feature %d\n",
115 field->report->id);
116 goto out;
117 }
118
119 if (!report->id) {
120 /*
121 * Undo the damage from hid_hw_raw_request() for unnumbered
122 * reports.
123 */
124 report_data++;
125 report_len--;
126 }
127
128 ret = hid_report_raw_event(hdev, HID_FEATURE_REPORT, report_data,
129 report_len, 0);
130 if (ret) {
131 dev_warn(&hdev->dev, "failed to report feature %d\n",
132 field->report->id);
133 goto out;
134 }
135
136 drvdata->function_row_physmap[fn_key - MIN_FN_ROW_KEY] =
137 field->value[usage->usage_index];
138
139 out:
140 kfree(buf);
141 }
142
vivaldi_input_configured(struct hid_device * hdev,struct hid_input * hidinput)143 static int vivaldi_input_configured(struct hid_device *hdev,
144 struct hid_input *hidinput)
145 {
146 return devm_device_add_group(&hdev->dev, &input_attribute_group);
147 }
148
149 static const struct hid_device_id vivaldi_table[] = {
150 { HID_DEVICE(HID_BUS_ANY, HID_GROUP_VIVALDI, HID_ANY_ID,
151 HID_ANY_ID) },
152 { }
153 };
154
155 MODULE_DEVICE_TABLE(hid, vivaldi_table);
156
157 static struct hid_driver hid_vivaldi = {
158 .name = "hid-vivaldi",
159 .id_table = vivaldi_table,
160 .probe = vivaldi_probe,
161 .feature_mapping = vivaldi_feature_mapping,
162 .input_configured = vivaldi_input_configured,
163 };
164
165 module_hid_driver(hid_vivaldi);
166
167 MODULE_AUTHOR("Sean O'Brien");
168 MODULE_DESCRIPTION("HID vivaldi driver");
169 MODULE_LICENSE("GPL");
170