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

Commit f6c826a9 authored by stephane duverger's avatar stephane duverger Committed by Greg Kroah-Hartman
Browse files

USB: EHCI Debug Port Device Gadget 



This is a patch that implements an USB EHCI Debug Device using the
Gadget API. This patch applies to a 2.6.35-rc3 kernel.

The gadget needs a compliant usb controller that forwards the
USB_DEVICE_DEBUG_MODE feature to its gadget.

The gadget provides two configuration modes, one that only printk() the
received data, and one that exposes a serial device to userland
(/dev/ttyGSxxx).

The gadget has been tested on an IGEPv2 board running a 2.6.35-rc1
kernel. The debug port was fed on the host side by a 2.6.34 kernel.

Signed-off-by: default avatarStephane Duverger <stephane.duverger@gmail.com>
Cc: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent fd63b10b

drivers/usb/gadget/Kconfig

+28 −0
Original line number Diff line number Diff line
@@ -915,6 +915,34 @@ config USB_G_HID 
	  Say "y" to link the driver statically, or "m" to build a

	  dynamically linked module called "g_hid".



config USB_G_DBGP

	tristate "EHCI Debug Device Gadget"

	help

	  This gadget emulates an EHCI Debug device. This is useful when you want

	  to interact with an EHCI Debug Port.



	  Say "y" to link the driver statically, or "m" to build a

	  dynamically linked module called "g_dbgp".



if USB_G_DBGP

choice

	prompt "EHCI Debug Device mode"

	default USB_G_DBGP_SERIAL



config USB_G_DBGP_PRINTK

	depends on USB_G_DBGP

	bool "printk"

	help

	  Directly printk() received data. No interaction.



config USB_G_DBGP_SERIAL

	depends on USB_G_DBGP

	bool "serial"

	help

	  Userland can interact using /dev/ttyGSxxx.

endchoice

endif



# put drivers that need isochronous transfer support (for audio

# or video class gadget drivers), or specific hardware, here.

config USB_G_WEBCAM

drivers/usb/gadget/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -44,6 +44,7 @@ g_printer-objs := printer.o 
g_cdc-objs			:= cdc2.o

g_multi-objs			:= multi.o

g_hid-objs			:= hid.o

g_dbgp-objs			:= dbgp.o

g_nokia-objs			:= nokia.o

g_webcam-objs			:= webcam.o
@@ -60,6 +61,7 @@ obj-$(CONFIG_USB_G_PRINTER) += g_printer.o 
obj-$(CONFIG_USB_MIDI_GADGET)	+= g_midi.o

obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o

obj-$(CONFIG_USB_G_HID)		+= g_hid.o

obj-$(CONFIG_USB_G_DBGP)	+= g_dbgp.o

obj-$(CONFIG_USB_G_MULTI)	+= g_multi.o

obj-$(CONFIG_USB_G_NOKIA)	+= g_nokia.o

obj-$(CONFIG_USB_G_WEBCAM)	+= g_webcam.o

drivers/usb/gadget/dbgp.c

0 → 100644
+434 −0
Original line number Diff line number Diff line 
/*

 * dbgp.c -- EHCI Debug Port device gadget

 *

 * Copyright (C) 2010 Stephane Duverger

 *

 * Released under the GPLv2.

 *

 */



/* verbose messages */

#include <linux/kernel.h>

#include <linux/device.h>

#include <linux/usb/ch9.h>

#include <linux/usb/gadget.h>



/* See comments in "zero.c" */

#include "epautoconf.c"



#ifdef CONFIG_USB_G_DBGP_SERIAL

#include "u_serial.c"

#endif



#define DRIVER_VENDOR_ID	0x0525 /* NetChip */

#define DRIVER_PRODUCT_ID	0xc0de /* undefined */



#define USB_DEBUG_MAX_PACKET_SIZE     8

#define DBGP_REQ_EP0_LEN              128

#define DBGP_REQ_LEN                  512



static struct dbgp {

	struct usb_gadget  *gadget;

	struct usb_request *req;

	struct usb_ep      *i_ep;

	struct usb_ep      *o_ep;

#ifdef CONFIG_USB_G_DBGP_SERIAL

	struct gserial     *serial;

#endif

} dbgp;



static struct usb_device_descriptor device_desc = {

	.bLength = sizeof device_desc,

	.bDescriptorType = USB_DT_DEVICE,

	.bcdUSB = __constant_cpu_to_le16(0x0200),

	.bDeviceClass =	USB_CLASS_VENDOR_SPEC,

	.idVendor = __constant_cpu_to_le16(DRIVER_VENDOR_ID),

	.idProduct = __constant_cpu_to_le16(DRIVER_PRODUCT_ID),

	.bNumConfigurations = 1,

};



static struct usb_debug_descriptor dbg_desc = {

	.bLength = sizeof dbg_desc,

	.bDescriptorType = USB_DT_DEBUG,

};



static struct usb_endpoint_descriptor i_desc = {

	.bLength = USB_DT_ENDPOINT_SIZE,

	.bDescriptorType = USB_DT_ENDPOINT,

	.bmAttributes = USB_ENDPOINT_XFER_BULK,

	.bEndpointAddress = USB_DIR_IN,

};



static struct usb_endpoint_descriptor o_desc = {

	.bLength = USB_DT_ENDPOINT_SIZE,

	.bDescriptorType = USB_DT_ENDPOINT,

	.bmAttributes = USB_ENDPOINT_XFER_BULK,

	.bEndpointAddress = USB_DIR_OUT,

};



#ifdef CONFIG_USB_G_DBGP_PRINTK

static int dbgp_consume(char *buf, unsigned len)

{

	char c;



	if (!len)

		return 0;



	c = buf[len-1];

	if (c != 0)

		buf[len-1] = 0;



	printk(KERN_NOTICE "%s%c", buf, c);

	return 0;

}



static void __disable_ep(struct usb_ep *ep)

{

	if (ep && ep->driver_data == dbgp.gadget) {

		usb_ep_disable(ep);

		ep->driver_data = NULL;

	}

}



static void dbgp_disable_ep(void)

{

	__disable_ep(dbgp.i_ep);

	__disable_ep(dbgp.o_ep);

}



static void dbgp_complete(struct usb_ep *ep, struct usb_request *req)

{

	int stp;

	int err = 0;

	int status = req->status;



	if (ep == dbgp.i_ep) {

		stp = 1;

		goto fail;

	}



	if (status != 0) {

		stp = 2;

		goto release_req;

	}



	dbgp_consume(req->buf, req->actual);



	req->length = DBGP_REQ_LEN;

	err = usb_ep_queue(ep, req, GFP_ATOMIC);

	if (err < 0) {

		stp = 3;

		goto release_req;

	}



	return;



release_req:

	kfree(req->buf);

	usb_ep_free_request(dbgp.o_ep, req);

	dbgp_disable_ep();

fail:

	dev_dbg(&dbgp.gadget->dev,

		"complete: failure (%d:%d) ==> %d\n", stp, err, status);

}



static int dbgp_enable_ep_req(struct usb_ep *ep)

{

	int err, stp;

	struct usb_request *req;



	req = usb_ep_alloc_request(ep, GFP_KERNEL);

	if (!req) {

		err = -ENOMEM;

		stp = 1;

		goto fail_1;

	}



	req->buf = kmalloc(DBGP_REQ_LEN, GFP_KERNEL);

	if (!req->buf) {

		err = -ENOMEM;

		stp = 2;

		goto fail_2;

	}



	req->complete = dbgp_complete;

	req->length = DBGP_REQ_LEN;

	err = usb_ep_queue(ep, req, GFP_ATOMIC);

	if (err < 0) {

		stp = 3;

		goto fail_3;

	}



	return 0;



fail_3:

	kfree(req->buf);

fail_2:

	usb_ep_free_request(dbgp.o_ep, req);

fail_1:

	dev_dbg(&dbgp.gadget->dev,

		"enable ep req: failure (%d:%d)\n", stp, err);

	return err;

}



static int __enable_ep(struct usb_ep *ep, struct usb_endpoint_descriptor *desc)

{

	int err = usb_ep_enable(ep, desc);

	ep->driver_data = dbgp.gadget;

	return err;

}



static int dbgp_enable_ep(void)

{

	int err, stp;



	err = __enable_ep(dbgp.i_ep, &i_desc);

	if (err < 0) {

		stp = 1;

		goto fail_1;

	}



	err = __enable_ep(dbgp.o_ep, &o_desc);

	if (err < 0) {

		stp = 2;

		goto fail_2;

	}



	err = dbgp_enable_ep_req(dbgp.o_ep);

	if (err < 0) {

		stp = 3;

		goto fail_3;

	}



	return 0;



fail_3:

	__disable_ep(dbgp.o_ep);

fail_2:

	__disable_ep(dbgp.i_ep);

fail_1:

	dev_dbg(&dbgp.gadget->dev, "enable ep: failure (%d:%d)\n", stp, err);

	return err;

}

#endif



static void dbgp_disconnect(struct usb_gadget *gadget)

{

#ifdef CONFIG_USB_G_DBGP_PRINTK

	dbgp_disable_ep();

#else

	gserial_disconnect(dbgp.serial);

#endif

}



static void dbgp_unbind(struct usb_gadget *gadget)

{

#ifdef CONFIG_USB_G_DBGP_SERIAL

	kfree(dbgp.serial);

#endif

	if (dbgp.req) {

		kfree(dbgp.req->buf);

		usb_ep_free_request(gadget->ep0, dbgp.req);

	}



	gadget->ep0->driver_data = NULL;

}



static int __init dbgp_configure_endpoints(struct usb_gadget *gadget)

{

	int stp;



	usb_ep_autoconfig_reset(gadget);



	dbgp.i_ep = usb_ep_autoconfig(gadget, &i_desc);

	if (!dbgp.i_ep) {

		stp = 1;

		goto fail_1;

	}



	dbgp.i_ep->driver_data = gadget;

	i_desc.wMaxPacketSize =

		__constant_cpu_to_le16(USB_DEBUG_MAX_PACKET_SIZE);



	dbgp.o_ep = usb_ep_autoconfig(gadget, &o_desc);

	if (!dbgp.o_ep) {

		dbgp.i_ep->driver_data = NULL;

		stp = 2;

		goto fail_2;

	}



	dbgp.o_ep->driver_data = gadget;

	o_desc.wMaxPacketSize =

		__constant_cpu_to_le16(USB_DEBUG_MAX_PACKET_SIZE);



	dbg_desc.bDebugInEndpoint = i_desc.bEndpointAddress & 0x7f;

	dbg_desc.bDebugOutEndpoint = o_desc.bEndpointAddress & 0x7f;



#ifdef CONFIG_USB_G_DBGP_SERIAL

	dbgp.serial->in = dbgp.i_ep;

	dbgp.serial->out = dbgp.o_ep;



	dbgp.serial->in_desc = &i_desc;

	dbgp.serial->out_desc = &o_desc;



	if (gserial_setup(gadget, 1) < 0) {

		stp = 3;

		goto fail_3;

	}



	return 0;



fail_3:

	dbgp.o_ep->driver_data = NULL;

#else

	return 0;

#endif

fail_2:

	dbgp.i_ep->driver_data = NULL;

fail_1:

	dev_dbg(&dbgp.gadget->dev, "ep config: failure (%d)\n", stp);

	return -ENODEV;

}



static int __init dbgp_bind(struct usb_gadget *gadget)

{

	int err, stp;



	dbgp.gadget = gadget;



	dbgp.req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);

	if (!dbgp.req) {

		err = -ENOMEM;

		stp = 1;

		goto fail;

	}



	dbgp.req->buf = kmalloc(DBGP_REQ_EP0_LEN, GFP_KERNEL);

	if (!dbgp.req->buf) {

		err = -ENOMEM;

		stp = 2;

		goto fail;

	}



	dbgp.req->length = DBGP_REQ_EP0_LEN;

	gadget->ep0->driver_data = gadget;



#ifdef CONFIG_USB_G_DBGP_SERIAL

	dbgp.serial = kzalloc(sizeof(struct gserial), GFP_KERNEL);

	if (!dbgp.serial) {

		stp = 3;

		err = -ENOMEM;

		goto fail;

	}

#endif

	err = dbgp_configure_endpoints(gadget);

	if (err < 0) {

		stp = 4;

		goto fail;

	}



	dev_dbg(&dbgp.gadget->dev, "bind: success\n");

	return 0;



fail:

	dev_dbg(&gadget->dev, "bind: failure (%d:%d)\n", stp, err);

	dbgp_unbind(gadget);

	return err;

}



static void dbgp_setup_complete(struct usb_ep *ep,

				struct usb_request *req)

{

	dev_dbg(&dbgp.gadget->dev, "setup complete: %d, %d/%d\n",

		req->status, req->actual, req->length);

}



static int dbgp_setup(struct usb_gadget *gadget,

		      const struct usb_ctrlrequest *ctrl)

{

	struct usb_request *req = dbgp.req;

	u8 request = ctrl->bRequest;

	u16 value = le16_to_cpu(ctrl->wValue);

	u16 length = le16_to_cpu(ctrl->wLength);

	int err = 0;

	void *data;

	u16 len;



	gadget->ep0->driver_data = gadget;



	if (request == USB_REQ_GET_DESCRIPTOR) {

		switch (value>>8) {

		case USB_DT_DEVICE:

			dev_dbg(&dbgp.gadget->dev, "setup: desc device\n");

			len = sizeof device_desc;

			data = &device_desc;

			break;

		case USB_DT_DEBUG:

			dev_dbg(&dbgp.gadget->dev, "setup: desc debug\n");

			len = sizeof dbg_desc;

			data = &dbg_desc;

			break;

		default:

			goto fail;

		}

	} else if (request == USB_REQ_SET_FEATURE &&

		   value == USB_DEVICE_DEBUG_MODE) {

		len = 0;

		data = NULL;

		dev_dbg(&dbgp.gadget->dev, "setup: feat debug\n");

#ifdef CONFIG_USB_G_DBGP_PRINTK

		err = dbgp_enable_ep();

#else

		err = gserial_connect(dbgp.serial, 0);

#endif

		if (err < 0)

			goto fail;

	} else

		goto fail;



	if (len >= 0) {

		req->length = min(length, len);

		req->zero = len < req->length;

		if (data && req->length)

			memcpy(req->buf, data, req->length);



		req->complete = dbgp_setup_complete;

		return usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);

	}



fail:

	dev_dbg(&dbgp.gadget->dev,

		"setup: failure req %x v %x\n", request, value);

	return err;

}



static struct usb_gadget_driver dbgp_driver = {

	.function = "dbgp",

	.speed = USB_SPEED_HIGH,

	.bind = dbgp_bind,

	.unbind = dbgp_unbind,

	.setup = dbgp_setup,

	.disconnect = dbgp_disconnect,

	.driver	= {

		.owner = THIS_MODULE,

		.name = "dbgp"

	},

};



static int __init dbgp_init(void)

{

	return usb_gadget_register_driver(&dbgp_driver);

}



static void __exit dbgp_exit(void)

{

	usb_gadget_unregister_driver(&dbgp_driver);

#ifdef CONFIG_USB_G_DBGP_SERIAL

	gserial_cleanup();

#endif

}



MODULE_AUTHOR("Stephane Duverger");

MODULE_LICENSE("GPL");

module_init(dbgp_init);

module_exit(dbgp_exit);