ishtp-hid.c

  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 */
 21static 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 */
 36static int ishtp_hid_start(struct hid_device *hid)
 37{
 38	return 0;
 39}
 40
 41static void ishtp_hid_stop(struct hid_device *hid)
 42{
 43}
 44
 45static int ishtp_hid_open(struct hid_device *hid)
 46{
 47	return 0;
 48}
 49
 50static void ishtp_hid_close(struct hid_device *hid)
 51{
 52}
 53
 54static 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 */
104static 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 */
145static 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 */
178void 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
186static 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 */
206int 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
249err_hid_device:
250	kfree(hid_data);
251err_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 */
262void ishtp_hid_remove(struct ishtp_cl_data *client_data)
263{
264	void *data;
265	int i;
266
267	for (i = 0; i < client_data->num_hid_devices; ++i) {
268		if (client_data->hid_sensor_hubs[i]) {
269			data = client_data->hid_sensor_hubs[i]->driver_data;
270			hid_destroy_device(client_data->hid_sensor_hubs[i]);
271			kfree(data);
272			client_data->hid_sensor_hubs[i] = NULL;
273		}
274	}
275}