f_hid.c 28.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
 * f_hid.c -- USB HID function driver
 *
 * Copyright (C) 2010 Fabien Chouteau <fabien.chouteau@barco.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/hid.h>
15
#include <linux/idr.h>
16
17
18
19
20
#include <linux/cdev.h>
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
21
#include <linux/sched.h>
22
23
#include <linux/usb/g_hid.h>

24
#include "u_f.h"
25
26
27
#include "u_hid.h"

#define HIDG_MINORS	4
28

29
30
static int major, minors;
static struct class *hidg_class;
31
32
static DEFINE_IDA(hidg_ida);
static DEFINE_MUTEX(hidg_ida_lock); /* protects access to hidg_ida */
33
34
35
36

/*-------------------------------------------------------------------------*/
/*                            HID gadget struct                            */

37
38
39
40
41
42
struct f_hidg_req_list {
	struct usb_request	*req;
	unsigned int		pos;
	struct list_head 	list;
};

43
44
45
46
47
48
49
50
51
struct f_hidg {
	/* configuration */
	unsigned char			bInterfaceSubClass;
	unsigned char			bInterfaceProtocol;
	unsigned short			report_desc_length;
	char				*report_desc;
	unsigned short			report_length;

	/* recv report */
52
	struct list_head		completed_out_req;
53
	spinlock_t			read_spinlock;
54
	wait_queue_head_t		read_queue;
55
	unsigned int			qlen;
56
57

	/* send report */
58
	spinlock_t			write_spinlock;
59
60
61
62
63
64
65
	bool				write_pending;
	wait_queue_head_t		write_queue;
	struct usb_request		*req;

	int				minor;
	struct cdev			cdev;
	struct usb_function		func;
66

67
	struct usb_ep			*in_ep;
68
	struct usb_ep			*out_ep;
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
};

static inline struct f_hidg *func_to_hidg(struct usb_function *f)
{
	return container_of(f, struct f_hidg, func);
}

/*-------------------------------------------------------------------------*/
/*                           Static descriptors                            */

static struct usb_interface_descriptor hidg_interface_desc = {
	.bLength		= sizeof hidg_interface_desc,
	.bDescriptorType	= USB_DT_INTERFACE,
	/* .bInterfaceNumber	= DYNAMIC */
	.bAlternateSetting	= 0,
84
	.bNumEndpoints		= 2,
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
	.bInterfaceClass	= USB_CLASS_HID,
	/* .bInterfaceSubClass	= DYNAMIC */
	/* .bInterfaceProtocol	= DYNAMIC */
	/* .iInterface		= DYNAMIC */
};

static struct hid_descriptor hidg_desc = {
	.bLength			= sizeof hidg_desc,
	.bDescriptorType		= HID_DT_HID,
	.bcdHID				= 0x0101,
	.bCountryCode			= 0x00,
	.bNumDescriptors		= 0x1,
	/*.desc[0].bDescriptorType	= DYNAMIC */
	/*.desc[0].wDescriptorLenght	= DYNAMIC */
};

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* Super-Speed Support */

static struct usb_endpoint_descriptor hidg_ss_in_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_IN,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 4, /* FIXME: Add this field in the
				      * HID gadget configuration?
				      * (struct hidg_func_descriptor)
				      */
};

static struct usb_ss_ep_comp_descriptor hidg_ss_in_comp_desc = {
	.bLength                = sizeof(hidg_ss_in_comp_desc),
	.bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,

	/* .bMaxBurst           = 0, */
	/* .bmAttributes        = 0, */
	/* .wBytesPerInterval   = DYNAMIC */
};

static struct usb_endpoint_descriptor hidg_ss_out_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_OUT,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 4, /* FIXME: Add this field in the
				      * HID gadget configuration?
				      * (struct hidg_func_descriptor)
				      */
};

static struct usb_ss_ep_comp_descriptor hidg_ss_out_comp_desc = {
	.bLength                = sizeof(hidg_ss_out_comp_desc),
	.bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,

	/* .bMaxBurst           = 0, */
	/* .bmAttributes        = 0, */
	/* .wBytesPerInterval   = DYNAMIC */
};

static struct usb_descriptor_header *hidg_ss_descriptors[] = {
	(struct usb_descriptor_header *)&hidg_interface_desc,
	(struct usb_descriptor_header *)&hidg_desc,
	(struct usb_descriptor_header *)&hidg_ss_in_ep_desc,
	(struct usb_descriptor_header *)&hidg_ss_in_comp_desc,
	(struct usb_descriptor_header *)&hidg_ss_out_ep_desc,
	(struct usb_descriptor_header *)&hidg_ss_out_comp_desc,
	NULL,
};

155
156
157
158
159
160
161
162
163
164
165
166
167
168
/* High-Speed Support */

static struct usb_endpoint_descriptor hidg_hs_in_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_IN,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 4, /* FIXME: Add this field in the
				      * HID gadget configuration?
				      * (struct hidg_func_descriptor)
				      */
};

169
170
171
172
173
174
175
176
177
178
179
180
static struct usb_endpoint_descriptor hidg_hs_out_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_OUT,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 4, /* FIXME: Add this field in the
				      * HID gadget configuration?
				      * (struct hidg_func_descriptor)
				      */
};

181
182
183
184
static struct usb_descriptor_header *hidg_hs_descriptors[] = {
	(struct usb_descriptor_header *)&hidg_interface_desc,
	(struct usb_descriptor_header *)&hidg_desc,
	(struct usb_descriptor_header *)&hidg_hs_in_ep_desc,
185
	(struct usb_descriptor_header *)&hidg_hs_out_ep_desc,
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
	NULL,
};

/* Full-Speed Support */

static struct usb_endpoint_descriptor hidg_fs_in_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_IN,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 10, /* FIXME: Add this field in the
				       * HID gadget configuration?
				       * (struct hidg_func_descriptor)
				       */
};

203
204
205
206
207
208
209
210
211
212
213
214
static struct usb_endpoint_descriptor hidg_fs_out_ep_desc = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,
	.bEndpointAddress	= USB_DIR_OUT,
	.bmAttributes		= USB_ENDPOINT_XFER_INT,
	/*.wMaxPacketSize	= DYNAMIC */
	.bInterval		= 10, /* FIXME: Add this field in the
				       * HID gadget configuration?
				       * (struct hidg_func_descriptor)
				       */
};

215
216
217
218
static struct usb_descriptor_header *hidg_fs_descriptors[] = {
	(struct usb_descriptor_header *)&hidg_interface_desc,
	(struct usb_descriptor_header *)&hidg_desc,
	(struct usb_descriptor_header *)&hidg_fs_in_ep_desc,
219
	(struct usb_descriptor_header *)&hidg_fs_out_ep_desc,
220
221
222
	NULL,
};

223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
/*-------------------------------------------------------------------------*/
/*                                 Strings                                 */

#define CT_FUNC_HID_IDX	0

static struct usb_string ct_func_string_defs[] = {
	[CT_FUNC_HID_IDX].s	= "HID Interface",
	{},			/* end of list */
};

static struct usb_gadget_strings ct_func_string_table = {
	.language	= 0x0409,	/* en-US */
	.strings	= ct_func_string_defs,
};

static struct usb_gadget_strings *ct_func_strings[] = {
	&ct_func_string_table,
	NULL,
};

243
244
245
246
247
248
/*-------------------------------------------------------------------------*/
/*                              Char Device                                */

static ssize_t f_hidg_read(struct file *file, char __user *buffer,
			size_t count, loff_t *ptr)
{
249
250
251
252
253
	struct f_hidg *hidg = file->private_data;
	struct f_hidg_req_list *list;
	struct usb_request *req;
	unsigned long flags;
	int ret;
254
255
256
257
258
259
260

	if (!count)
		return 0;

	if (!access_ok(VERIFY_WRITE, buffer, count))
		return -EFAULT;

261
	spin_lock_irqsave(&hidg->read_spinlock, flags);
262

263
#define READ_COND (!list_empty(&hidg->completed_out_req))
264

265
	/* wait for at least one buffer to complete */
266
	while (!READ_COND) {
267
		spin_unlock_irqrestore(&hidg->read_spinlock, flags);
268
269
270
271
272
273
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;

		if (wait_event_interruptible(hidg->read_queue, READ_COND))
			return -ERESTARTSYS;

274
		spin_lock_irqsave(&hidg->read_spinlock, flags);
275
276
	}

277
278
279
	/* pick the first one */
	list = list_first_entry(&hidg->completed_out_req,
				struct f_hidg_req_list, list);
280
281
282
283
284
285
286

	/*
	 * Remove this from list to protect it from beign free()
	 * while host disables our function
	 */
	list_del(&list->list);

287
288
	req = list->req;
	count = min_t(unsigned int, count, req->actual - list->pos);
289
	spin_unlock_irqrestore(&hidg->read_spinlock, flags);
290

291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
	/* copy to user outside spinlock */
	count -= copy_to_user(buffer, req->buf + list->pos, count);
	list->pos += count;

	/*
	 * if this request is completely handled and transfered to
	 * userspace, remove its entry from the list and requeue it
	 * again. Otherwise, we will revisit it again upon the next
	 * call, taking into account its current read position.
	 */
	if (list->pos == req->actual) {
		kfree(list);

		req->length = hidg->report_length;
		ret = usb_ep_queue(hidg->out_ep, req, GFP_KERNEL);
306
307
		if (ret < 0) {
			free_ep_req(hidg->out_ep, req);
308
			return ret;
309
310
		}
	} else {
311
		spin_lock_irqsave(&hidg->read_spinlock, flags);
312
		list_add(&list->list, &hidg->completed_out_req);
313
		spin_unlock_irqrestore(&hidg->read_spinlock, flags);
314
315

		wake_up(&hidg->read_queue);
316
	}
317
318
319
320
321
322
323

	return count;
}

static void f_hidg_req_complete(struct usb_ep *ep, struct usb_request *req)
{
	struct f_hidg *hidg = (struct f_hidg *)ep->driver_data;
324
	unsigned long flags;
325
326
327
328
329
330

	if (req->status != 0) {
		ERROR(hidg->func.config->cdev,
			"End Point Request ERROR: %d\n", req->status);
	}

331
	spin_lock_irqsave(&hidg->write_spinlock, flags);
332
	hidg->write_pending = 0;
333
	spin_unlock_irqrestore(&hidg->write_spinlock, flags);
334
335
336
337
338
339
	wake_up(&hidg->write_queue);
}

static ssize_t f_hidg_write(struct file *file, const char __user *buffer,
			    size_t count, loff_t *offp)
{
340
	struct f_hidg *hidg  = file->private_data;
341
	struct usb_request *req;
342
	unsigned long flags;
343
344
345
346
347
	ssize_t status = -ENOMEM;

	if (!access_ok(VERIFY_READ, buffer, count))
		return -EFAULT;

348
	spin_lock_irqsave(&hidg->write_spinlock, flags);
349
350

#define WRITE_COND (!hidg->write_pending)
351
try_again:
352
353
	/* write queue */
	while (!WRITE_COND) {
354
		spin_unlock_irqrestore(&hidg->write_spinlock, flags);
355
356
357
358
359
360
361
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;

		if (wait_event_interruptible_exclusive(
				hidg->write_queue, WRITE_COND))
			return -ERESTARTSYS;

362
		spin_lock_irqsave(&hidg->write_spinlock, flags);
363
364
	}

365
	hidg->write_pending = 1;
366
	req = hidg->req;
367
	count  = min_t(unsigned, count, hidg->report_length);
368
369

	spin_unlock_irqrestore(&hidg->write_spinlock, flags);
370
	status = copy_from_user(req->buf, buffer, count);
371
372
373
374

	if (status != 0) {
		ERROR(hidg->func.config->cdev,
			"copy_from_user error\n");
375
376
		status = -EINVAL;
		goto release_write_pending;
377
378
	}

379
380
	spin_lock_irqsave(&hidg->write_spinlock, flags);

381
	/* when our function has been disabled by host */
382
	if (!hidg->req) {
383
		free_ep_req(hidg->in_ep, req);
384
385
386
387
388
389
390
391
392
393
394
395
		/*
		 * TODO
		 * Should we fail with error here?
		 */
		goto try_again;
	}

	req->status   = 0;
	req->zero     = 0;
	req->length   = count;
	req->complete = f_hidg_req_complete;
	req->context  = hidg;
396

397
	status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
398
399
400
	if (status < 0) {
		ERROR(hidg->func.config->cdev,
			"usb_ep_queue error on int endpoint %zd\n", status);
401
		goto release_write_pending_unlocked;
402
403
404
	} else {
		status = count;
	}
405
	spin_unlock_irqrestore(&hidg->write_spinlock, flags);
406

407
408
409
	return status;
release_write_pending:
	spin_lock_irqsave(&hidg->write_spinlock, flags);
410
release_write_pending_unlocked:
411
412
413
414
	hidg->write_pending = 0;
	spin_unlock_irqrestore(&hidg->write_spinlock, flags);

	wake_up(&hidg->write_queue);
415
416
417
418
419
420

	return status;
}

static unsigned int f_hidg_poll(struct file *file, poll_table *wait)
{
421
	struct f_hidg	*hidg  = file->private_data;
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
	unsigned int	ret = 0;

	poll_wait(file, &hidg->read_queue, wait);
	poll_wait(file, &hidg->write_queue, wait);

	if (WRITE_COND)
		ret |= POLLOUT | POLLWRNORM;

	if (READ_COND)
		ret |= POLLIN | POLLRDNORM;

	return ret;
}

#undef WRITE_COND
#undef READ_COND

static int f_hidg_release(struct inode *inode, struct file *fd)
{
	fd->private_data = NULL;
	return 0;
}

static int f_hidg_open(struct inode *inode, struct file *fd)
{
	struct f_hidg *hidg =
		container_of(inode->i_cdev, struct f_hidg, cdev);

	fd->private_data = hidg;

	return 0;
}

/*-------------------------------------------------------------------------*/
/*                                usb_function                             */

458
459
static inline struct usb_request *hidg_alloc_ep_req(struct usb_ep *ep,
						    unsigned length)
460
{
461
	return alloc_ep_req(ep, length);
462
}
463

464
465
466
static void hidg_set_report_complete(struct usb_ep *ep, struct usb_request *req)
{
	struct f_hidg *hidg = (struct f_hidg *) req->context;
467
	struct usb_composite_dev *cdev = hidg->func.config->cdev;
468
469
	struct f_hidg_req_list *req_list;
	unsigned long flags;
470

471
472
473
474
475
476
477
	switch (req->status) {
	case 0:
		req_list = kzalloc(sizeof(*req_list), GFP_ATOMIC);
		if (!req_list) {
			ERROR(cdev, "Unable to allocate mem for req_list\n");
			goto free_req;
		}
478

479
		req_list->req = req;
480

481
		spin_lock_irqsave(&hidg->read_spinlock, flags);
482
		list_add_tail(&req_list->list, &hidg->completed_out_req);
483
		spin_unlock_irqrestore(&hidg->read_spinlock, flags);
484

485
486
487
488
489
490
491
492
493
494
495
496
		wake_up(&hidg->read_queue);
		break;
	default:
		ERROR(cdev, "Set report failed %d\n", req->status);
		/* FALLTHROUGH */
	case -ECONNABORTED:		/* hardware forced ep reset */
	case -ECONNRESET:		/* request dequeued */
	case -ESHUTDOWN:		/* disconnect from host */
free_req:
		free_ep_req(ep, req);
		return;
	}
497
498
499
500
501
502
503
504
505
506
507
508
509
510
}

static int hidg_setup(struct usb_function *f,
		const struct usb_ctrlrequest *ctrl)
{
	struct f_hidg			*hidg = func_to_hidg(f);
	struct usb_composite_dev	*cdev = f->config->cdev;
	struct usb_request		*req  = cdev->req;
	int status = 0;
	__u16 value, length;

	value	= __le16_to_cpu(ctrl->wValue);
	length	= __le16_to_cpu(ctrl->wLength);

511
512
513
	VDBG(cdev,
	     "%s crtl_request : bRequestType:0x%x bRequest:0x%x Value:0x%x\n",
	     __func__, ctrl->bRequestType, ctrl->bRequest, value);
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534

	switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
		  | HID_REQ_GET_REPORT):
		VDBG(cdev, "get_report\n");

		/* send an empty report */
		length = min_t(unsigned, length, hidg->report_length);
		memset(req->buf, 0x0, length);

		goto respond;
		break;

	case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
		  | HID_REQ_GET_PROTOCOL):
		VDBG(cdev, "get_protocol\n");
		goto stall;
		break;

	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
		  | HID_REQ_SET_REPORT):
535
		VDBG(cdev, "set_report | wLength=%d\n", ctrl->wLength);
536
		goto stall;
537
538
539
540
541
542
543
544
545
546
547
		break;

	case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8
		  | HID_REQ_SET_PROTOCOL):
		VDBG(cdev, "set_protocol\n");
		goto stall;
		break;

	case ((USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_INTERFACE) << 8
		  | USB_REQ_GET_DESCRIPTOR):
		switch (value >> 8) {
548
		case HID_DT_HID:
549
550
551
		{
			struct hid_descriptor hidg_desc_copy = hidg_desc;

552
			VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: HID\n");
553
554
555
556
			hidg_desc_copy.desc[0].bDescriptorType = HID_DT_REPORT;
			hidg_desc_copy.desc[0].wDescriptorLength =
				cpu_to_le16(hidg->report_desc_length);

557
			length = min_t(unsigned short, length,
558
559
						   hidg_desc_copy.bLength);
			memcpy(req->buf, &hidg_desc_copy, length);
560
561
			goto respond;
			break;
562
		}
563
564
565
566
567
568
569
570
571
		case HID_DT_REPORT:
			VDBG(cdev, "USB_REQ_GET_DESCRIPTOR: REPORT\n");
			length = min_t(unsigned short, length,
						   hidg->report_desc_length);
			memcpy(req->buf, hidg->report_desc, length);
			goto respond;
			break;

		default:
572
			VDBG(cdev, "Unknown descriptor request 0x%x\n",
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
				 value >> 8);
			goto stall;
			break;
		}
		break;

	default:
		VDBG(cdev, "Unknown request 0x%x\n",
			 ctrl->bRequest);
		goto stall;
		break;
	}

stall:
	return -EOPNOTSUPP;

respond:
	req->zero = 0;
	req->length = length;
	status = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
	if (status < 0)
		ERROR(cdev, "usb_ep_queue error on ep0 %d\n", value);
	return status;
}

static void hidg_disable(struct usb_function *f)
{
	struct f_hidg *hidg = func_to_hidg(f);
601
	struct f_hidg_req_list *list, *next;
602
	unsigned long flags;
603
604

	usb_ep_disable(hidg->in_ep);
605
606
	usb_ep_disable(hidg->out_ep);

607
	spin_lock_irqsave(&hidg->read_spinlock, flags);
608
	list_for_each_entry_safe(list, next, &hidg->completed_out_req, list) {
609
		free_ep_req(hidg->out_ep, list->req);
610
611
612
		list_del(&list->list);
		kfree(list);
	}
613
	spin_unlock_irqrestore(&hidg->read_spinlock, flags);
614
615
616
617
618
619
620
621
622

	spin_lock_irqsave(&hidg->write_spinlock, flags);
	if (!hidg->write_pending) {
		free_ep_req(hidg->in_ep, hidg->req);
		hidg->write_pending = 1;
	}

	hidg->req = NULL;
	spin_unlock_irqrestore(&hidg->write_spinlock, flags);
623
624
625
626
627
628
}

static int hidg_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
	struct usb_composite_dev		*cdev = f->config->cdev;
	struct f_hidg				*hidg = func_to_hidg(f);
629
630
	struct usb_request			*req_in = NULL;
	unsigned long				flags;
631
	int i, status = 0;
632
633
634
635
636

	VDBG(cdev, "hidg_set_alt intf:%d alt:%d\n", intf, alt);

	if (hidg->in_ep != NULL) {
		/* restart endpoint */
637
		usb_ep_disable(hidg->in_ep);
638

639
640
641
642
643
644
		status = config_ep_by_speed(f->config->cdev->gadget, f,
					    hidg->in_ep);
		if (status) {
			ERROR(cdev, "config_ep_by_speed FAILED!\n");
			goto fail;
		}
645
		status = usb_ep_enable(hidg->in_ep);
646
		if (status < 0) {
647
			ERROR(cdev, "Enable IN endpoint FAILED!\n");
648
649
650
			goto fail;
		}
		hidg->in_ep->driver_data = hidg;
651
652
653
654
655
656

		req_in = hidg_alloc_ep_req(hidg->in_ep, hidg->report_length);
		if (!req_in) {
			status = -ENOMEM;
			goto disable_ep_in;
		}
657
	}
658
659
660
661


	if (hidg->out_ep != NULL) {
		/* restart endpoint */
662
		usb_ep_disable(hidg->out_ep);
663
664
665
666
667

		status = config_ep_by_speed(f->config->cdev->gadget, f,
					    hidg->out_ep);
		if (status) {
			ERROR(cdev, "config_ep_by_speed FAILED!\n");
668
			goto free_req_in;
669
670
671
		}
		status = usb_ep_enable(hidg->out_ep);
		if (status < 0) {
672
			ERROR(cdev, "Enable OUT endpoint FAILED!\n");
673
			goto free_req_in;
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
		}
		hidg->out_ep->driver_data = hidg;

		/*
		 * allocate a bunch of read buffers and queue them all at once.
		 */
		for (i = 0; i < hidg->qlen && status == 0; i++) {
			struct usb_request *req =
					hidg_alloc_ep_req(hidg->out_ep,
							  hidg->report_length);
			if (req) {
				req->complete = hidg_set_report_complete;
				req->context  = hidg;
				status = usb_ep_queue(hidg->out_ep, req,
						      GFP_ATOMIC);
689
				if (status) {
690
691
					ERROR(cdev, "%s queue req --> %d\n",
						hidg->out_ep->name, status);
692
693
					free_ep_req(hidg->out_ep, req);
				}
694
695
			} else {
				status = -ENOMEM;
696
				goto disable_out_ep;
697
698
699
700
			}
		}
	}

701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
	if (hidg->in_ep != NULL) {
		spin_lock_irqsave(&hidg->write_spinlock, flags);
		hidg->req = req_in;
		hidg->write_pending = 0;
		spin_unlock_irqrestore(&hidg->write_spinlock, flags);

		wake_up(&hidg->write_queue);
	}
	return 0;
disable_out_ep:
	usb_ep_disable(hidg->out_ep);
free_req_in:
	if (req_in)
		free_ep_req(hidg->in_ep, req_in);

disable_ep_in:
	if (hidg->in_ep)
		usb_ep_disable(hidg->in_ep);

720
721
722
723
fail:
	return status;
}

724
static const struct file_operations f_hidg_fops = {
725
726
727
728
729
730
	.owner		= THIS_MODULE,
	.open		= f_hidg_open,
	.release	= f_hidg_release,
	.write		= f_hidg_write,
	.read		= f_hidg_read,
	.poll		= f_hidg_poll,
731
	.llseek		= noop_llseek,
732
733
};

734
static int hidg_bind(struct usb_configuration *c, struct usb_function *f)
735
736
737
{
	struct usb_ep		*ep;
	struct f_hidg		*hidg = func_to_hidg(f);
738
	struct usb_string	*us;
739
	struct device		*device;
740
741
742
	int			status;
	dev_t			dev;

743
	/* maybe allocate device-global string IDs, and patch descriptors */
744
745
746
747
748
	us = usb_gstrings_attach(c->cdev, ct_func_strings,
				 ARRAY_SIZE(ct_func_string_defs));
	if (IS_ERR(us))
		return PTR_ERR(us);
	hidg_interface_desc.iInterface = us[CT_FUNC_HID_IDX].id;
749

750
751
752
753
754
755
756
757
758
759
760
761
762
	/* allocate instance-specific interface IDs, and patch descriptors */
	status = usb_interface_id(c, f);
	if (status < 0)
		goto fail;
	hidg_interface_desc.bInterfaceNumber = status;

	/* allocate instance-specific endpoints */
	status = -ENODEV;
	ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_in_ep_desc);
	if (!ep)
		goto fail;
	hidg->in_ep = ep;

763
764
765
766
767
	ep = usb_ep_autoconfig(c->cdev->gadget, &hidg_fs_out_ep_desc);
	if (!ep)
		goto fail;
	hidg->out_ep = ep;

768
769
770
	/* set descriptor dynamic values */
	hidg_interface_desc.bInterfaceSubClass = hidg->bInterfaceSubClass;
	hidg_interface_desc.bInterfaceProtocol = hidg->bInterfaceProtocol;
771
772
773
	hidg_ss_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
	hidg_ss_in_comp_desc.wBytesPerInterval =
				cpu_to_le16(hidg->report_length);
774
775
	hidg_hs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
	hidg_fs_in_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
776
777
778
	hidg_ss_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
	hidg_ss_out_comp_desc.wBytesPerInterval =
				cpu_to_le16(hidg->report_length);
779
780
	hidg_hs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
	hidg_fs_out_ep_desc.wMaxPacketSize = cpu_to_le16(hidg->report_length);
781
782
783
784
	/*
	 * We can use hidg_desc struct here but we should not relay
	 * that its content won't change after returning from this function.
	 */
785
786
787
788
	hidg_desc.desc[0].bDescriptorType = HID_DT_REPORT;
	hidg_desc.desc[0].wDescriptorLength =
		cpu_to_le16(hidg->report_desc_length);

789
790
791
792
	hidg_hs_in_ep_desc.bEndpointAddress =
		hidg_fs_in_ep_desc.bEndpointAddress;
	hidg_hs_out_ep_desc.bEndpointAddress =
		hidg_fs_out_ep_desc.bEndpointAddress;
793

794
795
796
797
798
	hidg_ss_in_ep_desc.bEndpointAddress =
		hidg_fs_in_ep_desc.bEndpointAddress;
	hidg_ss_out_ep_desc.bEndpointAddress =
		hidg_fs_out_ep_desc.bEndpointAddress;

799
	status = usb_assign_descriptors(f, hidg_fs_descriptors,
800
			hidg_hs_descriptors, hidg_ss_descriptors, NULL);
801
802
	if (status)
		goto fail;
803

804
	spin_lock_init(&hidg->write_spinlock);
805
806
	hidg->write_pending = 1;
	hidg->req = NULL;
807
	spin_lock_init(&hidg->read_spinlock);
808
809
	init_waitqueue_head(&hidg->write_queue);
	init_waitqueue_head(&hidg->read_queue);
810
	INIT_LIST_HEAD(&hidg->completed_out_req);
811
812
813
814
815
816

	/* create char device */
	cdev_init(&hidg->cdev, &f_hidg_fops);
	dev = MKDEV(major, hidg->minor);
	status = cdev_add(&hidg->cdev, dev, 1);
	if (status)
817
		goto fail_free_descs;
818

819
820
821
822
823
824
	device = device_create(hidg_class, NULL, dev, NULL,
			       "%s%d", "hidg", hidg->minor);
	if (IS_ERR(device)) {
		status = PTR_ERR(device);
		goto del;
	}
825
826

	return 0;
827
828
del:
	cdev_del(&hidg->cdev);
829
830
fail_free_descs:
	usb_free_all_descriptors(f);
831
832
fail:
	ERROR(f->config->cdev, "hidg_bind FAILED\n");
833
834
	if (hidg->req != NULL)
		free_ep_req(hidg->in_ep, hidg->req);
835
836
837
838

	return status;
}

839
static inline int hidg_get_minor(void)
840
{
841
	int ret;
842

843
	ret = ida_simple_get(&hidg_ida, 0, 0, GFP_KERNEL);
844
845
846
847
	if (ret >= HIDG_MINORS) {
		ida_simple_remove(&hidg_ida, ret);
		ret = -ENODEV;
	}
848

849
850
	return ret;
}
851

852
853
854
855
static inline struct f_hid_opts *to_f_hid_opts(struct config_item *item)
{
	return container_of(to_config_group(item), struct f_hid_opts,
			    func_inst.group);
856
857
}

858
859
860
static void hid_attr_release(struct config_item *item)
{
	struct f_hid_opts *opts = to_f_hid_opts(item);
861

862
863
	usb_put_function_instance(&opts->func_inst);
}
864

865
866
static struct configfs_item_operations hidg_item_ops = {
	.release	= hid_attr_release,
867
868
};

869
#define F_HID_OPT(name, prec, limit)					\
870
static ssize_t f_hid_opts_##name##_show(struct config_item *item, char *page)\
871
{									\
872
	struct f_hid_opts *opts = to_f_hid_opts(item);			\
873
874
875
876
877
878
879
880
881
	int result;							\
									\
	mutex_lock(&opts->lock);					\
	result = sprintf(page, "%d\n", opts->name);			\
	mutex_unlock(&opts->lock);					\
									\
	return result;							\
}									\
									\
882
static ssize_t f_hid_opts_##name##_store(struct config_item *item,	\
883
884
					 const char *page, size_t len)	\
{									\
885
	struct f_hid_opts *opts = to_f_hid_opts(item);			\
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
	int ret;							\
	u##prec num;							\
									\
	mutex_lock(&opts->lock);					\
	if (opts->refcnt) {						\
		ret = -EBUSY;						\
		goto end;						\
	}								\
									\
	ret = kstrtou##prec(page, 0, &num);				\
	if (ret)							\
		goto end;						\
									\
	if (num > limit) {						\
		ret = -EINVAL;						\
		goto end;						\
	}								\
	opts->name = num;						\
	ret = len;							\
									\
end:									\
	mutex_unlock(&opts->lock);					\
	return ret;							\
}									\
									\
911
CONFIGFS_ATTR(f_hid_opts_, name)
912
913
914

F_HID_OPT(subclass, 8, 255);
F_HID_OPT(protocol, 8, 255);
915
F_HID_OPT(report_length, 16, 65535);
916

917
static ssize_t f_hid_opts_report_desc_show(struct config_item *item, char *page)
918
{
919
	struct f_hid_opts *opts = to_f_hid_opts(item);
920
921
922
923
924
925
926
927
928
929
	int result;

	mutex_lock(&opts->lock);
	result = opts->report_desc_length;
	memcpy(page, opts->report_desc, opts->report_desc_length);
	mutex_unlock(&opts->lock);

	return result;
}

930
static ssize_t f_hid_opts_report_desc_store(struct config_item *item,
931
932
					    const char *page, size_t len)
{
933
	struct f_hid_opts *opts = to_f_hid_opts(item);
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
	int ret = -EBUSY;
	char *d;

	mutex_lock(&opts->lock);

	if (opts->refcnt)
		goto end;
	if (len > PAGE_SIZE) {
		ret = -ENOSPC;
		goto end;
	}
	d = kmemdup(page, len, GFP_KERNEL);
	if (!d) {
		ret = -ENOMEM;
		goto end;
	}
	kfree(opts->report_desc);
	opts->report_desc = d;
	opts->report_desc_length = len;
	opts->report_desc_alloc = true;
	ret = len;
end:
	mutex_unlock(&opts->lock);
	return ret;
}

960
CONFIGFS_ATTR(f_hid_opts_, report_desc);
961

962
963
964
965
966
967
968
969
970
static ssize_t f_hid_opts_dev_show(struct config_item *item, char *page)
{
	struct f_hid_opts *opts = to_f_hid_opts(item);

	return sprintf(page, "%d:%d\n", major, opts->minor);
}

CONFIGFS_ATTR_RO(f_hid_opts_, dev);

971
static struct configfs_attribute *hid_attrs[] = {
972
973
974
975
	&f_hid_opts_attr_subclass,
	&f_hid_opts_attr_protocol,
	&f_hid_opts_attr_report_length,
	&f_hid_opts_attr_report_desc,
976
	&f_hid_opts_attr_dev,
977
978
979
	NULL,
};

980
981
982
983
984
static struct config_item_type hid_func_type = {
	.ct_item_ops	= &hidg_item_ops,
	.ct_attrs	= hid_attrs,
	.ct_owner	= THIS_MODULE,
};
985

986
static inline void hidg_put_minor(int minor)
987
{
988
989
	ida_simple_remove(&hidg_ida, minor);
}
990

991
992
993
static void hidg_free_inst(struct usb_function_instance *f)
{
	struct f_hid_opts *opts;
994

995
996
997
998
999
	opts = container_of(f, struct f_hid_opts, func_inst);

	mutex_lock(&hidg_ida_lock);

	hidg_put_minor(opts->minor);
Matthew Wilcox's avatar
Matthew Wilcox committed
1000
	if (ida_is_empty(&hidg_ida))