1159 lines · 28.7 KB · C
RawDownload
/* * 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>#include <linux/idr.h>#include <linux/cdev.h>#include <linux/mutex.h>#include <linux/poll.h>#include <linux/uaccess.h>#include <linux/wait.h>#include <linux/sched.h>#include <linux/usb/g_hid.h> #include "u_f.h"#include "u_hid.h" #define HIDG_MINORS	4 static int major, minors;static struct class *hidg_class;static DEFINE_IDA(hidg_ida);static DEFINE_MUTEX(hidg_ida_lock); /* protects access to hidg_ida */ /*-------------------------------------------------------------------------*//*                            HID gadget struct                            */ struct f_hidg_req_list {	struct usb_request	*req;	unsigned int		pos;	struct list_head 	list;}; struct f_hidg {	/* configuration */	unsigned char			bInterfaceSubClass;	unsigned char			bInterfaceProtocol;	unsigned short			report_desc_length;	char				*report_desc;	unsigned short			report_length; 	/* recv report */	struct list_head		completed_out_req;	spinlock_t			read_spinlock;	wait_queue_head_t		read_queue;	unsigned int			qlen; 	/* send report */	spinlock_t			write_spinlock;	bool				write_pending;	wait_queue_head_t		write_queue;	struct usb_request		*req; 	int				minor;	struct cdev			cdev;	struct usb_function		func; 	struct usb_ep			*in_ep;	struct usb_ep			*out_ep;}; 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,	.bNumEndpoints		= 2,	.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 */}; /* 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,}; /* 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)				      */}; 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)				      */}; 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,	(struct usb_descriptor_header *)&hidg_hs_out_ep_desc,	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)				       */}; 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)				       */}; 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,	(struct usb_descriptor_header *)&hidg_fs_out_ep_desc,	NULL,}; /*-------------------------------------------------------------------------*//*                                 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,}; /*-------------------------------------------------------------------------*//*                              Char Device                                */ static ssize_t f_hidg_read(struct file *file, char __user *buffer,			size_t count, loff_t *ptr){	struct f_hidg *hidg = file->private_data;	struct f_hidg_req_list *list;	struct usb_request *req;	unsigned long flags;	int ret; 	if (!count)		return 0; 	if (!access_ok(VERIFY_WRITE, buffer, count))		return -EFAULT; 	spin_lock_irqsave(&hidg->read_spinlock, flags); #define READ_COND (!list_empty(&hidg->completed_out_req)) 	/* wait for at least one buffer to complete */	while (!READ_COND) {		spin_unlock_irqrestore(&hidg->read_spinlock, flags);		if (file->f_flags & O_NONBLOCK)			return -EAGAIN; 		if (wait_event_interruptible(hidg->read_queue, READ_COND))			return -ERESTARTSYS; 		spin_lock_irqsave(&hidg->read_spinlock, flags);	} 	/* pick the first one */	list = list_first_entry(&hidg->completed_out_req,				struct f_hidg_req_list, list); 	/*	 * Remove this from list to protect it from beign free()	 * while host disables our function	 */	list_del(&list->list); 	req = list->req;	count = min_t(unsigned int, count, req->actual - list->pos);	spin_unlock_irqrestore(&hidg->read_spinlock, flags); 	/* 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);		if (ret < 0) {			free_ep_req(hidg->out_ep, req);			return ret;		}	} else {		spin_lock_irqsave(&hidg->read_spinlock, flags);		list_add(&list->list, &hidg->completed_out_req);		spin_unlock_irqrestore(&hidg->read_spinlock, flags); 		wake_up(&hidg->read_queue);	} 	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;	unsigned long flags; 	if (req->status != 0) {		ERROR(hidg->func.config->cdev,			"End Point Request ERROR: %d\n", req->status);	} 	spin_lock_irqsave(&hidg->write_spinlock, flags);	hidg->write_pending = 0;	spin_unlock_irqrestore(&hidg->write_spinlock, flags);	wake_up(&hidg->write_queue);} static ssize_t f_hidg_write(struct file *file, const char __user *buffer,			    size_t count, loff_t *offp){	struct f_hidg *hidg  = file->private_data;	struct usb_request *req;	unsigned long flags;	ssize_t status = -ENOMEM; 	if (!access_ok(VERIFY_READ, buffer, count))		return -EFAULT; 	spin_lock_irqsave(&hidg->write_spinlock, flags); #define WRITE_COND (!hidg->write_pending)try_again:	/* write queue */	while (!WRITE_COND) {		spin_unlock_irqrestore(&hidg->write_spinlock, flags);		if (file->f_flags & O_NONBLOCK)			return -EAGAIN; 		if (wait_event_interruptible_exclusive(				hidg->write_queue, WRITE_COND))			return -ERESTARTSYS; 		spin_lock_irqsave(&hidg->write_spinlock, flags);	} 	hidg->write_pending = 1;	req = hidg->req;	count  = min_t(unsigned, count, hidg->report_length); 	spin_unlock_irqrestore(&hidg->write_spinlock, flags);	status = copy_from_user(req->buf, buffer, count); 	if (status != 0) {		ERROR(hidg->func.config->cdev,			"copy_from_user error\n");		status = -EINVAL;		goto release_write_pending;	} 	spin_lock_irqsave(&hidg->write_spinlock, flags); 	/* when our function has been disabled by host */	if (!hidg->req) {		free_ep_req(hidg->in_ep, req);		/*		 * 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; 	status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);	if (status < 0) {		ERROR(hidg->func.config->cdev,			"usb_ep_queue error on int endpoint %zd\n", status);		goto release_write_pending_unlocked;	} else {		status = count;	}	spin_unlock_irqrestore(&hidg->write_spinlock, flags); 	return status;release_write_pending:	spin_lock_irqsave(&hidg->write_spinlock, flags);release_write_pending_unlocked:	hidg->write_pending = 0;	spin_unlock_irqrestore(&hidg->write_spinlock, flags); 	wake_up(&hidg->write_queue); 	return status;} static unsigned int f_hidg_poll(struct file *file, poll_table *wait){	struct f_hidg	*hidg  = file->private_data;	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                             */ static inline struct usb_request *hidg_alloc_ep_req(struct usb_ep *ep,						    unsigned length){	return alloc_ep_req(ep, length);} static void hidg_set_report_complete(struct usb_ep *ep, struct usb_request *req){	struct f_hidg *hidg = (struct f_hidg *) req->context;	struct usb_composite_dev *cdev = hidg->func.config->cdev;	struct f_hidg_req_list *req_list;	unsigned long flags; 	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;		} 		req_list->req = req; 		spin_lock_irqsave(&hidg->read_spinlock, flags);		list_add_tail(&req_list->list, &hidg->completed_out_req);		spin_unlock_irqrestore(&hidg->read_spinlock, flags); 		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;	}} static int hidg_setup(struct usb_function *f,		const struct usb_ctrlrequest *ctrl)

Lines 1–500 of 1159.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t