Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cf9a08ae authored by Sebastian Andrzej Siewior's avatar Sebastian Andrzej Siewior Committed by Felipe Balbi
Browse files

usb: gadget: convert source sink and loopback to new function interface 



This patch converts the f_sourcesink and f_loopback file to the USB-function
module. Both functions shares a few common utility functions which are
currently implemented in g_zero.c itself. This patch moves the common
code into the sourcesink file and creates one module out of the the two
functions (source sink and loop back).
The g_zero gadget is function specific to source sink and loop back to
set a few options. This Symbol dependency enforces a modul load right
now.

Signed-off-by: default avatarSebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: default avatarFelipe Balbi <balbi@ti.com>
parent de53c254

drivers/usb/gadget/Kconfig

+4 −0
Original line number Diff line number Diff line
@@ -500,6 +500,9 @@ config USB_LIBCOMPOSITE 
	tristate

	depends on USB_GADGET



config USB_F_SS_LB

	tristate



choice

	tristate "USB Gadget Drivers"

	default USB_ETH
@@ -524,6 +527,7 @@ choice 
config USB_ZERO

	tristate "Gadget Zero (DEVELOPMENT)"

	select USB_LIBCOMPOSITE

	select USB_F_SS_LB

	help

	  Gadget Zero is a two-configuration device.  It either sinks and

	  sources bulk data; or it loops back a configurable number of

drivers/usb/gadget/Makefile

+4 −0
Original line number Diff line number Diff line
@@ -74,3 +74,7 @@ obj-$(CONFIG_USB_G_WEBCAM) += g_webcam.o 
obj-$(CONFIG_USB_G_NCM)		+= g_ncm.o

obj-$(CONFIG_USB_G_ACM_MS)	+= g_acm_ms.o

obj-$(CONFIG_USB_GADGET_TARGET)	+= tcm_usb_gadget.o



# USB Functions

f_ss_lb-y			:= f_loopback.o f_sourcesink.o

obj-$(CONFIG_USB_F_SS_LB)	+= f_ss_lb.o

drivers/usb/gadget/f_loopback.c

+56 −19
Original line number Diff line number Diff line
@@ -15,10 +15,11 @@ 
#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 "gadget_chips.h"





/*

 * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
@@ -44,9 +45,8 @@ static inline struct f_loopback *func_to_loop(struct usb_function *f) 
	return container_of(f, struct f_loopback, function);

}



static unsigned qlen = 32;

module_param(qlen, uint, 0);

MODULE_PARM_DESC(qlenn, "depth of loopback queue");

static unsigned qlen;

static unsigned buflen;



/*-------------------------------------------------------------------------*/
@@ -171,8 +171,7 @@ static struct usb_gadget_strings *loopback_strings[] = { 


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



static int __init

loopback_bind(struct usb_configuration *c, struct usb_function *f)

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);
@@ -229,8 +228,7 @@ loopback_bind(struct usb_configuration *c, struct usb_function *f) 
	return 0;

}



static void

loopback_unbind(struct usb_configuration *c, struct usb_function *f)

static void lb_free_func(struct usb_function *f)

{

	usb_free_all_descriptors(f);

	kfree(func_to_loop(f));
@@ -372,25 +370,64 @@ static void loopback_disable(struct usb_function *f) 
	disable_loopback(loop);

}



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



static int __init loopback_bind_config(struct usb_configuration *c)

static struct usb_function *loopback_alloc(struct usb_function_instance *fi)

{

	struct f_loopback	*loop;

	int			status;

	struct f_lb_opts	*lb_opts;



	loop = kzalloc(sizeof *loop, GFP_KERNEL);

	if (!loop)

		return -ENOMEM;

		return ERR_PTR(-ENOMEM);



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

	buflen = lb_opts->bulk_buflen;

	qlen = lb_opts->qlen;

	if (!qlen)

		qlen = 32;



	loop->function.name = "loopback";

	loop->function.bind = loopback_bind;

	loop->function.unbind = loopback_unbind;

	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;

}



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);

}



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);

	lb_opts->func_inst.free_func_inst = lb_free_instance;

	return  &lb_opts->func_inst;

}

DECLARE_USB_FUNCTION(Loopback, loopback_alloc_instance, loopback_alloc);



int __init lb_modinit(void)

{

	int ret;



	status = usb_add_function(c, &loop->function);

	if (status)

		kfree(loop);

	return status;

	ret = usb_function_register(&Loopbackusb_func);

	if (ret)

		return ret;

	return ret;

}

void __exit lb_modexit(void)

{

	usb_function_unregister(&Loopbackusb_func);

}



MODULE_LICENSE("GPL");

drivers/usb/gadget/f_sourcesink.c

+114 −51
Original line number Diff line number Diff line
@@ -16,11 +16,12 @@ 
#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/module.h>

#include <linux/usb/composite.h>

#include <linux/err.h>



#include "g_zero.h"

#include "gadget_chips.h"





/*

 * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral

 * controller drivers.
@@ -62,24 +63,11 @@ static inline struct f_sourcesink *func_to_ss(struct usb_function *f) 
}



static unsigned pattern;

module_param(pattern, uint, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63, 2 = none");



static unsigned isoc_interval = 4;

module_param(isoc_interval, uint, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(isoc_interval, "1 - 16");



static unsigned isoc_maxpacket = 1024;

module_param(isoc_maxpacket, uint, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(isoc_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");



static unsigned isoc_interval;

static unsigned isoc_maxpacket;

static unsigned isoc_mult;

module_param(isoc_mult, uint, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(isoc_mult, "0 - 2 (hs/ss only)");



static unsigned isoc_maxburst;

module_param(isoc_maxburst, uint, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)");

static unsigned buflen;



/*-------------------------------------------------------------------------*/
@@ -313,7 +301,57 @@ static struct usb_gadget_strings *sourcesink_strings[] = { 


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



static int __init

struct usb_request *alloc_ep_req(struct usb_ep *ep, int len)

{

	struct usb_request      *req;



	req = usb_ep_alloc_request(ep, GFP_ATOMIC);

	if (req) {

		if (len)

			req->length = len;

		else

			req->length = buflen;

		req->buf = kmalloc(req->length, GFP_ATOMIC);

		if (!req->buf) {

			usb_ep_free_request(ep, req);

			req = NULL;

		}

	}

	return req;

}



void free_ep_req(struct usb_ep *ep, struct usb_request *req)

{

	kfree(req->buf);

	usb_ep_free_request(ep, req);

}



static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)

{

	int			value;



	if (ep->driver_data) {

		value = usb_ep_disable(ep);

		if (value < 0)

			DBG(cdev, "disable %s --> %d\n",

					ep->name, value);

		ep->driver_data = NULL;

	}

}



void disable_endpoints(struct usb_composite_dev *cdev,

		struct usb_ep *in, struct usb_ep *out,

		struct usb_ep *iso_in, struct usb_ep *iso_out)

{

	disable_ep(cdev, in);

	disable_ep(cdev, out);

	if (iso_in)

		disable_ep(cdev, iso_in);

	if (iso_out)

		disable_ep(cdev, iso_out);

}



static int

sourcesink_bind(struct usb_configuration *c, struct usb_function *f)

{

	struct usb_composite_dev *cdev = c->cdev;
@@ -328,14 +366,6 @@ sourcesink_bind(struct usb_configuration *c, struct usb_function *f) 
	source_sink_intf_alt0.bInterfaceNumber = id;

	source_sink_intf_alt1.bInterfaceNumber = id;



	/* allocate string ID(s) */

	id = usb_string_id(cdev);

	if (id < 0)

		return id;

	strings_sourcesink[0].id = id;

	source_sink_intf_alt0.iInterface = id;

	source_sink_intf_alt1.iInterface = id;



	/* allocate bulk endpoints */

	ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);

	if (!ss->in_ep) {
@@ -457,14 +487,11 @@ sourcesink_bind(struct usb_configuration *c, struct usb_function *f) 
	return 0;

}



static struct usb_function *global_ss_func;



static void

sourcesink_unbind(struct usb_configuration *c, struct usb_function *f)

sourcesink_free_func(struct usb_function *f)

{

	usb_free_all_descriptors(f);

	kfree(func_to_ss(f));

	global_ss_func = NULL;

}



/* optionally require specific source/sink data patterns  */
@@ -767,6 +794,7 @@ static void sourcesink_disable(struct usb_function *f) 
}



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



static int sourcesink_setup(struct usb_function *f,

		const struct usb_ctrlrequest *ctrl)

{
@@ -839,41 +867,76 @@ static int sourcesink_setup(struct usb_function *f, 
	return value;

}



static int __init sourcesink_bind_config(struct usb_configuration *c)

static struct usb_function *source_sink_alloc_func(

		struct usb_function_instance *fi)

{

	struct f_sourcesink     *ss;

	int			status;

	struct f_ss_opts	*ss_opts;



	ss = kzalloc(sizeof(*ss), GFP_KERNEL);

	if (!ss)

		return -ENOMEM;

		return NULL;



	global_ss_func = &ss->function;

	ss_opts =  container_of(fi, struct f_ss_opts, func_inst);

	pattern = ss_opts->pattern;

	isoc_interval = ss_opts->isoc_interval;

	isoc_maxpacket = ss_opts->isoc_maxpacket;

	isoc_mult = ss_opts->isoc_mult;

	isoc_maxburst = ss_opts->isoc_maxburst;

	buflen = ss_opts->bulk_buflen;



	ss->function.name = "source/sink";

	ss->function.bind = sourcesink_bind;

	ss->function.unbind = sourcesink_unbind;

	ss->function.set_alt = sourcesink_set_alt;

	ss->function.get_alt = sourcesink_get_alt;

	ss->function.disable = sourcesink_disable;

	ss->function.setup = sourcesink_setup;

	ss->function.strings = sourcesink_strings;



	status = usb_add_function(c, &ss->function);

	if (status)

		kfree(ss);

	return status;

	ss->function.free_func = sourcesink_free_func;



	return &ss->function;

}



static int ss_config_setup(struct usb_configuration *c,

		const struct usb_ctrlrequest *ctrl)

static void acm_free_instance(struct usb_function_instance *fi)

{

	if (!global_ss_func)

		return -EOPNOTSUPP;

	switch (ctrl->bRequest) {

	case 0x5b:

	case 0x5c:

		return global_ss_func->setup(global_ss_func, ctrl);

	default:

		return -EOPNOTSUPP;

	struct f_ss_opts *ss_opts;



	ss_opts = container_of(fi, struct f_ss_opts, func_inst);

	kfree(ss_opts);

}



static struct usb_function_instance *source_sink_alloc_inst(void)

{

	struct f_ss_opts *ss_opts;



	ss_opts = kzalloc(sizeof(*ss_opts), GFP_KERNEL);

	if (!ss_opts)

		return ERR_PTR(-ENOMEM);

	ss_opts->func_inst.free_func_inst = acm_free_instance;

	return &ss_opts->func_inst;

}

DECLARE_USB_FUNCTION(SourceSink, source_sink_alloc_inst,

		source_sink_alloc_func);



static int __init sslb_modinit(void)

{

	int ret;



	ret = usb_function_register(&SourceSinkusb_func);

	if (ret)

		return ret;

	ret = lb_modinit();

	if (ret)

		usb_function_unregister(&SourceSinkusb_func);

	return ret;

}

static void __exit sslb_modexit(void)

{

	usb_function_unregister(&SourceSinkusb_func);

	lb_modexit();

}

module_init(sslb_modinit);

module_exit(sslb_modexit);



MODULE_LICENSE("GPL");

drivers/usb/gadget/g_zero.h

+27 −4
Original line number Diff line number Diff line
@@ -6,11 +6,34 @@ 
#ifndef __G_ZERO_H

#define __G_ZERO_H



#include <linux/usb/composite.h>

struct usb_zero_options {

	unsigned pattern;

	unsigned isoc_interval;

	unsigned isoc_maxpacket;

	unsigned isoc_mult;

	unsigned isoc_maxburst;

	unsigned bulk_buflen;

	unsigned qlen;

};



/* global state */

extern unsigned buflen;

extern const struct usb_descriptor_header *otg_desc[];

struct f_ss_opts {

	struct usb_function_instance func_inst;

	unsigned pattern;

	unsigned isoc_interval;

	unsigned isoc_maxpacket;

	unsigned isoc_mult;

	unsigned isoc_maxburst;

	unsigned bulk_buflen;

};



struct f_lb_opts {

	struct usb_function_instance func_inst;

	unsigned bulk_buflen;

	unsigned qlen;

};



void lb_modexit(void);

int lb_modinit(void);



/* common utilities */

struct usb_request *alloc_ep_req(struct usb_ep *ep, int len);