Release 4.7 drivers/usb/gadget/function/f_loopback.c

Directory: drivers/usb/gadget/function
/*
 * f_loopback.c - USB peripheral loopback configuration driver
 *
 * Copyright (C) 2003-2008 David Brownell
 * Copyright (C) 2008 by Nokia Corporation
 *
 * 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.
 */

/* #define VERBOSE_DEBUG */

#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/usb/composite.h>

#include "g_zero.h"
#include "u_f.h"

/*
 * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
 *
 * This takes messages of various sizes written OUT to a device, and loops
 * them back so they can be read IN from it.  It has been used by certain
 * test applications.  It supports limited testing of data queueing logic.
 */

struct f_loopback {
	
struct usb_function	function;

	
struct usb_ep		*in_ep;
	
struct usb_ep		*out_ep;

	
unsigned                qlen;
	
unsigned                buflen;
};



static inline struct f_loopback *func_to_loop(struct usb_function *f)
{
	return container_of(f, struct f_loopback, function);
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

/*-------------------------------------------------------------------------*/


static struct usb_interface_descriptor loopback_intf = {
	.bLength =		sizeof(loopback_intf),
	.bDescriptorType =	USB_DT_INTERFACE,

	.bNumEndpoints =	2,
	.bInterfaceClass =	USB_CLASS_VENDOR_SPEC,
	/* .iInterface = DYNAMIC */
};

/* full speed support: */


static struct usb_endpoint_descriptor fs_loop_source_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bEndpointAddress =	USB_DIR_IN,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
};


static struct usb_endpoint_descriptor fs_loop_sink_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bEndpointAddress =	USB_DIR_OUT,
	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
};


static struct usb_descriptor_header *fs_loopback_descs[] = {
	(struct usb_descriptor_header *) &loopback_intf,
	(struct usb_descriptor_header *) &fs_loop_sink_desc,
	(struct usb_descriptor_header *) &fs_loop_source_desc,
	NULL,
};

/* high speed support: */


static struct usb_endpoint_descriptor hs_loop_source_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
};


static struct usb_endpoint_descriptor hs_loop_sink_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(512),
};


static struct usb_descriptor_header *hs_loopback_descs[] = {
	(struct usb_descriptor_header *) &loopback_intf,
	(struct usb_descriptor_header *) &hs_loop_source_desc,
	(struct usb_descriptor_header *) &hs_loop_sink_desc,
	NULL,
};

/* super speed support: */


static struct usb_endpoint_descriptor ss_loop_source_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};


static struct usb_ss_ep_comp_descriptor ss_loop_source_comp_desc = {
	.bLength =		USB_DT_SS_EP_COMP_SIZE,
	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
	.bMaxBurst =		0,
	.bmAttributes =		0,
	.wBytesPerInterval =	0,
};


static struct usb_endpoint_descriptor ss_loop_sink_desc = {
	.bLength =		USB_DT_ENDPOINT_SIZE,
	.bDescriptorType =	USB_DT_ENDPOINT,

	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
	.wMaxPacketSize =	cpu_to_le16(1024),
};


static struct usb_ss_ep_comp_descriptor ss_loop_sink_comp_desc = {
	.bLength =		USB_DT_SS_EP_COMP_SIZE,
	.bDescriptorType =	USB_DT_SS_ENDPOINT_COMP,
	.bMaxBurst =		0,
	.bmAttributes =		0,
	.wBytesPerInterval =	0,
};


static struct usb_descriptor_header *ss_loopback_descs[] = {
	(struct usb_descriptor_header *) &loopback_intf,
	(struct usb_descriptor_header *) &ss_loop_source_desc,
	(struct usb_descriptor_header *) &ss_loop_source_comp_desc,
	(struct usb_descriptor_header *) &ss_loop_sink_desc,
	(struct usb_descriptor_header *) &ss_loop_sink_comp_desc,
	NULL,
};

/* function-specific strings: */


static struct usb_string strings_loopback[] = {
	[0].s = "loop input to output",
	{  }			/* end of list */
};


static struct usb_gadget_strings stringtab_loop = {
	.language	= 0x0409,	/* en-us */
	.strings	= strings_loopback,
};


static struct usb_gadget_strings *loopback_strings[] = {
	&stringtab_loop,
	NULL,
};

/*-------------------------------------------------------------------------*/



static int loopback_bind(struct usb_configuration *c, struct usb_function *f)
{
	struct usb_composite_dev *cdev = c->cdev;
	struct f_loopback	*loop = func_to_loop(f);
	int			id;
	int ret;

	/* allocate interface ID(s) */
	id = usb_interface_id(c, f);
	if (id < 0)
		return id;
	loopback_intf.bInterfaceNumber = id;

	id = usb_string_id(cdev);
	if (id < 0)
		return id;
	strings_loopback[0].id = id;
	loopback_intf.iInterface = id;

	/* allocate endpoints */

	loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_source_desc);
	if (!loop->in_ep) {
autoconf_fail:
		ERROR(cdev, "%s: can't autoconfigure on %s\n",
			f->name, cdev->gadget->name);
		return -ENODEV;
	}

	loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_loop_sink_desc);
	if (!loop->out_ep)
		goto autoconf_fail;

	/* support high speed hardware */
	hs_loop_source_desc.bEndpointAddress =
		fs_loop_source_desc.bEndpointAddress;
	hs_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;

	/* support super speed hardware */
	ss_loop_source_desc.bEndpointAddress =
		fs_loop_source_desc.bEndpointAddress;
	ss_loop_sink_desc.bEndpointAddress = fs_loop_sink_desc.bEndpointAddress;

	ret = usb_assign_descriptors(f, fs_loopback_descs, hs_loopback_descs,
			ss_loopback_descs, NULL);
	if (ret)
		return ret;

	DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
	    (gadget_is_superspeed(c->cdev->gadget) ? "super" :
	     (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
			f->name, loop->in_ep->name, loop->out_ep->name);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 190 68.35% 2 33.33%
sebastian andrzej siewior sebastian andrzej siewior 51 18.35% 2 33.33%
amit blay amit blay 35 12.59% 1 16.67%
john youn john youn 2 0.72% 1 16.67%
Total 278 100.00% 6 100.00%



static void lb_free_func(struct usb_function *f)
{
	struct f_lb_opts *opts;

	opts = container_of(f->fi, struct f_lb_opts, func_inst);

	mutex_lock(&opts->lock);
	opts->refcnt--;
	mutex_unlock(&opts->lock);

	usb_free_all_descriptors(f);
	kfree(func_to_loop(f));
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 40 62.50% 1 25.00%
david brownell david brownell 18 28.12% 1 25.00%
sebastian andrzej siewior sebastian andrzej siewior 6 9.38% 2 50.00%
Total 64 100.00% 4 100.00%



static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
{
	struct f_loopback	*loop = ep->driver_data;
	struct usb_composite_dev *cdev = loop->function.config->cdev;
	int			status = req->status;

	switch (status) {
	case 0:				/* normal completion? */
		if (ep == loop->out_ep) {
			/*
                         * We received some data from the host so let's
                         * queue it so host can read the from our in ep
                         */
			struct usb_request *in_req = req->context;

			in_req->zero = (req->actual < req->length);
			in_req->length = req->actual;
			ep = loop->in_ep;
			req = in_req;
		} else {
			/*
                         * We have just looped back a bunch of data
                         * to host. Now let's wait for some more data.
                         */
			req = req->context;
			ep = loop->out_ep;
		}

		/* queue the buffer back to host or for next bunch of data */
		status = usb_ep_queue(ep, req, GFP_ATOMIC);
		if (status == 0) {
			return;
		} else {
			ERROR(cdev, "Unable to loop back buffer to %s: %d\n",
			      ep->name, status);
			goto free_req;
		}

		/* "should never get here" */
	default:
		ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
				status, req->actual, req->length);
		/* FALLTHROUGH */

	/* NOTE:  since this driver doesn't maintain an explicit record
         * of requests it submitted (just maintains qlen count), we
         * rely on the hardware driver to clean up on disconnect or
         * endpoint disable.
         */
	case -ECONNABORTED:		/* hardware forced ep reset */
	case -ECONNRESET:		/* request dequeued */
	case -ESHUTDOWN:		/* disconnect from host */
free_req:
		usb_ep_free_request(ep == loop->in_ep ?
				    loop->out_ep : loop->in_ep,
				    req->context);
		free_ep_req(ep, req);
		return;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 155 66.24% 1 25.00%
krzysztof opasiak krzysztof opasiak 78 33.33% 2 50.00%
felipe balbi felipe balbi 1 0.43% 1 25.00%
Total 234 100.00% 4 100.00%



static void disable_loopback(struct f_loopback *loop)
{
	struct usb_composite_dev	*cdev;

	cdev = loop->function.config->cdev;
	disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL);
	VDBG(cdev, "%s disabled\n", loop->function.name);
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 52 92.86% 1 50.00%
paul zimmerman paul zimmerman 4 7.14% 1 50.00%
Total 56 100.00% 2 100.00%



static inline struct usb_request *lb_alloc_ep_req(struct usb_ep *ep, int len)
{
	struct f_loopback	*loop = ep->driver_data;

	return alloc_ep_req(ep, len, loop->buflen);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 27 71.05% 1 50.00%
krzysztof opasiak krzysztof opasiak 11 28.95% 1 50.00%
Total 38 100.00% 2 100.00%



static int alloc_requests(struct usb_composite_dev *cdev,
			  struct f_loopback *loop)
{
	struct usb_request *in_req, *out_req;
	int i;
	int result = 0;

	/*
         * allocate a bunch of read buffers and queue them all at once.
         * we buffer at most 'qlen' transfers; We allocate buffers only
         * for out transfer and reuse them in IN transfers to implement
         * our loopback functionality
         */
	for (i = 0; i < loop->qlen && result == 0; i++) {
		result = -ENOMEM;

		in_req = usb_ep_alloc_request(loop->in_ep, GFP_ATOMIC);
		if (!in_req)
			goto fail;

		out_req = lb_alloc_ep_req(loop->out_ep, 0);
		if (!out_req)
			goto fail_in;

		in_req->complete = loopback_complete;
		out_req->complete = loopback_complete;

		in_req->buf = out_req->buf;
		/* length will be set in complete routine */
		in_req->context = out_req;
		out_req->context = in_req;

		result = usb_ep_queue(loop->out_ep, out_req, GFP_ATOMIC);
		if (result) {
			ERROR(cdev, "%s queue req --> %d\n",
					loop->out_ep->name, result);
			goto fail_out;
		}
	}

	return 0;

fail_out:
	free_ep_req(loop->out_ep, out_req);
fail_in:
	usb_ep_free_request(loop->in_ep, in_req);
fail:
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
krzysztof opasiak krzysztof opasiak 102 51.78% 2 28.57%
david brownell david brownell 77 39.09% 1 14.29%
felipe balbi felipe balbi 14 7.11% 1 14.29%
paul zimmerman paul zimmerman 2 1.02% 1 14.29%
andrzej pietrasiewicz andrzej pietrasiewicz 1 0.51% 1 14.29%
peter chen peter chen 1 0.51% 1 14.29%
Total 197 100.00% 7 100.00%



static int enable_endpoint(struct usb_composite_dev *cdev,
			   struct f_loopback *loop, struct usb_ep *ep)
{
	int					result;

	result = config_ep_by_speed(cdev->gadget, &(loop->function), ep);
	if (result)
		goto out;

	result = usb_ep_enable(ep);
	if (result < 0)
		goto out;
	ep->driver_data = loop;
	result = 0;

out:
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
krzysztof opasiak krzysztof opasiak 72 90.00% 1 33.33%
felipe balbi felipe balbi 5 6.25% 1 33.33%
david brownell david brownell 3 3.75% 1 33.33%
Total 80 100.00% 3 100.00%


static int

enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
{
	int					result = 0;

	result = enable_endpoint(cdev, loop, loop->in_ep);
	if (result)
		goto out;

	result = enable_endpoint(cdev, loop, loop->out_ep);
	if (result)
		goto disable_in;

	result = alloc_requests(cdev, loop);
	if (result)
		goto disable_out;

	DBG(cdev, "%s enabled\n", loop->function.name);
	return 0;

disable_out:
	usb_ep_disable(loop->out_ep);
disable_in:
	usb_ep_disable(loop->in_ep);
out:
	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
felipe balbi felipe balbi 50 43.10% 1 33.33%
krzysztof opasiak krzysztof opasiak 44 37.93% 1 33.33%
david brownell david brownell 22 18.97% 1 33.33%
Total 116 100.00% 3 100.00%



static int loopback_set_alt(struct usb_function *f,
		unsigned intf, unsigned alt)
{
	struct f_loopback	*loop = func_to_loop(f);
	struct usb_composite_dev *cdev = f->config->cdev;

	/* we know alt is zero */
	disable_loopback(loop);
	return enable_loopback(cdev, loop);
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 52 100.00% 1 100.00%
Total 52 100.00% 1 100.00%



static void loopback_disable(struct usb_function *f)
{
	struct f_loopback	*loop = func_to_loop(f);

	disable_loopback(loop);
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static struct usb_function *loopback_alloc(struct usb_function_instance *fi)
{
	struct f_loopback	*loop;
	struct f_lb_opts	*lb_opts;

	loop = kzalloc(sizeof *loop, GFP_KERNEL);
	if (!loop)
		return ERR_PTR(-ENOMEM);

	lb_opts = container_of(fi, struct f_lb_opts, func_inst);

	mutex_lock(&lb_opts->lock);
	lb_opts->refcnt++;
	mutex_unlock(&lb_opts->lock);

	loop->buflen = lb_opts->bulk_buflen;
	loop->qlen = lb_opts->qlen;
	if (!loop->qlen)
		loop->qlen = 32;

	loop->function.name = "loopback";
	loop->function.bind = loopback_bind;
	loop->function.set_alt = loopback_set_alt;
	loop->function.disable = loopback_disable;
	loop->function.strings = loopback_strings;

	loop->function.free_func = lb_free_func;

	return &loop->function;
}

Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 71 43.83% 1 25.00%
sebastian andrzej siewior sebastian andrzej siewior 62 38.27% 1 25.00%
andrzej pietrasiewicz andrzej pietrasiewicz 21 12.96% 1 25.00%
krzysztof opasiak krzysztof opasiak 8 4.94% 1 25.00%
Total 162 100.00% 4 100.00%



static inline struct f_lb_opts *to_f_lb_opts(struct config_item *item)
{
	return container_of(to_config_group(item), struct f_lb_opts,
			    func_inst.group);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static void lb_attr_release(struct config_item *item)
{
	struct f_lb_opts *lb_opts = to_f_lb_opts(item);

	usb_put_function_instance(&lb_opts->func_inst);
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


static struct configfs_item_operations lb_item_ops = {
	.release		= lb_attr_release,
};



static ssize_t f_lb_opts_qlen_show(struct config_item *item, char *page)
{
	struct f_lb_opts *opts = to_f_lb_opts(item);
	int result;

	mutex_lock(&opts->lock);
	result = sprintf(page, "%d\n", opts->qlen);
	mutex_unlock(&opts->lock);

	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 47 78.33% 1 33.33%
christoph hellwig christoph hellwig 12 20.00% 1 33.33%
krzysztof opasiak krzysztof opasiak 1 1.67% 1 33.33%
Total 60 100.00% 3 100.00%



static ssize_t f_lb_opts_qlen_store(struct config_item *item,
				    const char *page, size_t len)
{
	struct f_lb_opts *opts = to_f_lb_opts(item);
	int ret;
	u32 num;

	mutex_lock(&opts->lock);
	if (opts->refcnt) {
		ret = -EBUSY;
		goto end;
	}

	ret = kstrtou32(page, 0, &num);
	if (ret)
		goto end;

	opts->qlen = num;
	ret = len;
end:
	mutex_unlock(&opts->lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 89 88.12% 1 50.00%
christoph hellwig christoph hellwig 12 11.88% 1 50.00%
Total 101 100.00% 2 100.00%

CONFIGFS_ATTR(f_lb_opts_, qlen);



static ssize_t f_lb_opts_bulk_buflen_show(struct config_item *item, char *page)
{
	struct f_lb_opts *opts = to_f_lb_opts(item);
	int result;

	mutex_lock(&opts->lock);
	result = sprintf(page, "%d\n", opts->bulk_buflen);
	mutex_unlock(&opts->lock);

	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 47 78.33% 1 33.33%
christoph hellwig christoph hellwig 12 20.00% 1 33.33%
krzysztof opasiak krzysztof opasiak 1 1.67% 1 33.33%
Total 60 100.00% 3 100.00%



static ssize_t f_lb_opts_bulk_buflen_store(struct config_item *item,
				    const char *page, size_t len)
{
	struct f_lb_opts *opts = to_f_lb_opts(item);
	int ret;
	u32 num;

	mutex_lock(&opts->lock);
	if (opts->refcnt) {
		ret = -EBUSY;
		goto end;
	}

	ret = kstrtou32(page, 0, &num);
	if (ret)
		goto end;

	opts->bulk_buflen = num;
	ret = len;
end:
	mutex_unlock(&opts->lock);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrzej pietrasiewicz andrzej pietrasiewicz 89 88.12% 1 50.00%
christoph hellwig christoph hellwig 12 11.88% 1 50.00%
Total 101 100.00% 2 100.00%

CONFIGFS_ATTR(f_lb_opts_, bulk_buflen);


static struct configfs_attribute *lb_attrs[] = {
	&f_lb_opts_attr_qlen,
	&f_lb_opts_attr_bulk_buflen,
	NULL,
};


static struct config_item_type lb_func_type = {
	.ct_item_ops    = &lb_item_ops,
	.ct_attrs	= lb_attrs,
	.ct_owner       = THIS_MODULE,
};



static void lb_free_instance(struct usb_function_instance *fi)
{
	struct f_lb_opts *lb_opts;

	lb_opts = container_of(fi, struct f_lb_opts, func_inst);
	kfree(lb_opts);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%



static struct usb_function_instance *loopback_alloc_instance(void)
{
	struct f_lb_opts *lb_opts;

	lb_opts = kzalloc(sizeof(*lb_opts), GFP_KERNEL);
	if (!lb_opts)
		return ERR_PTR(-ENOMEM);
	mutex_init(&lb_opts->lock);
	lb_opts->func_inst.free_func_inst = lb_free_instance;
	lb_opts->bulk_buflen = GZERO_BULK_BUFLEN;
	lb_opts->qlen = GZERO_QLEN;

	config_group_init_type_name(&lb_opts->func_inst.group, "",
				    &lb_func_type);

	return  &lb_opts->func_inst;
}
Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 45 50.56% 1 33.33%
andrzej pietrasiewicz andrzej pietrasiewicz 35 39.33% 1 33.33%
david brownell david brownell 9 10.11% 1 33.33%
Total 89 100.00% 3 100.00%

DECLARE_USB_FUNCTION(Loopback, loopback_alloc_instance, loopback_alloc);



int __init lb_modinit(void)
{
	int ret;

	ret = usb_function_register(&Loopbackusb_func);
	if (ret)
		return ret;
	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 27 93.10% 1 50.00%
david brownell david brownell 2 6.90% 1 50.00%
Total 29 100.00% 2 100.00%



void __exit lb_modexit(void)
{
	usb_function_unregister(&Loopbackusb_func);
}

Contributors
Person Tokens Prop Commits CommitProp
sebastian andrzej siewior sebastian andrzej siewior 14 100.00% 1 100.00%
Total 14 100.00% 1 100.00%

MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
david brownell david brownell 1000 40.75% 2 9.52%
andrzej pietrasiewicz andrzej pietrasiewicz 514 20.95% 2 9.52%
krzysztof opasiak krzysztof opasiak 326 13.28% 4 19.05%
sebastian andrzej siewior sebastian andrzej siewior 260 10.59% 3 14.29%
amit blay amit blay 209 8.52% 1 4.76%
felipe balbi felipe balbi 70 2.85% 1 4.76%
christoph hellwig christoph hellwig 58 2.36% 1 4.76%
paul zimmerman paul zimmerman 6 0.24% 1 4.76%
tejun heo tejun heo 3 0.12% 1 4.76%
jingoo han jingoo han 2 0.08% 1 4.76%
harvey harrison harvey harrison 2 0.08% 1 4.76%
john youn john youn 2 0.08% 1 4.76%
peter chen peter chen 1 0.04% 1 4.76%
klaus schwarzkopf klaus schwarzkopf 1 0.04% 1 4.76%
Total 2454 100.00% 21 100.00%
  Directory: drivers/usb/gadget/function

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
david brownell	david brownell	25	100.00%	1	100.00%
	Total	25	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/usb/gadget/function/f_loopback.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
