source: mainline/uspace/lib/drv/generic/remote_usbhid.c@ a46e56b

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a46e56b was a46e56b, checked in by Jakub Jermar <jakub@…>, 7 years ago

Prefer handle over ID in naming handle variables
  • Property mode set to 100644
File size: 11.6 KB
Line 
1/*
2 * Copyright (c) 2010-2011 Vojtech Horky
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup libdrv
30 * @{
31 */
32/** @file
33 */
34
35#include <async.h>
36#include <errno.h>
37#include <assert.h>
38#include <stdio.h>
39#include <macros.h>
40
41#include "usbhid_iface.h"
42#include "ddf/driver.h"
43
44/** IPC methods for USB HID device interface. */
45typedef enum {
46 /** Get number of events reported in single burst.
47 * Parameters: none
48 * Answer:
49 * - Size of one report in bytes.
50 */
51 IPC_M_USBHID_GET_EVENT_LENGTH,
52 /** Get single event from the HID device.
53 * The word single refers to set of individual events that were
54 * available at particular point in time.
55 * Parameters:
56 * - flags
57 * The call is followed by data read expecting two concatenated
58 * arrays.
59 * Answer:
60 * - EOK - events returned
61 * - EAGAIN - no event ready (only in non-blocking mode)
62 *
63 * It is okay if the client requests less data. Extra data must
64 * be truncated by the driver.
65 *
66 * @todo Change this comment.
67 */
68 IPC_M_USBHID_GET_EVENT,
69
70 /** Get the size of the report descriptor from the HID device.
71 *
72 * Parameters:
73 * - none
74 * Answer:
75 * - EOK - method is implemented (expected always)
76 * Parameters of the answer:
77 * - Size of the report in bytes.
78 */
79 IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH,
80
81 /** Get the report descriptor from the HID device.
82 *
83 * Parameters:
84 * - none
85 * The call is followed by data read expecting the descriptor itself.
86 * Answer:
87 * - EOK - report descriptor returned.
88 */
89 IPC_M_USBHID_GET_REPORT_DESCRIPTOR
90} usbhid_iface_funcs_t;
91
92/** Ask for event array length.
93 *
94 * @param dev_sess Session to DDF device providing USB HID interface.
95 *
96 * @return Number of usages returned or an error code.
97 *
98 */
99errno_t usbhid_dev_get_event_length(async_sess_t *dev_sess, size_t *size)
100{
101 if (!dev_sess)
102 return EINVAL;
103
104 async_exch_t *exch = async_exchange_begin(dev_sess);
105
106 sysarg_t len;
107 errno_t rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
108 IPC_M_USBHID_GET_EVENT_LENGTH, &len);
109
110 async_exchange_end(exch);
111
112 if (rc == EOK) {
113 if (size != NULL)
114 *size = (size_t) len;
115 }
116
117 return rc;
118}
119
120/** Request for next event from HID device.
121 *
122 * @param[in] dev_sess Session to DDF device providing USB HID interface.
123 * @param[out] usage_pages Where to store usage pages.
124 * @param[out] usages Where to store usages (actual data).
125 * @param[in] usage_count Length of @p usage_pages and @p usages buffer
126 * (in items, not bytes).
127 * @param[out] actual_usage_count Number of usages actually returned by the
128 * device driver.
129 * @param[in] flags Flags (see USBHID_IFACE_FLAG_*).
130 *
131 * @return Error code.
132 *
133 */
134errno_t usbhid_dev_get_event(async_sess_t *dev_sess, uint8_t *buf,
135 size_t size, size_t *actual_size, int *event_nr, unsigned int flags)
136{
137 if (!dev_sess)
138 return EINVAL;
139
140 if (buf == NULL)
141 return ENOMEM;
142
143 if (size == 0)
144 return EINVAL;
145
146 size_t buffer_size = size;
147 uint8_t *buffer = malloc(buffer_size);
148 if (buffer == NULL)
149 return ENOMEM;
150
151 async_exch_t *exch = async_exchange_begin(dev_sess);
152
153 ipc_call_t opening_request_call;
154 aid_t opening_request = async_send_2(exch,
155 DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_EVENT,
156 flags, &opening_request_call);
157
158 if (opening_request == 0) {
159 async_exchange_end(exch);
160 free(buffer);
161 return ENOMEM;
162 }
163
164 ipc_call_t data_request_call;
165 aid_t data_request = async_data_read(exch, buffer, buffer_size,
166 &data_request_call);
167
168 async_exchange_end(exch);
169
170 if (data_request == 0) {
171 async_forget(opening_request);
172 free(buffer);
173 return ENOMEM;
174 }
175
176 errno_t data_request_rc;
177 errno_t opening_request_rc;
178 async_wait_for(data_request, &data_request_rc);
179 async_wait_for(opening_request, &opening_request_rc);
180
181 if (data_request_rc != EOK) {
182 /* Prefer return code of the opening request. */
183 if (opening_request_rc != EOK)
184 return (errno_t) opening_request_rc;
185 else
186 return (errno_t) data_request_rc;
187 }
188
189 if (opening_request_rc != EOK)
190 return (errno_t) opening_request_rc;
191
192 size_t act_size = IPC_GET_ARG2(data_request_call);
193
194 /* Copy the individual items. */
195 memcpy(buf, buffer, act_size);
196
197 if (actual_size != NULL)
198 *actual_size = act_size;
199
200 if (event_nr != NULL)
201 *event_nr = IPC_GET_ARG1(opening_request_call);
202
203 return EOK;
204}
205
206errno_t usbhid_dev_get_report_descriptor_length(async_sess_t *dev_sess,
207 size_t *size)
208{
209 if (!dev_sess)
210 return EINVAL;
211
212 async_exch_t *exch = async_exchange_begin(dev_sess);
213
214 sysarg_t arg_size;
215 errno_t rc = async_req_1_1(exch, DEV_IFACE_ID(USBHID_DEV_IFACE),
216 IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH, &arg_size);
217
218 async_exchange_end(exch);
219
220 if (rc == EOK) {
221 if (size != NULL)
222 *size = (size_t) arg_size;
223 }
224
225 return rc;
226}
227
228errno_t usbhid_dev_get_report_descriptor(async_sess_t *dev_sess, uint8_t *buf,
229 size_t size, size_t *actual_size)
230{
231 if (!dev_sess)
232 return EINVAL;
233
234 if (buf == NULL)
235 return ENOMEM;
236
237 if (size == 0)
238 return EINVAL;
239
240 async_exch_t *exch = async_exchange_begin(dev_sess);
241
242 aid_t opening_request = async_send_1(exch,
243 DEV_IFACE_ID(USBHID_DEV_IFACE), IPC_M_USBHID_GET_REPORT_DESCRIPTOR,
244 NULL);
245 if (opening_request == 0) {
246 async_exchange_end(exch);
247 return ENOMEM;
248 }
249
250 ipc_call_t data_request_call;
251 aid_t data_request = async_data_read(exch, buf, size,
252 &data_request_call);
253
254 async_exchange_end(exch);
255
256 if (data_request == 0) {
257 async_forget(opening_request);
258 return ENOMEM;
259 }
260
261 errno_t data_request_rc;
262 errno_t opening_request_rc;
263 async_wait_for(data_request, &data_request_rc);
264 async_wait_for(opening_request, &opening_request_rc);
265
266 if (data_request_rc != EOK) {
267 /* Prefer return code of the opening request. */
268 if (opening_request_rc != EOK)
269 return (errno_t) opening_request_rc;
270 else
271 return (errno_t) data_request_rc;
272 }
273
274 if (opening_request_rc != EOK)
275 return (errno_t) opening_request_rc;
276
277 size_t act_size = IPC_GET_ARG2(data_request_call);
278
279 if (actual_size != NULL)
280 *actual_size = act_size;
281
282 return EOK;
283}
284
285static void remote_usbhid_get_event_length(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
286static void remote_usbhid_get_event(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
287static void remote_usbhid_get_report_descriptor_length(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
288static void remote_usbhid_get_report_descriptor(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
289// static void remote_usbhid_(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
290
291/** Remote USB HID interface operations. */
292static const remote_iface_func_ptr_t remote_usbhid_iface_ops [] = {
293 [IPC_M_USBHID_GET_EVENT_LENGTH] = remote_usbhid_get_event_length,
294 [IPC_M_USBHID_GET_EVENT] = remote_usbhid_get_event,
295 [IPC_M_USBHID_GET_REPORT_DESCRIPTOR_LENGTH] =
296 remote_usbhid_get_report_descriptor_length,
297 [IPC_M_USBHID_GET_REPORT_DESCRIPTOR] = remote_usbhid_get_report_descriptor
298};
299
300/** Remote USB HID interface structure.
301 */
302const remote_iface_t remote_usbhid_iface = {
303 .method_count = ARRAY_SIZE(remote_usbhid_iface_ops),
304 .methods = remote_usbhid_iface_ops
305};
306
307//usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
308
309
310void remote_usbhid_get_event_length(ddf_fun_t *fun, void *iface,
311 cap_call_handle_t chandle, ipc_call_t *call)
312{
313 printf("remote_usbhid_get_event_length()\n");
314
315 usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
316
317 if (!hid_iface->get_event_length) {
318 printf("Get event length not set!\n");
319 async_answer_0(chandle, ENOTSUP);
320 return;
321 }
322
323 size_t len = hid_iface->get_event_length(fun);
324// if (len == 0) {
325// len = EEMPTY;
326// }
327 async_answer_1(chandle, EOK, len);
328
329// if (len < 0) {
330// async_answer_0(chandle, len);
331// } else {
332// async_answer_1(chandle, EOK, len);
333// }
334}
335
336void remote_usbhid_get_event(ddf_fun_t *fun, void *iface,
337 cap_call_handle_t chandle, ipc_call_t *call)
338{
339 usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
340
341 if (!hid_iface->get_event) {
342 async_answer_0(chandle, ENOTSUP);
343 return;
344 }
345
346 unsigned int flags = DEV_IPC_GET_ARG1(*call);
347
348 size_t len;
349 cap_call_handle_t data_chandle;
350 if (!async_data_read_receive(&data_chandle, &len)) {
351 async_answer_0(chandle, EPARTY);
352 return;
353 }
354// /* Check that length is even number. Truncate otherwise. */
355// if ((len % 2) == 1) {
356// len--;
357// }
358 if (len == 0) {
359 async_answer_0(data_chandle, EINVAL);
360 async_answer_0(chandle, EINVAL);
361 return;
362 }
363
364 errno_t rc;
365
366 uint8_t *data = malloc(len);
367 if (data == NULL) {
368 async_answer_0(data_chandle, ENOMEM);
369 async_answer_0(chandle, ENOMEM);
370 return;
371 }
372
373 size_t act_length;
374 int event_nr;
375 rc = hid_iface->get_event(fun, data, len, &act_length, &event_nr, flags);
376 if (rc != EOK) {
377 free(data);
378 async_answer_0(data_chandle, rc);
379 async_answer_0(chandle, rc);
380 return;
381 }
382 if (act_length >= len) {
383 /* This shall not happen. */
384 // FIXME: how about an assert here?
385 act_length = len;
386 }
387
388 async_data_read_finalize(data_chandle, data, act_length);
389
390 free(data);
391
392 async_answer_1(chandle, EOK, event_nr);
393}
394
395void remote_usbhid_get_report_descriptor_length(ddf_fun_t *fun, void *iface,
396 cap_call_handle_t chandle, ipc_call_t *call)
397{
398 usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
399
400 if (!hid_iface->get_report_descriptor_length) {
401 async_answer_0(chandle, ENOTSUP);
402 return;
403 }
404
405 size_t len = hid_iface->get_report_descriptor_length(fun);
406 async_answer_1(chandle, EOK, (sysarg_t) len);
407}
408
409void remote_usbhid_get_report_descriptor(ddf_fun_t *fun, void *iface,
410 cap_call_handle_t chandle, ipc_call_t *call)
411{
412 usbhid_iface_t *hid_iface = (usbhid_iface_t *) iface;
413
414 if (!hid_iface->get_report_descriptor) {
415 async_answer_0(chandle, ENOTSUP);
416 return;
417 }
418
419 size_t len;
420 cap_call_handle_t data_chandle;
421 if (!async_data_read_receive(&data_chandle, &len)) {
422 async_answer_0(chandle, EINVAL);
423 return;
424 }
425
426 if (len == 0) {
427 async_answer_0(data_chandle, EINVAL);
428 async_answer_0(chandle, EINVAL);
429 return;
430 }
431
432 uint8_t *descriptor = malloc(len);
433 if (descriptor == NULL) {
434 async_answer_0(data_chandle, ENOMEM);
435 async_answer_0(chandle, ENOMEM);
436 return;
437 }
438
439 size_t act_len = 0;
440 errno_t rc = hid_iface->get_report_descriptor(fun, descriptor, len,
441 &act_len);
442 if (act_len > len) {
443 rc = ELIMIT;
444 }
445 if (rc != EOK) {
446 free(descriptor);
447 async_answer_0(data_chandle, rc);
448 async_answer_0(chandle, rc);
449 return;
450 }
451
452 async_data_read_finalize(data_chandle, descriptor, act_len);
453 async_answer_0(chandle, EOK);
454
455 free(descriptor);
456}
457
458
459
460/**
461 * @}
462 */
Note: See TracBrowser for help on using the repository browser.