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.
10 */
11
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/hid.h>
15#include <linux/idr.h>
16#include <linux/cdev.h>
17#include <linux/mutex.h>
18#include <linux/poll.h>
19#include <linux/uaccess.h>
20#include <linux/wait.h>
21#include <linux/sched.h>
22#include <linux/usb/g_hid.h>
23
24#include "u_f.h"
25#include "u_hid.h"
26
27#define HIDG_MINORS	4
28
29static int major, minors;
30static struct class *hidg_class;
31static DEFINE_IDA(hidg_ida);
32static DEFINE_MUTEX(hidg_ida_lock); /* protects access to hidg_ida */
33
34/*-------------------------------------------------------------------------*/
35/*                            HID gadget struct                            */
36
37struct f_hidg_req_list {
38	struct usb_request	*req;
39	unsigned int		pos;
40	struct list_head 	list;
41};
42
43struct f_hidg {
44	/* configuration */
45	unsigned char			bInterfaceSubClass;
46	unsigned char			bInterfaceProtocol;
47	unsigned short			report_desc_length;
48	char				*report_desc;
49	unsigned short			report_length;
50
51	/* recv report */
52	struct list_head		completed_out_req;
53	spinlock_t			spinlock;
54	wait_queue_head_t		read_queue;
55	unsigned int			qlen;
56
57	/* send report */
58	struct mutex			lock;
59	bool				write_pending;
60	wait_queue_head_t		write_queue;
61	struct usb_request		*req;
62
63	int				minor;
64	struct cdev			cdev;
65	struct usb_function		func;
66
67	struct usb_ep			*in_ep;
68	struct usb_ep			*out_ep;
69};
70
71static inline struct f_hidg *func_to_hidg(struct usb_function *f)
72{
73	return container_of(f, struct f_hidg, func);
74}
75
76/*-------------------------------------------------------------------------*/
77/*                           Static descriptors                            */
78
79static struct usb_interface_descriptor hidg_interface_desc = {
80	.bLength		= sizeof hidg_interface_desc,
81	.bDescriptorType	= USB_DT_INTERFACE,
82	/* .bInterfaceNumber	= DYNAMIC */
83	.bAlternateSetting	= 0,
84	.bNumEndpoints		= 2,
85	.bInterfaceClass	= USB_CLASS_HID,
86	/* .bInterfaceSubClass	= DYNAMIC */
87	/* .bInterfaceProtocol	= DYNAMIC */
88	/* .iInterface		= DYNAMIC */
89};
90
91static struct hid_descriptor hidg_desc = {
92	.bLength			= sizeof hidg_desc,
93	.bDescriptorType		= HID_DT_HID,
94	.bcdHID				= 0x0101,
95	.bCountryCode			= 0x00,
96	.bNumDescriptors		= 0x1,
97	/*.desc[0].bDescriptorType	= DYNAMIC */
98	/*.desc[0].wDescriptorLenght	= DYNAMIC */
99};
100
101/* High-Speed Support */
102
103static struct usb_endpoint_descriptor hidg_hs_in_ep_desc = {
104	.bLength		= USB_DT_ENDPOINT_SIZE,
105	.bDescriptorType	= USB_DT_ENDPOINT,
106	.bEndpointAddress	= USB_DIR_IN,
107	.bmAttributes		= USB_ENDPOINT_XFER_INT,
108	/*.wMaxPacketSize	= DYNAMIC */
109	.bInterval		= 4, /* FIXME: Add this field in the
110				      * HID gadget configuration?
111				      * (struct hidg_func_descriptor)
112				      */
113};
114
115static struct usb_endpoint_descriptor hidg_hs_out_ep_desc = {
116	.bLength		= USB_DT_ENDPOINT_SIZE,
117	.bDescriptorType	= USB_DT_ENDPOINT,
118	.bEndpointAddress	= USB_DIR_OUT,
119	.bmAttributes		= USB_ENDPOINT_XFER_INT,
120	/*.wMaxPacketSize	= DYNAMIC */
121	.bInterval		= 4, /* FIXME: Add this field in the
122				      * HID gadget configuration?
123				      * (struct hidg_func_descriptor)
124				      */
125};
126
127static struct usb_descriptor_header *hidg_hs_descriptors[] = {
128	(struct usb_descriptor_header *)&hidg_interface_desc,
129	(struct usb_descriptor_header *)&hidg_desc,
130	(struct usb_descriptor_header *)&hidg_hs_in_ep_desc,
131	(struct usb_descriptor_header *)&hidg_hs_out_ep_desc,
132	NULL,
133};
134
135/* Full-Speed Support */
136
137static struct usb_endpoint_descriptor hidg_fs_in_ep_desc = {
138	.bLength		= USB_DT_ENDPOINT_SIZE,
139	.bDescriptorType	= USB_DT_ENDPOINT,
140	.bEndpointAddress	= USB_DIR_IN,
141	.bmAttributes		= USB_ENDPOINT_XFER_INT,
142	/*.wMaxPacketSize	= DYNAMIC */
143	.bInterval		= 10, /* FIXME: Add this field in the
144				       * HID gadget configuration?
145				       * (struct hidg_func_descriptor)
146				       */
147};
148
149static struct usb_endpoint_descriptor hidg_fs_out_ep_desc = {
150	.bLength		= USB_DT_ENDPOINT_SIZE,
151	.bDescriptorType	= USB_DT_ENDPOINT,
152	.bEndpointAddress	= USB_DIR_OUT,
153	.bmAttributes		= USB_ENDPOINT_XFER_INT,
154	/*.wMaxPacketSize	= DYNAMIC */
155	.bInterval		= 10, /* FIXME: Add this field in the
156				       * HID gadget configuration?
157				       * (struct hidg_func_descriptor)
158				       */
159};
160
161static struct usb_descriptor_header *hidg_fs_descriptors[] = {
162	(struct usb_descriptor_header *)&hidg_interface_desc,
163	(struct usb_descriptor_header *)&hidg_desc,
164	(struct usb_descriptor_header *)&hidg_fs_in_ep_desc,
165	(struct usb_descriptor_header *)&hidg_fs_out_ep_desc,
166	NULL,
167};
168
169/*-------------------------------------------------------------------------*/
170/*                                 Strings                                 */
171
172#define CT_FUNC_HID_IDX	0
173
174static struct usb_string ct_func_string_defs[] = {
175	[CT_FUNC_HID_IDX].s	= "HID Interface",
176	{},			/* end of list */
177};
178
179static struct usb_gadget_strings ct_func_string_table = {
180	.language	= 0x0409,	/* en-US */
181	.strings	= ct_func_string_defs,
182};
183
184static struct usb_gadget_strings *ct_func_strings[] = {
185	&ct_func_string_table,
186	NULL,
187};
188
189/*-------------------------------------------------------------------------*/
190/*                              Char Device                                */
191
192static ssize_t f_hidg_read(struct file *file, char __user *buffer,
193			size_t count, loff_t *ptr)
194{
195	struct f_hidg *hidg = file->private_data;
196	struct f_hidg_req_list *list;
197	struct usb_request *req;
198	unsigned long flags;
199	int ret;
200
201	if (!count)
202		return 0;
203
204	if (!access_ok(VERIFY_WRITE, buffer, count))
205		return -EFAULT;
206
207	spin_lock_irqsave(&hidg->spinlock, flags);
208
209#define READ_COND (!list_empty(&hidg->completed_out_req))
210
211	/* wait for at least one buffer to complete */
212	while (!READ_COND) {
213		spin_unlock_irqrestore(&hidg->spinlock, flags);
214		if (file->f_flags & O_NONBLOCK)
215			return -EAGAIN;
216
217		if (wait_event_interruptible(hidg->read_queue, READ_COND))
218			return -ERESTARTSYS;
219
220		spin_lock_irqsave(&hidg->spinlock, flags);
221	}
222
223	/* pick the first one */
224	list = list_first_entry(&hidg->completed_out_req,
225				struct f_hidg_req_list, list);
226	req = list->req;
227	count = min_t(unsigned int, count, req->actual - list->pos);
228	spin_unlock_irqrestore(&hidg->spinlock, flags);
229
230	/* copy to user outside spinlock */
231	count -= copy_to_user(buffer, req->buf + list->pos, count);
232	list->pos += count;
233
234	/*
235	 * if this request is completely handled and transfered to
236	 * userspace, remove its entry from the list and requeue it
237	 * again. Otherwise, we will revisit it again upon the next
238	 * call, taking into account its current read position.
239	 */
240	if (list->pos == req->actual) {
241		spin_lock_irqsave(&hidg->spinlock, flags);
242		list_del(&list->list);
243		kfree(list);
244		spin_unlock_irqrestore(&hidg->spinlock, flags);
245
246		req->length = hidg->report_length;
247		ret = usb_ep_queue(hidg->out_ep, req, GFP_KERNEL);
248		if (ret < 0)
249			return ret;
250	}
251
252	return count;
253}
254
255static void f_hidg_req_complete(struct usb_ep *ep, struct usb_request *req)
256{
257	struct f_hidg *hidg = (struct f_hidg *)ep->driver_data;
258
259	if (req->status != 0) {
260		ERROR(hidg->func.config->cdev,
261			"End Point Request ERROR: %d\n", req->status);
262	}
263
264	hidg->write_pending = 0;
265	wake_up(&hidg->write_queue);
266}
267
268static ssize_t f_hidg_write(struct file *file, const char __user *buffer,
269			    size_t count, loff_t *offp)
270{
271	struct f_hidg *hidg  = file->private_data;
272	ssize_t status = -ENOMEM;
273
274	if (!access_ok(VERIFY_READ, buffer, count))
275		return -EFAULT;
276
277	mutex_lock(&hidg->lock);
278
279#define WRITE_COND (!hidg->write_pending)
280
281	/* write queue */
282	while (!WRITE_COND) {
283		mutex_unlock(&hidg->lock);
284		if (file->f_flags & O_NONBLOCK)
285			return -EAGAIN;
286
287		if (wait_event_interruptible_exclusive(
288				hidg->write_queue, WRITE_COND))
289			return -ERESTARTSYS;
290
291		mutex_lock(&hidg->lock);
292	}
293
294	count  = min_t(unsigned, count, hidg->report_length);
295	status = copy_from_user(hidg->req->buf, buffer, count);
296
297	if (status != 0) {
298		ERROR(hidg->func.config->cdev,
299			"copy_from_user error\n");
300		mutex_unlock(&hidg->lock);
301		return -EINVAL;
302	}
303
304	hidg->req->status   = 0;
305	hidg->req->zero     = 0;
306	hidg->req->length   = count;
307	hidg->req->complete = f_hidg_req_complete;
308	hidg->req->context  = hidg;
309	hidg->write_pending = 1;
310
311	status = usb_ep_queue(hidg->in_ep, hidg->req, GFP_ATOMIC);
312	if (status < 0) {
313		ERROR(hidg->func.config->cdev,
314			"usb_ep_queue error on int endpoint %zd\n", status);
315		hidg->write_pending = 0;
316		wake_up(&hidg->write_queue);
317	} else {
318		status = count;
319	}
320
321	mutex_unlock(&hidg->lock);
322
323	return status;
324}
325
326static unsigned int f_hidg_poll(struct file *file, poll_table *wait)
327{
328	struct f_hidg	*hidg  = file->private_data;
329	unsigned int	ret = 0;
330
331	poll_wait(file, &hidg->read_queue, wait);
332	poll_wait(file, &hidg->write_queue, wait);
333
334	if (WRITE_COND)
335		ret |= POLLOUT | POLLWRNORM;
336
337	if (READ_COND)
338		ret |= POLLIN | POLLRDNORM;
339
340	return ret;
341}
342
343#undef WRITE_COND
344#undef READ_COND
345
346static int f_hidg_release(struct inode *inode, struct file *fd)
347{
348	fd->private_data = NULL;
349	return 0;
350}
351
352static int f_hidg_open(struct inode *inode, struct file *fd)
353{
354	struct f_hidg *hidg =
355		container_of(inode->i_cdev, struct f_hidg, cdev);
356
357	fd->private_data = hidg;
358
359	return 0;
360}
361
362/*-------------------------------------------------------------------------*/
363/*                                usb_function                             */
364
365static inline struct usb_request *hidg_alloc_ep_req(struct usb_ep *ep,
366						    unsigned length)
367{
368	return alloc_ep_req(ep, length, length);
369}
370
371static void hidg_set_report_complete(struct usb_ep *ep, struct usb_request *req)
372{
373	struct f_hidg *hidg = (struct f_hidg *) req->context;
374	struct f_hidg_req_list *req_list;
375	unsigned long flags;
376
377	req_list = kzalloc(sizeof(*req_list), GFP_ATOMIC);
378	if (!req_list)
379		return;
380
381	req_list->req = req;
382
383	spin_lock_irqsave(&hidg->spinlock, flags);
384	list_add_tail(&req_list->list, &hidg->completed_out_req);
385	spin_unlock_irqrestore(&hidg->spinlock, flags);
386
387	wake_up(&hidg->read_queue);
388}
389
390static int hidg_setup(struct usb_function *f,
391		const struct usb_ctrlrequest *ctrl)
392{
393	struct f_hidg			*hidg = func_to_hidg(f);
394	struct usb_composite_dev	*cdev = f->config->cdev;
395	struct usb_request		*req  = cdev->req;
396	int status = 0;
397	__u16 value, length;
398
399	value	= __le16_to_cpu(ctrl->wValue);
400	length	= __le16_to_cpu(ctrl->wLength);
401
402	VDBG(cdev,
403	     "%s crtl_request : bRequestType:0x%x bRequest:0x%x Value:0x%x\n",
404	     __func__, ctrl->bRequestType, ctrl->bRequest, value);
405
406	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
407	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
408		  | HID_REQ_GET_REPORT):
409		VDBG(cdev, "get_report\n");
410
411		/* send an empty report */
412		length = min_t(unsigned, length, hidg->report_length);
413		memset(req->buf, 0x0, length);
414
415		goto respond;
416		break;
417
418	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
419		  | HID_REQ_GET_PROTOCOL):
420		VDBG(cdev, "get_protocol\n");
421		goto stall;
422		break;
423
424	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
425		  | HID_REQ_SET_REPORT):
426		VDBG(cdev, "set_report | wLength=%d\n", ctrl->wLength);
427		goto stall;
428		break;
429
430	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
431		  | HID_REQ_SET_PROTOCOL):
432		VDBG(cdev, "set_protocol\n");
433		goto stall;
434		break;
435
436	case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
437		  | USB_REQ_GET_DESCRIPTOR):
438		switch (value >> 8) {
439		case HID_DT_HID:
440		{
441			struct hid_descriptor hidg_desc_copy = hidg_desc;
442
443			VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n");
444			hidg_desc_copy.desc[0].bDescriptorType = HID_DT_REPORT;
445			hidg_desc_copy.desc[0].wDescriptorLength =
446				cpu_to_le16(hidg->report_desc_length);
447
448			length = min_t(unsigned short, length,
449						   hidg_desc_copy.bLength);
450			memcpy(req->buf, &hidg_desc_copy, length);
451			goto respond;
452			break;
453		}
454		case HID_DT_REPORT:
455			VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
456			length = min_t(unsigned short, length,
457						   hidg->report_desc_length);
458			memcpy(req->buf, hidg->report_desc, length);
459			goto respond;
460			break;
461
462		default:
463			VDBG(cdev, "Unknown descriptor request 0x%x\n",
464				 value >> 8);
465			goto stall;
466			break;
467		}
468		break;
469
470	default:
471		VDBG(cdev, "Unknown request 0x%x\n",
472			 ctrl->bRequest);
473		goto stall;
474		break;
475	}
476
477stall:
478	return -EOPNOTSUPP;
479
480respond:
481	req->zero = 0;
482	req->length = length;
483	status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
484	if (status < 0)
485		ERROR(cdev, "usb_ep_queue error on ep0 %d\n", value);
486	return status;
487}
488
489static void hidg_disable(struct usb_function *f)
490{
491	struct f_hidg *hidg = func_to_hidg(f);
492	struct f_hidg_req_list *list, *next;
493
494	usb_ep_disable(hidg->in_ep);
495	hidg->in_ep->driver_data = NULL;
496
497	usb_ep_disable(hidg->out_ep);
498	hidg->out_ep->driver_data = NULL;
499
500	list_for_each_entry_safe(list, next, &hidg->completed_out_req, list) {
501		list_del(&list->list);
502		kfree(list);
503	}
504}
505
506static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
507{
508	struct usb_composite_dev		*cdev = f->config->cdev;
509	struct f_hidg				*hidg = func_to_hidg(f);
510	int i, status = 0;
511
512	VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);
513
514	if (hidg->in_ep != NULL) {
515		/* restart endpoint */
516		if (hidg->in_ep->driver_data != NULL)
517			usb_ep_disable(hidg->in_ep);
518
519		status = config_ep_by_speed(f->config->cdev->gadget, f,
520					    hidg->in_ep);
521		if (status) {
522			ERROR(cdev, "config_ep_by_speed FAILED!\n");
523			goto fail;
524		}
525		status = usb_ep_enable(hidg->in_ep);
526		if (status < 0) {
527			ERROR(cdev, "Enable IN endpoint FAILED!\n");
528			goto fail;
529		}
530		hidg->in_ep->driver_data = hidg;
531	}
532
533
534	if (hidg->out_ep != NULL) {
535		/* restart endpoint */
536		if (hidg->out_ep->driver_data != NULL)
537			usb_ep_disable(hidg->out_ep);
538
539		status = config_ep_by_speed(f->config->cdev->gadget, f,
540					    hidg->out_ep);
541		if (status) {
542			ERROR(cdev, "config_ep_by_speed FAILED!\n");
543			goto fail;
544		}
545		status = usb_ep_enable(hidg->out_ep);
546		if (status < 0) {
547			ERROR(cdev, "Enable IN endpoint FAILED!\n");
548			goto fail;
549		}
550		hidg->out_ep->driver_data = hidg;
551
552		/*
553		 * allocate a bunch of read buffers and queue them all at once.
554		 */
555		for (i = 0; i < hidg->qlen && status == 0; i++) {
556			struct usb_request *req =
557					hidg_alloc_ep_req(hidg->out_ep,
558							  hidg->report_length);
559			if (req) {
560				req->complete = hidg_set_report_complete;
561				req->context  = hidg;
562				status = usb_ep_queue(hidg->out_ep, req,
563						      GFP_ATOMIC);
564				if (status)
565					ERROR(cdev, "%s queue req --> %d\n",
566						hidg->out_ep->name, status);
567			} else {
568				usb_ep_disable(hidg->out_ep);
569				hidg->out_ep->driver_data = NULL;
570				status = -ENOMEM;
571				goto fail;
572			}
573		}
574	}
575
576fail:
577	return status;
578}
579
580static const struct file_operations f_hidg_fops = {
581	.owner		= THIS_MODULE,
582	.open		= f_hidg_open,
583	.release	= f_hidg_release,
584	.write		= f_hidg_write,
585	.read		= f_hidg_read,
586	.poll		= f_hidg_poll,
587	.llseek		= noop_llseek,
588};
589
590static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
591{
592	struct usb_ep		*ep;
593	struct f_hidg		*hidg = func_to_hidg(f);
594	struct usb_string	*us;
595	struct device		*device;
596	int			status;
597	dev_t			dev;
598
599	/* maybe allocate device-global string IDs, and patch descriptors */
600	us = usb_gstrings_attach(c->cdev, ct_func_strings,
601				 ARRAY_SIZE(ct_func_string_defs));
602	if (IS_ERR(us))
603		return PTR_ERR(us);
604	hidg_interface_desc.iInterface = us[CT_FUNC_HID_IDX].id;
605
606	/* allocate instance-specific interface IDs, and patch descriptors */
607	status = usb_interface_id(c, f);
608	if (status < 0)
609		goto fail;
610	hidg_interface_desc.bInterfaceNumber = status;
611
612	/* allocate instance-specific endpoints */
613	status = -ENODEV;
614	ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_in_ep_desc);
615	if (!ep)
616		goto fail;
617	ep->driver_data = c->cdev;	/* claim */
618	hidg->in_ep = ep;
619
620	ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_out_ep_desc);
621	if (!ep)
622		goto fail;
623	ep->driver_data = c->cdev;	/* claim */
624	hidg->out_ep = ep;
625
626	/* preallocate request and buffer */
627	status = -ENOMEM;
628	hidg->req = usb_ep_alloc_request(hidg->in_ep, GFP_KERNEL);
629	if (!hidg->req)
630		goto fail;
631
632	hidg->req->buf = kmalloc(hidg->report_length, GFP_KERNEL);
633	if (!hidg->req->buf)
634		goto fail;
635
636	/* set descriptor dynamic values */
637	hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;
638	hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;
639	hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
640	hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
641	hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
642	hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
643	/*
644	 * We can use hidg_desc struct here but we should not relay
645	 * that its content won't change after returning from this function.
646	 */
647	hidg_desc.desc[0].bDescriptorType = HID_DT_REPORT;
648	hidg_desc.desc[0].wDescriptorLength =
649		cpu_to_le16(hidg->report_desc_length);
650
651	hidg_hs_in_ep_desc.bEndpointAddress =
652		hidg_fs_in_ep_desc.bEndpointAddress;
653	hidg_hs_out_ep_desc.bEndpointAddress =
654		hidg_fs_out_ep_desc.bEndpointAddress;
655
656	status = usb_assign_descriptors(f, hidg_fs_descriptors,
657			hidg_hs_descriptors, NULL);
658	if (status)
659		goto fail;
660
661	mutex_init(&hidg->lock);
662	spin_lock_init(&hidg->spinlock);
663	init_waitqueue_head(&hidg->write_queue);
664	init_waitqueue_head(&hidg->read_queue);
665	INIT_LIST_HEAD(&hidg->completed_out_req);
666
667	/* create char device */
668	cdev_init(&hidg->cdev, &f_hidg_fops);
669	dev = MKDEV(major, hidg->minor);
670	status = cdev_add(&hidg->cdev, dev, 1);
671	if (status)
672		goto fail_free_descs;
673
674	device = device_create(hidg_class, NULL, dev, NULL,
675			       "%s%d", "hidg", hidg->minor);
676	if (IS_ERR(device)) {
677		status = PTR_ERR(device);
678		goto del;
679	}
680
681	return 0;
682del:
683	cdev_del(&hidg->cdev);
684fail_free_descs:
685	usb_free_all_descriptors(f);
686fail:
687	ERROR(f->config->cdev, "hidg_bind FAILED\n");
688	if (hidg->req != NULL) {
689		kfree(hidg->req->buf);
690		if (hidg->in_ep != NULL)
691			usb_ep_free_request(hidg->in_ep, hidg->req);
692	}
693
694	return status;
695}
696
697static inline int hidg_get_minor(void)
698{
699	int ret;
700
701	ret = ida_simple_get(&hidg_ida, 0, 0, GFP_KERNEL);
702
703	return ret;
704}
705
706static inline struct f_hid_opts *to_f_hid_opts(struct config_item *item)
707{
708	return container_of(to_config_group(item), struct f_hid_opts,
709			    func_inst.group);
710}
711
712CONFIGFS_ATTR_STRUCT(f_hid_opts);
713CONFIGFS_ATTR_OPS(f_hid_opts);
714
715static void hid_attr_release(struct config_item *item)
716{
717	struct f_hid_opts *opts = to_f_hid_opts(item);
718
719	usb_put_function_instance(&opts->func_inst);
720}
721
722static struct configfs_item_operations hidg_item_ops = {
723	.release	= hid_attr_release,
724	.show_attribute	= f_hid_opts_attr_show,
725	.store_attribute = f_hid_opts_attr_store,
726};
727
728#define F_HID_OPT(name, prec, limit)					\
729static ssize_t f_hid_opts_##name##_show(struct f_hid_opts *opts, char *page)\
730{									\
731	int result;							\
732									\
733	mutex_lock(&opts->lock);					\
734	result = sprintf(page, "%d\n", opts->name);			\
735	mutex_unlock(&opts->lock);					\
736									\
737	return result;							\
738}									\
739									\
740static ssize_t f_hid_opts_##name##_store(struct f_hid_opts *opts,	\
741					 const char *page, size_t len)	\
742{									\
743	int ret;							\
744	u##prec num;							\
745									\
746	mutex_lock(&opts->lock);					\
747	if (opts->refcnt) {						\
748		ret = -EBUSY;						\
749		goto end;						\
750	}								\
751									\
752	ret = kstrtou##prec(page, 0, &num);				\
753	if (ret)							\
754		goto end;						\
755									\
756	if (num > limit) {						\
757		ret = -EINVAL;						\
758		goto end;						\
759	}								\
760	opts->name = num;						\
761	ret = len;							\
762									\
763end:									\
764	mutex_unlock(&opts->lock);					\
765	return ret;							\
766}									\
767									\
768static struct f_hid_opts_attribute f_hid_opts_##name =			\
769	__CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR, f_hid_opts_##name##_show,\
770			f_hid_opts_##name##_store)
771
772F_HID_OPT(subclass, 8, 255);
773F_HID_OPT(protocol, 8, 255);
774F_HID_OPT(report_length, 16, 65535);
775
776static ssize_t f_hid_opts_report_desc_show(struct f_hid_opts *opts, char *page)
777{
778	int result;
779
780	mutex_lock(&opts->lock);
781	result = opts->report_desc_length;
782	memcpy(page, opts->report_desc, opts->report_desc_length);
783	mutex_unlock(&opts->lock);
784
785	return result;
786}
787
788static ssize_t f_hid_opts_report_desc_store(struct f_hid_opts *opts,
789					    const char *page, size_t len)
790{
791	int ret = -EBUSY;
792	char *d;
793
794	mutex_lock(&opts->lock);
795
796	if (opts->refcnt)
797		goto end;
798	if (len > PAGE_SIZE) {
799		ret = -ENOSPC;
800		goto end;
801	}
802	d = kmemdup(page, len, GFP_KERNEL);
803	if (!d) {
804		ret = -ENOMEM;
805		goto end;
806	}
807	kfree(opts->report_desc);
808	opts->report_desc = d;
809	opts->report_desc_length = len;
810	opts->report_desc_alloc = true;
811	ret = len;
812end:
813	mutex_unlock(&opts->lock);
814	return ret;
815}
816
817static struct f_hid_opts_attribute f_hid_opts_report_desc =
818	__CONFIGFS_ATTR(report_desc, S_IRUGO | S_IWUSR,
819			f_hid_opts_report_desc_show,
820			f_hid_opts_report_desc_store);
821
822static struct configfs_attribute *hid_attrs[] = {
823	&f_hid_opts_subclass.attr,
824	&f_hid_opts_protocol.attr,
825	&f_hid_opts_report_length.attr,
826	&f_hid_opts_report_desc.attr,
827	NULL,
828};
829
830static struct config_item_type hid_func_type = {
831	.ct_item_ops	= &hidg_item_ops,
832	.ct_attrs	= hid_attrs,
833	.ct_owner	= THIS_MODULE,
834};
835
836static inline void hidg_put_minor(int minor)
837{
838	ida_simple_remove(&hidg_ida, minor);
839}
840
841static void hidg_free_inst(struct usb_function_instance *f)
842{
843	struct f_hid_opts *opts;
844
845	opts = container_of(f, struct f_hid_opts, func_inst);
846
847	mutex_lock(&hidg_ida_lock);
848
849	hidg_put_minor(opts->minor);
850	if (idr_is_empty(&hidg_ida.idr))
851		ghid_cleanup();
852
853	mutex_unlock(&hidg_ida_lock);
854
855	if (opts->report_desc_alloc)
856		kfree(opts->report_desc);
857
858	kfree(opts);
859}
860
861static struct usb_function_instance *hidg_alloc_inst(void)
862{
863	struct f_hid_opts *opts;
864	struct usb_function_instance *ret;
865	int status = 0;
866
867	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
868	if (!opts)
869		return ERR_PTR(-ENOMEM);
870	mutex_init(&opts->lock);
871	opts->func_inst.free_func_inst = hidg_free_inst;
872	ret = &opts->func_inst;
873
874	mutex_lock(&hidg_ida_lock);
875
876	if (idr_is_empty(&hidg_ida.idr)) {
877		status = ghid_setup(NULL, HIDG_MINORS);
878		if (status)  {
879			ret = ERR_PTR(status);
880			kfree(opts);
881			goto unlock;
882		}
883	}
884
885	opts->minor = hidg_get_minor();
886	if (opts->minor < 0) {
887		ret = ERR_PTR(opts->minor);
888		kfree(opts);
889		if (idr_is_empty(&hidg_ida.idr))
890			ghid_cleanup();
891		goto unlock;
892	}
893	config_group_init_type_name(&opts->func_inst.group, "", &hid_func_type);
894
895unlock:
896	mutex_unlock(&hidg_ida_lock);
897	return ret;
898}
899
900static void hidg_free(struct usb_function *f)
901{
902	struct f_hidg *hidg;
903	struct f_hid_opts *opts;
904
905	hidg = func_to_hidg(f);
906	opts = container_of(f->fi, struct f_hid_opts, func_inst);
907	kfree(hidg->report_desc);
908	kfree(hidg);
909	mutex_lock(&opts->lock);
910	--opts->refcnt;
911	mutex_unlock(&opts->lock);
912}
913
914static void hidg_unbind(struct usb_configuration *c, struct usb_function *f)
915{
916	struct f_hidg *hidg = func_to_hidg(f);
917
918	device_destroy(hidg_class, MKDEV(major, hidg->minor));
919	cdev_del(&hidg->cdev);
920
921	/* disable/free request and end point */
922	usb_ep_disable(hidg->in_ep);
923	kfree(hidg->req->buf);
924	usb_ep_free_request(hidg->in_ep, hidg->req);
925
926	usb_free_all_descriptors(f);
927}
928
929static struct usb_function *hidg_alloc(struct usb_function_instance *fi)
930{
931	struct f_hidg *hidg;
932	struct f_hid_opts *opts;
933
934	/* allocate and initialize one new instance */
935	hidg = kzalloc(sizeof(*hidg), GFP_KERNEL);
936	if (!hidg)
937		return ERR_PTR(-ENOMEM);
938
939	opts = container_of(fi, struct f_hid_opts, func_inst);
940
941	mutex_lock(&opts->lock);
942	++opts->refcnt;
943
944	hidg->minor = opts->minor;
945	hidg->bInterfaceSubClass = opts->subclass;
946	hidg->bInterfaceProtocol = opts->protocol;
947	hidg->report_length = opts->report_length;
948	hidg->report_desc_length = opts->report_desc_length;
949	if (opts->report_desc) {
950		hidg->report_desc = kmemdup(opts->report_desc,
951					    opts->report_desc_length,
952					    GFP_KERNEL);
953		if (!hidg->report_desc) {
954			kfree(hidg);
955			mutex_unlock(&opts->lock);
956			return ERR_PTR(-ENOMEM);
957		}
958	}
959
960	mutex_unlock(&opts->lock);
961
962	hidg->func.name    = "hid";
963	hidg->func.bind    = hidg_bind;
964	hidg->func.unbind  = hidg_unbind;
965	hidg->func.set_alt = hidg_set_alt;
966	hidg->func.disable = hidg_disable;
967	hidg->func.setup   = hidg_setup;
968	hidg->func.free_func = hidg_free;
969
970	/* this could me made configurable at some point */
971	hidg->qlen	   = 4;
972
973	return &hidg->func;
974}
975
976DECLARE_USB_FUNCTION_INIT(hid, hidg_alloc_inst, hidg_alloc);
977MODULE_LICENSE("GPL");
978MODULE_AUTHOR("Fabien Chouteau");
979
980int ghid_setup(struct usb_gadget *g, int count)
981{
982	int status;
983	dev_t dev;
984
985	hidg_class = class_create(THIS_MODULE, "hidg");
986	if (IS_ERR(hidg_class)) {
987		status = PTR_ERR(hidg_class);
988		hidg_class = NULL;
989		return status;
990	}
991
992	status = alloc_chrdev_region(&dev, 0, count, "hidg");
993	if (status) {
994		class_destroy(hidg_class);
995		hidg_class = NULL;
996		return status;
997	}
998
999	major = MAJOR(dev);
1000	minors = count;
1001
1002	return 0;
1003}
1004
1005void ghid_cleanup(void)
1006{
1007	if (major) {
1008		unregister_chrdev_region(MKDEV(major, 0), minors);
1009		major = minors = 0;
1010	}
1011
1012	class_destroy(hidg_class);
1013	hidg_class = NULL;
1014}
1015