1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * ISHTP-HID glue driver.
4 *
5 * Copyright (c) 2012-2016, Intel Corporation.
6 */
7
8 #include <linux/hid.h>
9 #include <linux/intel-ish-client-if.h>
10 #include <uapi/linux/input.h>
11 #include "ishtp-hid.h"
12
13 /**
14 * ishtp_hid_parse() - hid-core .parse() callback
15 * @hid: hid device instance
16 *
17 * This function gets called during call to hid_add_device
18 *
19 * Return: 0 on success and non zero on error
20 */
ishtp_hid_parse(struct hid_device * hid)21 static int ishtp_hid_parse(struct hid_device *hid)
22 {
23 struct ishtp_hid_data *hid_data = hid->driver_data;
24 struct ishtp_cl_data *client_data = hid_data->client_data;
25 int rv;
26
27 rv = hid_parse_report(hid, client_data->report_descr[hid_data->index],
28 client_data->report_descr_size[hid_data->index]);
29 if (rv)
30 return rv;
31
32 return 0;
33 }
34
35 /* Empty callbacks with success return code */
ishtp_hid_start(struct hid_device * hid)36 static int ishtp_hid_start(struct hid_device *hid)
37 {
38 return 0;
39 }
40
ishtp_hid_stop(struct hid_device * hid)41 static void ishtp_hid_stop(struct hid_device *hid)
42 {
43 }
44
ishtp_hid_open(struct hid_device * hid)45 static int ishtp_hid_open(struct hid_device *hid)
46 {
47 return 0;
48 }
49
ishtp_hid_close(struct hid_device * hid)50 static void ishtp_hid_close(struct hid_device *hid)
51 {
52 }
53
ishtp_raw_request(struct hid_device * hid,unsigned char reportnum,__u8 * buf,size_t len,unsigned char rtype,int reqtype)54 static int ishtp_raw_request(struct hid_device *hid, unsigned char reportnum,
55 __u8 *buf, size_t len, unsigned char rtype,
56 int reqtype)
57 {
58 struct ishtp_hid_data *hid_data = hid->driver_data;
59 char *ishtp_buf = NULL;
60 size_t ishtp_buf_len;
61 unsigned int header_size = sizeof(struct hostif_msg);
62
63 if (rtype == HID_OUTPUT_REPORT)
64 return -EINVAL;
65
66 hid_data->request_done = false;
67 switch (reqtype) {
68 case HID_REQ_GET_REPORT:
69 hid_data->raw_buf = buf;
70 hid_data->raw_buf_size = len;
71 hid_data->raw_get_req = true;
72
73 hid_ishtp_get_report(hid, reportnum, rtype);
74 break;
75 case HID_REQ_SET_REPORT:
76 /*
77 * Spare 7 bytes for 64b accesses through
78 * get/put_unaligned_le64()
79 */
80 ishtp_buf_len = len + header_size;
81 ishtp_buf = kzalloc(ishtp_buf_len + 7, GFP_KERNEL);
82 if (!ishtp_buf)
83 return -ENOMEM;
84
85 memcpy(ishtp_buf + header_size, buf, len);
86 hid_ishtp_set_feature(hid, ishtp_buf, ishtp_buf_len, reportnum);
87 kfree(ishtp_buf);
88 break;
89 }
90
91 hid_hw_wait(hid);
92
93 return len;
94 }
95
96 /**
97 * ishtp_hid_request() - hid-core .request() callback
98 * @hid: hid device instance
99 * @rep: pointer to hid_report
100 * @reqtype: type of req. [GET|SET]_REPORT
101 *
102 * This function is used to set/get feaure/input report.
103 */
ishtp_hid_request(struct hid_device * hid,struct hid_report * rep,int reqtype)104 static void ishtp_hid_request(struct hid_device *hid, struct hid_report *rep,
105 int reqtype)
106 {
107 struct ishtp_hid_data *hid_data = hid->driver_data;
108 /* the specific report length, just HID part of it */
109 unsigned int len = ((rep->size - 1) >> 3) + 1 + (rep->id > 0);
110 char *buf;
111 unsigned int header_size = sizeof(struct hostif_msg);
112
113 len += header_size;
114
115 hid_data->request_done = false;
116 switch (reqtype) {
117 case HID_REQ_GET_REPORT:
118 hid_data->raw_get_req = false;
119 hid_ishtp_get_report(hid, rep->id, rep->type);
120 break;
121 case HID_REQ_SET_REPORT:
122 /*
123 * Spare 7 bytes for 64b accesses through
124 * get/put_unaligned_le64()
125 */
126 buf = kzalloc(len + 7, GFP_KERNEL);
127 if (!buf)
128 return;
129
130 hid_output_report(rep, buf + header_size);
131 hid_ishtp_set_feature(hid, buf, len, rep->id);
132 kfree(buf);
133 break;
134 }
135 }
136
137 /**
138 * ishtp_wait_for_response() - hid-core .wait() callback
139 * @hid: hid device instance
140 *
141 * This function is used to wait after get feaure/input report.
142 *
143 * Return: 0 on success and non zero on error
144 */
ishtp_wait_for_response(struct hid_device * hid)145 static int ishtp_wait_for_response(struct hid_device *hid)
146 {
147 struct ishtp_hid_data *hid_data = hid->driver_data;
148 int rv;
149
150 hid_ishtp_trace(client_data, "%s hid %p\n", __func__, hid);
151
152 rv = ishtp_hid_link_ready_wait(hid_data->client_data);
153 if (rv)
154 return rv;
155
156 if (!hid_data->request_done)
157 wait_event_interruptible_timeout(hid_data->hid_wait,
158 hid_data->request_done, 3 * HZ);
159
160 if (!hid_data->request_done) {
161 hid_err(hid,
162 "timeout waiting for response from ISHTP device\n");
163 return -ETIMEDOUT;
164 }
165 hid_ishtp_trace(client_data, "%s hid %p done\n", __func__, hid);
166
167 hid_data->request_done = false;
168
169 return 0;
170 }
171
172 /**
173 * ishtp_hid_wakeup() - Wakeup caller
174 * @hid: hid device instance
175 *
176 * This function will wakeup caller waiting for Get/Set feature report
177 */
ishtp_hid_wakeup(struct hid_device * hid)178 void ishtp_hid_wakeup(struct hid_device *hid)
179 {
180 struct ishtp_hid_data *hid_data = hid->driver_data;
181
182 hid_data->request_done = true;
183 wake_up_interruptible(&hid_data->hid_wait);
184 }
185
186 static const struct hid_ll_driver ishtp_hid_ll_driver = {
187 .parse = ishtp_hid_parse,
188 .start = ishtp_hid_start,
189 .stop = ishtp_hid_stop,
190 .open = ishtp_hid_open,
191 .close = ishtp_hid_close,
192 .request = ishtp_hid_request,
193 .wait = ishtp_wait_for_response,
194 .raw_request = ishtp_raw_request
195 };
196
197 /**
198 * ishtp_hid_probe() - hid register ll driver
199 * @cur_hid_dev: Index of hid device calling to register
200 * @client_data: Client data pointer
201 *
202 * This function is used to allocate and add HID device.
203 *
204 * Return: 0 on success, non zero on error
205 */
ishtp_hid_probe(unsigned int cur_hid_dev,struct ishtp_cl_data * client_data)206 int ishtp_hid_probe(unsigned int cur_hid_dev,
207 struct ishtp_cl_data *client_data)
208 {
209 int rv;
210 struct hid_device *hid;
211 struct ishtp_hid_data *hid_data;
212
213 hid = hid_allocate_device();
214 if (IS_ERR(hid))
215 return PTR_ERR(hid);
216
217 hid_data = kzalloc(sizeof(*hid_data), GFP_KERNEL);
218 if (!hid_data) {
219 rv = -ENOMEM;
220 goto err_hid_data;
221 }
222
223 hid_data->index = cur_hid_dev;
224 hid_data->client_data = client_data;
225 init_waitqueue_head(&hid_data->hid_wait);
226
227 hid->driver_data = hid_data;
228
229 client_data->hid_sensor_hubs[cur_hid_dev] = hid;
230
231 hid->ll_driver = &ishtp_hid_ll_driver;
232 hid->bus = BUS_INTEL_ISHTP;
233 hid->dev.parent = ishtp_device(client_data->cl_device);
234
235 hid->version = le16_to_cpu(ISH_HID_VERSION);
236 hid->vendor = le16_to_cpu(client_data->hid_devices[cur_hid_dev].vid);
237 hid->product = le16_to_cpu(client_data->hid_devices[cur_hid_dev].pid);
238 snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-ishtp",
239 hid->vendor, hid->product);
240
241 rv = hid_add_device(hid);
242 if (rv)
243 goto err_hid_device;
244
245 hid_ishtp_trace(client_data, "%s allocated hid %p\n", __func__, hid);
246
247 return 0;
248
249 err_hid_device:
250 kfree(hid_data);
251 err_hid_data:
252 hid_destroy_device(hid);
253 return rv;
254 }
255
256 /**
257 * ishtp_hid_remove() - Remove registered hid device
258 * @client_data: client data pointer
259 *
260 * This function is used to destroy allocatd HID device.
261 */
ishtp_hid_remove(struct ishtp_cl_data * client_data)262 void ishtp_hid_remove(struct ishtp_cl_data *client_data)
263 {
264 int i;
265
266 for (i = 0; i < client_data->num_hid_devices; ++i) {
267 if (client_data->hid_sensor_hubs[i]) {
268 kfree(client_data->hid_sensor_hubs[i]->driver_data);
269 hid_destroy_device(client_data->hid_sensor_hubs[i]);
270 client_data->hid_sensor_hubs[i] = NULL;
271 }
272 }
273 }
274