Commit | Line | Data |
---|---|---|
71adf118 FC |
1 | /* |
2 | * f_hid.c -- USB HID function driver | |
3 | * | |
4 | * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
71adf118 FC |
10 | */ |
11 | ||
12 | #include <linux/kernel.h> | |
13 | #include <linux/utsname.h> | |
14 | #include <linux/module.h> | |
15 | #include <linux/hid.h> | |
16 | #include <linux/cdev.h> | |
17 | #include <linux/mutex.h> | |
18 | #include <linux/poll.h> | |
71adf118 FC |
19 | #include <linux/uaccess.h> |
20 | #include <linux/wait.h> | |
21 | #include <linux/usb/g_hid.h> | |
22 | ||
23 | static int major, minors; | |
24 | static struct class *hidg_class; | |
25 | ||
26 | /*-------------------------------------------------------------------------*/ | |
27 | /* HID gadget struct */ | |
28 | ||
99c51500 DM |
29 | struct f_hidg_req_list { |
30 | struct usb_request *req; | |
31 | unsigned int pos; | |
32 | struct list_head list; | |
33 | }; | |
34 | ||
71adf118 FC |
35 | struct f_hidg { |
36 | /* configuration */ | |
37 | unsigned char bInterfaceSubClass; | |
38 | unsigned char bInterfaceProtocol; | |
39 | unsigned short report_desc_length; | |
40 | char *report_desc; | |
41 | unsigned short report_length; | |
42 | ||
43 | /* recv report */ | |
99c51500 | 44 | struct list_head completed_out_req; |
71adf118 FC |
45 | spinlock_t spinlock; |
46 | wait_queue_head_t read_queue; | |
99c51500 | 47 | unsigned int qlen; |
71adf118 FC |
48 | |
49 | /* send report */ | |
50 | struct mutex lock; | |
51 | bool write_pending; | |
52 | wait_queue_head_t write_queue; | |
53 | struct usb_request *req; | |
54 | ||
55 | int minor; | |
56 | struct cdev cdev; | |
57 | struct usb_function func; | |
99c51500 | 58 | |
71adf118 | 59 | struct usb_ep *in_ep; |
99c51500 | 60 | struct usb_ep *out_ep; |
71adf118 FC |
61 | }; |
62 | ||
63 | static inline struct f_hidg *func_to_hidg(struct usb_function *f) | |
64 | { | |
65 | return container_of(f, struct f_hidg, func); | |
66 | } | |
67 | ||
68 | /*-------------------------------------------------------------------------*/ | |
69 | /* Static descriptors */ | |
70 | ||
71 | static struct usb_interface_descriptor hidg_interface_desc = { | |
72 | .bLength = sizeof hidg_interface_desc, | |
73 | .bDescriptorType = USB_DT_INTERFACE, | |
74 | /* .bInterfaceNumber = DYNAMIC */ | |
75 | .bAlternateSetting = 0, | |
99c51500 | 76 | .bNumEndpoints = 2, |
71adf118 FC |
77 | .bInterfaceClass = USB_CLASS_HID, |
78 | /* .bInterfaceSubClass = DYNAMIC */ | |
79 | /* .bInterfaceProtocol = DYNAMIC */ | |
80 | /* .iInterface = DYNAMIC */ | |
81 | }; | |
82 | ||
83 | static struct hid_descriptor hidg_desc = { | |
84 | .bLength = sizeof hidg_desc, | |
85 | .bDescriptorType = HID_DT_HID, | |
86 | .bcdHID = 0x0101, | |
87 | .bCountryCode = 0x00, | |
88 | .bNumDescriptors = 0x1, | |
89 | /*.desc[0].bDescriptorType = DYNAMIC */ | |
90 | /*.desc[0].wDescriptorLenght = DYNAMIC */ | |
91 | }; | |
92 | ||
93 | /* High-Speed Support */ | |
94 | ||
95 | static struct usb_endpoint_descriptor hidg_hs_in_ep_desc = { | |
96 | .bLength = USB_DT_ENDPOINT_SIZE, | |
97 | .bDescriptorType = USB_DT_ENDPOINT, | |
98 | .bEndpointAddress = USB_DIR_IN, | |
99 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
100 | /*.wMaxPacketSize = DYNAMIC */ | |
101 | .bInterval = 4, /* FIXME: Add this field in the | |
102 | * HID gadget configuration? | |
103 | * (struct hidg_func_descriptor) | |
104 | */ | |
105 | }; | |
106 | ||
99c51500 DM |
107 | static struct usb_endpoint_descriptor hidg_hs_out_ep_desc = { |
108 | .bLength = USB_DT_ENDPOINT_SIZE, | |
109 | .bDescriptorType = USB_DT_ENDPOINT, | |
110 | .bEndpointAddress = USB_DIR_OUT, | |
111 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
112 | /*.wMaxPacketSize = DYNAMIC */ | |
113 | .bInterval = 4, /* FIXME: Add this field in the | |
114 | * HID gadget configuration? | |
115 | * (struct hidg_func_descriptor) | |
116 | */ | |
117 | }; | |
118 | ||
71adf118 FC |
119 | static struct usb_descriptor_header *hidg_hs_descriptors[] = { |
120 | (struct usb_descriptor_header *)&hidg_interface_desc, | |
121 | (struct usb_descriptor_header *)&hidg_desc, | |
122 | (struct usb_descriptor_header *)&hidg_hs_in_ep_desc, | |
99c51500 | 123 | (struct usb_descriptor_header *)&hidg_hs_out_ep_desc, |
71adf118 FC |
124 | NULL, |
125 | }; | |
126 | ||
127 | /* Full-Speed Support */ | |
128 | ||
129 | static struct usb_endpoint_descriptor hidg_fs_in_ep_desc = { | |
130 | .bLength = USB_DT_ENDPOINT_SIZE, | |
131 | .bDescriptorType = USB_DT_ENDPOINT, | |
132 | .bEndpointAddress = USB_DIR_IN, | |
133 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
134 | /*.wMaxPacketSize = DYNAMIC */ | |
135 | .bInterval = 10, /* FIXME: Add this field in the | |
136 | * HID gadget configuration? | |
137 | * (struct hidg_func_descriptor) | |
138 | */ | |
139 | }; | |
140 | ||
99c51500 DM |
141 | static struct usb_endpoint_descriptor hidg_fs_out_ep_desc = { |
142 | .bLength = USB_DT_ENDPOINT_SIZE, | |
143 | .bDescriptorType = USB_DT_ENDPOINT, | |
144 | .bEndpointAddress = USB_DIR_OUT, | |
145 | .bmAttributes = USB_ENDPOINT_XFER_INT, | |
146 | /*.wMaxPacketSize = DYNAMIC */ | |
147 | .bInterval = 10, /* FIXME: Add this field in the | |
148 | * HID gadget configuration? | |
149 | * (struct hidg_func_descriptor) | |
150 | */ | |
151 | }; | |
152 | ||
71adf118 FC |
153 | static struct usb_descriptor_header *hidg_fs_descriptors[] = { |
154 | (struct usb_descriptor_header *)&hidg_interface_desc, | |
155 | (struct usb_descriptor_header *)&hidg_desc, | |
156 | (struct usb_descriptor_header *)&hidg_fs_in_ep_desc, | |
99c51500 | 157 | (struct usb_descriptor_header *)&hidg_fs_out_ep_desc, |
71adf118 FC |
158 | NULL, |
159 | }; | |
160 | ||
161 | /*-------------------------------------------------------------------------*/ | |
162 | /* Char Device */ | |
163 | ||
164 | static ssize_t f_hidg_read(struct file *file, char __user *buffer, | |
165 | size_t count, loff_t *ptr) | |
166 | { | |
99c51500 DM |
167 | struct f_hidg *hidg = file->private_data; |
168 | struct f_hidg_req_list *list; | |
169 | struct usb_request *req; | |
170 | unsigned long flags; | |
171 | int ret; | |
71adf118 FC |
172 | |
173 | if (!count) | |
174 | return 0; | |
175 | ||
176 | if (!access_ok(VERIFY_WRITE, buffer, count)) | |
177 | return -EFAULT; | |
178 | ||
179 | spin_lock_irqsave(&hidg->spinlock, flags); | |
180 | ||
99c51500 | 181 | #define READ_COND (!list_empty(&hidg->completed_out_req)) |
71adf118 | 182 | |
99c51500 | 183 | /* wait for at least one buffer to complete */ |
71adf118 FC |
184 | while (!READ_COND) { |
185 | spin_unlock_irqrestore(&hidg->spinlock, flags); | |
186 | if (file->f_flags & O_NONBLOCK) | |
187 | return -EAGAIN; | |
188 | ||
189 | if (wait_event_interruptible(hidg->read_queue, READ_COND)) | |
190 | return -ERESTARTSYS; | |
191 | ||
192 | spin_lock_irqsave(&hidg->spinlock, flags); | |
193 | } | |
194 | ||
99c51500 DM |
195 | /* pick the first one */ |
196 | list = list_first_entry(&hidg->completed_out_req, | |
197 | struct f_hidg_req_list, list); | |
198 | req = list->req; | |
199 | count = min_t(unsigned int, count, req->actual - list->pos); | |
71adf118 FC |
200 | spin_unlock_irqrestore(&hidg->spinlock, flags); |
201 | ||
99c51500 DM |
202 | /* copy to user outside spinlock */ |
203 | count -= copy_to_user(buffer, req->buf + list->pos, count); | |
204 | list->pos += count; | |
205 | ||
206 | /* | |
207 | * if this request is completely handled and transfered to | |
208 | * userspace, remove its entry from the list and requeue it | |
209 | * again. Otherwise, we will revisit it again upon the next | |
210 | * call, taking into account its current read position. | |
211 | */ | |
212 | if (list->pos == req->actual) { | |
213 | spin_lock_irqsave(&hidg->spinlock, flags); | |
214 | list_del(&list->list); | |
215 | kfree(list); | |
216 | spin_unlock_irqrestore(&hidg->spinlock, flags); | |
217 | ||
218 | req->length = hidg->report_length; | |
219 | ret = usb_ep_queue(hidg->out_ep, req, GFP_KERNEL); | |
220 | if (ret < 0) | |
221 | return ret; | |
222 | } | |
71adf118 FC |
223 | |
224 | return count; | |
225 | } | |
226 | ||
227 | static void f_hidg_req_complete(struct usb_ep *ep, struct usb_request *req) | |
228 | { | |
229 | struct f_hidg *hidg = (struct f_hidg *)ep->driver_data; | |
230 | ||
231 | if (req->status != 0) { | |
232 | ERROR(hidg->func.config->cdev, | |
233 | "End Point Request ERROR: %d\n", req->status); | |
234 | } | |
235 | ||
236 | hidg->write_pending = 0; | |
237 | wake_up(&hidg->write_queue); | |
238 | } | |
239 | ||
240 | static ssize_t f_hidg_write(struct file *file, const char __user *buffer, | |
241 | size_t count, loff_t *offp) | |
242 | { | |
fd63b10b | 243 | struct f_hidg *hidg = file->private_data; |
71adf118 FC |
244 | ssize_t status = -ENOMEM; |
245 | ||
246 | if (!access_ok(VERIFY_READ, buffer, count)) | |
247 | return -EFAULT; | |
248 | ||
249 | mutex_lock(&hidg->lock); | |
250 | ||
251 | #define WRITE_COND (!hidg->write_pending) | |
252 | ||
253 | /* write queue */ | |
254 | while (!WRITE_COND) { | |
255 | mutex_unlock(&hidg->lock); | |
256 | if (file->f_flags & O_NONBLOCK) | |
257 | return -EAGAIN; | |
258 | ||
259 | if (wait_event_interruptible_exclusive( | |
260 | hidg->write_queue, WRITE_COND)) | |
261 | return -ERESTARTSYS; | |
262 | ||
263 | mutex_lock(&hidg->lock); | |
264 | } | |
265 | ||
266 | count = min_t(unsigned, count, hidg->report_length); | |
267 | status = copy_from_user(hidg->req->buf, buffer, count); | |
268 | ||
269 | if (status != 0) { | |
270 | ERROR(hidg->func.config->cdev, | |
271 | "copy_from_user error\n"); | |
272 | mutex_unlock(&hidg->lock); | |
273 | return -EINVAL; | |
274 | } | |
275 | ||
276 | hidg->req->status = 0; | |
277 | hidg->req->zero = 0; | |
278 | hidg->req->length = count; | |
279 | hidg->req->complete = f_hidg_req_complete; | |
280 | hidg->req->context = hidg; | |
281 | hidg->write_pending = 1; | |
282 | ||
283 | status = usb_ep_queue(hidg->in_ep, hidg->req, GFP_ATOMIC); | |
284 | if (status < 0) { | |
285 | ERROR(hidg->func.config->cdev, | |
286 | "usb_ep_queue error on int endpoint %zd\n", status); | |
287 | hidg->write_pending = 0; | |
288 | wake_up(&hidg->write_queue); | |
289 | } else { | |
290 | status = count; | |
291 | } | |
292 | ||
293 | mutex_unlock(&hidg->lock); | |
294 | ||
295 | return status; | |
296 | } | |
297 | ||
298 | static unsigned int f_hidg_poll(struct file *file, poll_table *wait) | |
299 | { | |
fd63b10b | 300 | struct f_hidg *hidg = file->private_data; |
71adf118 FC |
301 | unsigned int ret = 0; |
302 | ||
303 | poll_wait(file, &hidg->read_queue, wait); | |
304 | poll_wait(file, &hidg->write_queue, wait); | |
305 | ||
306 | if (WRITE_COND) | |
307 | ret |= POLLOUT | POLLWRNORM; | |
308 | ||
309 | if (READ_COND) | |
310 | ret |= POLLIN | POLLRDNORM; | |
311 | ||
312 | return ret; | |
313 | } | |
314 | ||
315 | #undef WRITE_COND | |
316 | #undef READ_COND | |
317 | ||
318 | static int f_hidg_release(struct inode *inode, struct file *fd) | |
319 | { | |
320 | fd->private_data = NULL; | |
321 | return 0; | |
322 | } | |
323 | ||
324 | static int f_hidg_open(struct inode *inode, struct file *fd) | |
325 | { | |
326 | struct f_hidg *hidg = | |
327 | container_of(inode->i_cdev, struct f_hidg, cdev); | |
328 | ||
329 | fd->private_data = hidg; | |
330 | ||
331 | return 0; | |
332 | } | |
333 | ||
334 | /*-------------------------------------------------------------------------*/ | |
335 | /* usb_function */ | |
336 | ||
99c51500 | 337 | static struct usb_request *hidg_alloc_ep_req(struct usb_ep *ep, unsigned length) |
71adf118 | 338 | { |
99c51500 DM |
339 | struct usb_request *req; |
340 | ||
341 | req = usb_ep_alloc_request(ep, GFP_ATOMIC); | |
342 | if (req) { | |
343 | req->length = length; | |
344 | req->buf = kmalloc(length, GFP_ATOMIC); | |
345 | if (!req->buf) { | |
346 | usb_ep_free_request(ep, req); | |
347 | req = NULL; | |
348 | } | |
71adf118 | 349 | } |
99c51500 DM |
350 | return req; |
351 | } | |
71adf118 | 352 | |
99c51500 DM |
353 | static void hidg_set_report_complete(struct usb_ep *ep, struct usb_request *req) |
354 | { | |
355 | struct f_hidg *hidg = (struct f_hidg *) req->context; | |
356 | struct f_hidg_req_list *req_list; | |
357 | unsigned long flags; | |
71adf118 | 358 | |
99c51500 DM |
359 | req_list = kzalloc(sizeof(*req_list), GFP_ATOMIC); |
360 | if (!req_list) | |
71adf118 | 361 | return; |
71adf118 | 362 | |
99c51500 DM |
363 | req_list->req = req; |
364 | ||
365 | spin_lock_irqsave(&hidg->spinlock, flags); | |
366 | list_add_tail(&req_list->list, &hidg->completed_out_req); | |
367 | spin_unlock_irqrestore(&hidg->spinlock, flags); | |
71adf118 FC |
368 | |
369 | wake_up(&hidg->read_queue); | |
71adf118 FC |
370 | } |
371 | ||
372 | static int hidg_setup(struct usb_function *f, | |
373 | const struct usb_ctrlrequest *ctrl) | |
374 | { | |
375 | struct f_hidg *hidg = func_to_hidg(f); | |
376 | struct usb_composite_dev *cdev = f->config->cdev; | |
377 | struct usb_request *req = cdev->req; | |
378 | int status = 0; | |
379 | __u16 value, length; | |
380 | ||
381 | value = __le16_to_cpu(ctrl->wValue); | |
382 | length = __le16_to_cpu(ctrl->wLength); | |
383 | ||
384 | VDBG(cdev, "hid_setup crtl_request : bRequestType:0x%x bRequest:0x%x " | |
385 | "Value:0x%x\n", ctrl->bRequestType, ctrl->bRequest, value); | |
386 | ||
387 | switch ((ctrl->bRequestType << 8) | ctrl->bRequest) { | |
388 | case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8 | |
389 | | HID_REQ_GET_REPORT): | |
390 | VDBG(cdev, "get_report\n"); | |
391 | ||
392 | /* send an empty report */ | |
393 | length = min_t(unsigned, length, hidg->report_length); | |
394 | memset(req->buf, 0x0, length); | |
395 | ||
396 | goto respond; | |
397 | break; | |
398 | ||
399 | case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8 | |
400 | | HID_REQ_GET_PROTOCOL): | |
401 | VDBG(cdev, "get_protocol\n"); | |
402 | goto stall; | |
403 | break; | |
404 | ||
405 | case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8 | |
406 | | HID_REQ_SET_REPORT): | |
407 | VDBG(cdev, "set_report | wLenght=%d\n", ctrl->wLength); | |
99c51500 | 408 | goto stall; |
71adf118 FC |
409 | break; |
410 | ||
411 | case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8 | |
412 | | HID_REQ_SET_PROTOCOL): | |
413 | VDBG(cdev, "set_protocol\n"); | |
414 | goto stall; | |
415 | break; | |
416 | ||
417 | case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8 | |
418 | | USB_REQ_GET_DESCRIPTOR): | |
419 | switch (value >> 8) { | |
c240d78a SB |
420 | case HID_DT_HID: |
421 | VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n"); | |
422 | length = min_t(unsigned short, length, | |
423 | hidg_desc.bLength); | |
424 | memcpy(req->buf, &hidg_desc, length); | |
425 | goto respond; | |
426 | break; | |
71adf118 FC |
427 | case HID_DT_REPORT: |
428 | VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n"); | |
429 | length = min_t(unsigned short, length, | |
430 | hidg->report_desc_length); | |
431 | memcpy(req->buf, hidg->report_desc, length); | |
432 | goto respond; | |
433 | break; | |
434 | ||
435 | default: | |
1c1301dd | 436 | VDBG(cdev, "Unknown descriptor request 0x%x\n", |
71adf118 FC |
437 | value >> 8); |
438 | goto stall; | |
439 | break; | |
440 | } | |
441 | break; | |
442 | ||
443 | default: | |
444 | VDBG(cdev, "Unknown request 0x%x\n", | |
445 | ctrl->bRequest); | |
446 | goto stall; | |
447 | break; | |
448 | } | |
449 | ||
450 | stall: | |
451 | return -EOPNOTSUPP; | |
452 | ||
453 | respond: | |
454 | req->zero = 0; | |
455 | req->length = length; | |
456 | status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); | |
457 | if (status < 0) | |
458 | ERROR(cdev, "usb_ep_queue error on ep0 %d\n", value); | |
459 | return status; | |
460 | } | |
461 | ||
462 | static void hidg_disable(struct usb_function *f) | |
463 | { | |
464 | struct f_hidg *hidg = func_to_hidg(f); | |
99c51500 | 465 | struct f_hidg_req_list *list, *next; |
71adf118 FC |
466 | |
467 | usb_ep_disable(hidg->in_ep); | |
468 | hidg->in_ep->driver_data = NULL; | |
99c51500 DM |
469 | |
470 | usb_ep_disable(hidg->out_ep); | |
471 | hidg->out_ep->driver_data = NULL; | |
472 | ||
473 | list_for_each_entry_safe(list, next, &hidg->completed_out_req, list) { | |
474 | list_del(&list->list); | |
475 | kfree(list); | |
476 | } | |
71adf118 FC |
477 | } |
478 | ||
479 | static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt) | |
480 | { | |
481 | struct usb_composite_dev *cdev = f->config->cdev; | |
482 | struct f_hidg *hidg = func_to_hidg(f); | |
99c51500 | 483 | int i, status = 0; |
71adf118 FC |
484 | |
485 | VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt); | |
486 | ||
487 | if (hidg->in_ep != NULL) { | |
488 | /* restart endpoint */ | |
489 | if (hidg->in_ep->driver_data != NULL) | |
490 | usb_ep_disable(hidg->in_ep); | |
491 | ||
ea2a1df7 TB |
492 | status = config_ep_by_speed(f->config->cdev->gadget, f, |
493 | hidg->in_ep); | |
494 | if (status) { | |
495 | ERROR(cdev, "config_ep_by_speed FAILED!\n"); | |
496 | goto fail; | |
497 | } | |
72c973dd | 498 | status = usb_ep_enable(hidg->in_ep); |
71adf118 | 499 | if (status < 0) { |
99c51500 | 500 | ERROR(cdev, "Enable IN endpoint FAILED!\n"); |
71adf118 FC |
501 | goto fail; |
502 | } | |
503 | hidg->in_ep->driver_data = hidg; | |
504 | } | |
99c51500 DM |
505 | |
506 | ||
507 | if (hidg->out_ep != NULL) { | |
508 | /* restart endpoint */ | |
509 | if (hidg->out_ep->driver_data != NULL) | |
510 | usb_ep_disable(hidg->out_ep); | |
511 | ||
512 | status = config_ep_by_speed(f->config->cdev->gadget, f, | |
513 | hidg->out_ep); | |
514 | if (status) { | |
515 | ERROR(cdev, "config_ep_by_speed FAILED!\n"); | |
516 | goto fail; | |
517 | } | |
518 | status = usb_ep_enable(hidg->out_ep); | |
519 | if (status < 0) { | |
520 | ERROR(cdev, "Enable IN endpoint FAILED!\n"); | |
521 | goto fail; | |
522 | } | |
523 | hidg->out_ep->driver_data = hidg; | |
524 | ||
525 | /* | |
526 | * allocate a bunch of read buffers and queue them all at once. | |
527 | */ | |
528 | for (i = 0; i < hidg->qlen && status == 0; i++) { | |
529 | struct usb_request *req = | |
530 | hidg_alloc_ep_req(hidg->out_ep, | |
531 | hidg->report_length); | |
532 | if (req) { | |
533 | req->complete = hidg_set_report_complete; | |
534 | req->context = hidg; | |
535 | status = usb_ep_queue(hidg->out_ep, req, | |
536 | GFP_ATOMIC); | |
537 | if (status) | |
538 | ERROR(cdev, "%s queue req --> %d\n", | |
539 | hidg->out_ep->name, status); | |
540 | } else { | |
541 | usb_ep_disable(hidg->out_ep); | |
542 | hidg->out_ep->driver_data = NULL; | |
543 | status = -ENOMEM; | |
544 | goto fail; | |
545 | } | |
546 | } | |
547 | } | |
548 | ||
71adf118 FC |
549 | fail: |
550 | return status; | |
551 | } | |
552 | ||
553 | const struct file_operations f_hidg_fops = { | |
554 | .owner = THIS_MODULE, | |
555 | .open = f_hidg_open, | |
556 | .release = f_hidg_release, | |
557 | .write = f_hidg_write, | |
558 | .read = f_hidg_read, | |
559 | .poll = f_hidg_poll, | |
6038f373 | 560 | .llseek = noop_llseek, |
71adf118 FC |
561 | }; |
562 | ||
563 | static int __init hidg_bind(struct usb_configuration *c, struct usb_function *f) | |
564 | { | |
565 | struct usb_ep *ep; | |
566 | struct f_hidg *hidg = func_to_hidg(f); | |
567 | int status; | |
568 | dev_t dev; | |
569 | ||
570 | /* allocate instance-specific interface IDs, and patch descriptors */ | |
571 | status = usb_interface_id(c, f); | |
572 | if (status < 0) | |
573 | goto fail; | |
574 | hidg_interface_desc.bInterfaceNumber = status; | |
575 | ||
576 | ||
577 | /* allocate instance-specific endpoints */ | |
578 | status = -ENODEV; | |
579 | ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_in_ep_desc); | |
580 | if (!ep) | |
581 | goto fail; | |
582 | ep->driver_data = c->cdev; /* claim */ | |
583 | hidg->in_ep = ep; | |
584 | ||
99c51500 DM |
585 | ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_out_ep_desc); |
586 | if (!ep) | |
587 | goto fail; | |
588 | ep->driver_data = c->cdev; /* claim */ | |
589 | hidg->out_ep = ep; | |
590 | ||
71adf118 FC |
591 | /* preallocate request and buffer */ |
592 | status = -ENOMEM; | |
593 | hidg->req = usb_ep_alloc_request(hidg->in_ep, GFP_KERNEL); | |
594 | if (!hidg->req) | |
595 | goto fail; | |
596 | ||
71adf118 FC |
597 | hidg->req->buf = kmalloc(hidg->report_length, GFP_KERNEL); |
598 | if (!hidg->req->buf) | |
599 | goto fail; | |
600 | ||
601 | /* set descriptor dynamic values */ | |
602 | hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass; | |
603 | hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol; | |
604 | hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length); | |
605 | hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length); | |
99c51500 DM |
606 | hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length); |
607 | hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length); | |
71adf118 FC |
608 | hidg_desc.desc[0].bDescriptorType = HID_DT_REPORT; |
609 | hidg_desc.desc[0].wDescriptorLength = | |
610 | cpu_to_le16(hidg->report_desc_length); | |
611 | ||
71adf118 FC |
612 | /* copy descriptors */ |
613 | f->descriptors = usb_copy_descriptors(hidg_fs_descriptors); | |
614 | if (!f->descriptors) | |
615 | goto fail; | |
616 | ||
71adf118 FC |
617 | if (gadget_is_dualspeed(c->cdev->gadget)) { |
618 | hidg_hs_in_ep_desc.bEndpointAddress = | |
619 | hidg_fs_in_ep_desc.bEndpointAddress; | |
99c51500 DM |
620 | hidg_hs_out_ep_desc.bEndpointAddress = |
621 | hidg_fs_out_ep_desc.bEndpointAddress; | |
71adf118 FC |
622 | f->hs_descriptors = usb_copy_descriptors(hidg_hs_descriptors); |
623 | if (!f->hs_descriptors) | |
624 | goto fail; | |
71adf118 FC |
625 | } |
626 | ||
627 | mutex_init(&hidg->lock); | |
628 | spin_lock_init(&hidg->spinlock); | |
629 | init_waitqueue_head(&hidg->write_queue); | |
630 | init_waitqueue_head(&hidg->read_queue); | |
99c51500 | 631 | INIT_LIST_HEAD(&hidg->completed_out_req); |
71adf118 FC |
632 | |
633 | /* create char device */ | |
634 | cdev_init(&hidg->cdev, &f_hidg_fops); | |
635 | dev = MKDEV(major, hidg->minor); | |
636 | status = cdev_add(&hidg->cdev, dev, 1); | |
637 | if (status) | |
638 | goto fail; | |
639 | ||
640 | device_create(hidg_class, NULL, dev, NULL, "%s%d", "hidg", hidg->minor); | |
641 | ||
642 | return 0; | |
643 | ||
644 | fail: | |
645 | ERROR(f->config->cdev, "hidg_bind FAILED\n"); | |
646 | if (hidg->req != NULL) { | |
647 | kfree(hidg->req->buf); | |
648 | if (hidg->in_ep != NULL) | |
649 | usb_ep_free_request(hidg->in_ep, hidg->req); | |
650 | } | |
651 | ||
652 | usb_free_descriptors(f->hs_descriptors); | |
653 | usb_free_descriptors(f->descriptors); | |
654 | ||
655 | return status; | |
656 | } | |
657 | ||
658 | static void hidg_unbind(struct usb_configuration *c, struct usb_function *f) | |
659 | { | |
660 | struct f_hidg *hidg = func_to_hidg(f); | |
661 | ||
662 | device_destroy(hidg_class, MKDEV(major, hidg->minor)); | |
663 | cdev_del(&hidg->cdev); | |
664 | ||
665 | /* disable/free request and end point */ | |
666 | usb_ep_disable(hidg->in_ep); | |
667 | usb_ep_dequeue(hidg->in_ep, hidg->req); | |
668 | kfree(hidg->req->buf); | |
669 | usb_ep_free_request(hidg->in_ep, hidg->req); | |
670 | ||
671 | /* free descriptors copies */ | |
672 | usb_free_descriptors(f->hs_descriptors); | |
673 | usb_free_descriptors(f->descriptors); | |
674 | ||
675 | kfree(hidg->report_desc); | |
71adf118 FC |
676 | kfree(hidg); |
677 | } | |
678 | ||
679 | /*-------------------------------------------------------------------------*/ | |
680 | /* Strings */ | |
681 | ||
682 | #define CT_FUNC_HID_IDX 0 | |
683 | ||
684 | static struct usb_string ct_func_string_defs[] = { | |
685 | [CT_FUNC_HID_IDX].s = "HID Interface", | |
686 | {}, /* end of list */ | |
687 | }; | |
688 | ||
689 | static struct usb_gadget_strings ct_func_string_table = { | |
690 | .language = 0x0409, /* en-US */ | |
691 | .strings = ct_func_string_defs, | |
692 | }; | |
693 | ||
694 | static struct usb_gadget_strings *ct_func_strings[] = { | |
695 | &ct_func_string_table, | |
696 | NULL, | |
697 | }; | |
698 | ||
699 | /*-------------------------------------------------------------------------*/ | |
700 | /* usb_configuration */ | |
701 | ||
702 | int __init hidg_bind_config(struct usb_configuration *c, | |
703 | struct hidg_func_descriptor *fdesc, int index) | |
704 | { | |
705 | struct f_hidg *hidg; | |
706 | int status; | |
707 | ||
708 | if (index >= minors) | |
709 | return -ENOENT; | |
710 | ||
711 | /* maybe allocate device-global string IDs, and patch descriptors */ | |
712 | if (ct_func_string_defs[CT_FUNC_HID_IDX].id == 0) { | |
713 | status = usb_string_id(c->cdev); | |
714 | if (status < 0) | |
715 | return status; | |
716 | ct_func_string_defs[CT_FUNC_HID_IDX].id = status; | |
717 | hidg_interface_desc.iInterface = status; | |
718 | } | |
719 | ||
720 | /* allocate and initialize one new instance */ | |
721 | hidg = kzalloc(sizeof *hidg, GFP_KERNEL); | |
722 | if (!hidg) | |
723 | return -ENOMEM; | |
724 | ||
725 | hidg->minor = index; | |
726 | hidg->bInterfaceSubClass = fdesc->subclass; | |
727 | hidg->bInterfaceProtocol = fdesc->protocol; | |
728 | hidg->report_length = fdesc->report_length; | |
729 | hidg->report_desc_length = fdesc->report_desc_length; | |
730 | hidg->report_desc = kmemdup(fdesc->report_desc, | |
731 | fdesc->report_desc_length, | |
732 | GFP_KERNEL); | |
733 | if (!hidg->report_desc) { | |
734 | kfree(hidg); | |
735 | return -ENOMEM; | |
736 | } | |
737 | ||
738 | hidg->func.name = "hid"; | |
739 | hidg->func.strings = ct_func_strings; | |
740 | hidg->func.bind = hidg_bind; | |
741 | hidg->func.unbind = hidg_unbind; | |
742 | hidg->func.set_alt = hidg_set_alt; | |
743 | hidg->func.disable = hidg_disable; | |
744 | hidg->func.setup = hidg_setup; | |
745 | ||
99c51500 DM |
746 | /* this could me made configurable at some point */ |
747 | hidg->qlen = 4; | |
748 | ||
71adf118 FC |
749 | status = usb_add_function(c, &hidg->func); |
750 | if (status) | |
751 | kfree(hidg); | |
752 | ||
753 | return status; | |
754 | } | |
755 | ||
756 | int __init ghid_setup(struct usb_gadget *g, int count) | |
757 | { | |
758 | int status; | |
759 | dev_t dev; | |
760 | ||
761 | hidg_class = class_create(THIS_MODULE, "hidg"); | |
762 | ||
763 | status = alloc_chrdev_region(&dev, 0, count, "hidg"); | |
764 | if (!status) { | |
765 | major = MAJOR(dev); | |
766 | minors = count; | |
767 | } | |
768 | ||
769 | return status; | |
770 | } | |
771 | ||
772 | void ghid_cleanup(void) | |
773 | { | |
774 | if (major) { | |
775 | unregister_chrdev_region(MKDEV(major, 0), minors); | |
776 | major = minors = 0; | |
777 | } | |
778 | ||
779 | class_destroy(hidg_class); | |
780 | hidg_class = NULL; | |
781 | } |