USB: gadget: add USB Audio Gadget driver (c6994e6f) · Commits · e / devices / android_kernel_teracube_2e

drivers/usb/gadget/Kconfig

+14 −0

Original line number	Diff line number	Diff line
		@@ -580,6 +580,20 @@ config USB_ZERO_HNPTEST
		the "B-Peripheral" role, that device will use HNP to let this
		one serve as the USB host instead (in the "B-Host" role).

		config USB_AUDIO
		tristate "Audio Gadget (EXPERIMENTAL)"
		depends on SND
		help
		Gadget Audio is compatible with USB Audio Class specification 1.0.
		It will include at least one AudioControl interface, zero or more
		AudioStream interface and zero or more MIDIStream interface.

		Gadget Audio will use on-board ALSA (CONFIG_SND) audio card to
		playback or capture audio stream.

		Say "y" to link the driver statically, or "m" to build a
		dynamically linked module called "g_audio".

		config USB_ETH
		tristate "Ethernet Gadget (with CDC Ethernet support)"
		depends on NET

drivers/usb/gadget/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@ obj-$(CONFIG_USB_S3C_HSOTG) += s3c-hsotg.o
		# USB gadget drivers
		#
		g_zero-objs := zero.o
		g_audio-objs := audio.o
		g_ether-objs := ether.o
		g_serial-objs := serial.o
		g_midi-objs := gmidi.o
		@@ -40,6 +41,7 @@ g_printer-objs := printer.o
		g_cdc-objs := cdc2.o

		obj-$(CONFIG_USB_ZERO) += g_zero.o
		obj-$(CONFIG_USB_AUDIO) += g_audio.o
		obj-$(CONFIG_USB_ETH) += g_ether.o
		obj-$(CONFIG_USB_GADGETFS) += gadgetfs.o
		obj-$(CONFIG_USB_FILE_STORAGE) += g_file_storage.o

drivers/usb/gadget/audio.c

0 → 100644

+302 −0

Original line number	Diff line number	Diff line
		/*
		* audio.c -- Audio gadget driver
		*
		* Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
		* Copyright (C) 2008 Analog Devices, Inc
		*
		* Enter bugs at http://blackfin.uclinux.org/
		*
		* Licensed under the GPL-2 or later.
		*/

		/* #define VERBOSE_DEBUG */

		#include <linux/kernel.h>
		#include <linux/utsname.h>

		#include "u_audio.h"

		#define DRIVER_DESC "Linux USB Audio Gadget"
		#define DRIVER_VERSION "Dec 18, 2008"

		/-------------------------------------------------------------------------/

		/*
		* Kbuild is not very cooperative with respect to linking separately
		* compiled library objects into one module. So for now we won't use
		* separate compilation ... ensuring init/exit sections work to shrink
		* the runtime footprint, and giving us at least some parts of what
		* a "gcc --combine ... part1.c part2.c part3.c ... " build would.
		*/
		#include "composite.c"
		#include "usbstring.c"
		#include "config.c"
		#include "epautoconf.c"

		#include "u_audio.c"
		#include "f_audio.c"

		/-------------------------------------------------------------------------/

		/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
		* Instead: allocate your own, using normal USB-IF procedures.
		*/

		/* Thanks to NetChip Technologies for donating this product ID. */
		#define AUDIO_VENDOR_NUM 0x0525 /* NetChip */
		#define AUDIO_PRODUCT_NUM 0xa4a1 /* Linux-USB Audio Gadget */

		/-------------------------------------------------------------------------/

		static struct usb_device_descriptor device_desc = {
		.bLength = sizeof device_desc,
		.bDescriptorType = USB_DT_DEVICE,

		.bcdUSB = __constant_cpu_to_le16(0x200),

		.bDeviceClass = USB_CLASS_PER_INTERFACE,
		.bDeviceSubClass = 0,
		.bDeviceProtocol = 0,
		/* .bMaxPacketSize0 = f(hardware) */

		/* Vendor and product id defaults change according to what configs
		* we support. (As does bNumConfigurations.) These values can
		* also be overridden by module parameters.
		*/
		.idVendor = __constant_cpu_to_le16(AUDIO_VENDOR_NUM),
		.idProduct = __constant_cpu_to_le16(AUDIO_PRODUCT_NUM),
		/* .bcdDevice = f(hardware) */
		/* .iManufacturer = DYNAMIC */
		/* .iProduct = DYNAMIC */
		/* NO SERIAL NUMBER */
		.bNumConfigurations = 1,
		};

		static struct usb_otg_descriptor otg_descriptor = {
		.bLength = sizeof otg_descriptor,
		.bDescriptorType = USB_DT_OTG,

		/* REVISIT SRP-only hardware is possible, although
		* it would not be called "OTG" ...
		*/
		.bmAttributes = USB_OTG_SRP \| USB_OTG_HNP,
		};

		static const struct usb_descriptor_header *otg_desc[] = {
		(struct usb_descriptor_header *) &otg_descriptor,
		NULL,
		};

		/-------------------------------------------------------------------------/

		/**
		* Handle USB audio endpoint set/get command in setup class request
		*/

		static int audio_set_endpoint_req(struct usb_configuration *c,
		const struct usb_ctrlrequest *ctrl)
		{
		struct usb_composite_dev *cdev = c->cdev;
		int value = -EOPNOTSUPP;
		u16 ep = le16_to_cpu(ctrl->wIndex);
		u16 len = le16_to_cpu(ctrl->wLength);
		u16 w_value = le16_to_cpu(ctrl->wValue);

		DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
		ctrl->bRequest, w_value, len, ep);

		switch (ctrl->bRequest) {
		case SET_CUR:
		value = 0;
		break;

		case SET_MIN:
		break;

		case SET_MAX:
		break;

		case SET_RES:
		break;

		case SET_MEM:
		break;

		default:
		break;
		}

		return value;
		}

		static int audio_get_endpoint_req(struct usb_configuration *c,
		const struct usb_ctrlrequest *ctrl)
		{
		struct usb_composite_dev *cdev = c->cdev;
		int value = -EOPNOTSUPP;
		u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
		u16 len = le16_to_cpu(ctrl->wLength);
		u16 w_value = le16_to_cpu(ctrl->wValue);

		DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
		ctrl->bRequest, w_value, len, ep);

		switch (ctrl->bRequest) {
		case GET_CUR:
		case GET_MIN:
		case GET_MAX:
		case GET_RES:
		value = 3;
		break;
		case GET_MEM:
		break;
		default:
		break;
		}

		return value;
		}

		static int
		audio_setup(struct usb_configuration c, const struct usb_ctrlrequest ctrl)
		{
		struct usb_composite_dev *cdev = c->cdev;
		struct usb_request *req = cdev->req;
		int value = -EOPNOTSUPP;
		u16 w_index = le16_to_cpu(ctrl->wIndex);
		u16 w_value = le16_to_cpu(ctrl->wValue);
		u16 w_length = le16_to_cpu(ctrl->wLength);

		/* composite driver infrastructure handles everything except
		* Audio class messages; interface activation uses set_alt().
		*/
		switch (ctrl->bRequestType) {
		case USB_AUDIO_SET_ENDPOINT:
		value = audio_set_endpoint_req(c, ctrl);
		break;

		case USB_AUDIO_GET_ENDPOINT:
		value = audio_get_endpoint_req(c, ctrl);
		break;

		default:
		ERROR(cdev, "Invalid control req%02x.%02x v%04x i%04x l%d\n",
		ctrl->bRequestType, ctrl->bRequest,
		w_value, w_index, w_length);
		}

		/* respond with data transfer or status phase? */
		if (value >= 0) {
		DBG(cdev, "Audio req%02x.%02x v%04x i%04x l%d\n",
		ctrl->bRequestType, ctrl->bRequest,
		w_value, w_index, w_length);
		req->zero = 0;
		req->length = value;
		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
		if (value < 0)
		ERROR(cdev, "Audio response on err %d\n", value);
		}

		/* device either stalls (value < 0) or reports success */
		return value;
		}

		/-------------------------------------------------------------------------/

		static int __init audio_do_config(struct usb_configuration *c)
		{
		/* FIXME alloc iConfiguration string, set it in c->strings */

		if (gadget_is_otg(c->cdev->gadget)) {
		c->descriptors = otg_desc;
		c->bmAttributes \|= USB_CONFIG_ATT_WAKEUP;
		}

		audio_bind_config(c);

		return 0;
		}

		static struct usb_configuration audio_config_driver = {
		.label = DRIVER_DESC,
		.bind = audio_do_config,
		.setup = audio_setup,
		.bConfigurationValue = 1,
		/* .iConfiguration = DYNAMIC */
		.bmAttributes = USB_CONFIG_ATT_SELFPOWER,
		};

		/-------------------------------------------------------------------------/

		static int __init audio_bind(struct usb_composite_dev *cdev)
		{
		int gcnum;
		int status;

		gcnum = usb_gadget_controller_number(cdev->gadget);
		if (gcnum >= 0)
		device_desc.bcdDevice = cpu_to_le16(0x0300 \| gcnum);
		else {
		ERROR(cdev, "controller '%s' not recognized; trying %s\n",
		cdev->gadget->name,
		audio_config_driver.label);
		device_desc.bcdDevice =
		__constant_cpu_to_le16(0x0300 \| 0x0099);
		}

		/* device descriptor strings: manufacturer, product */
		snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
		init_utsname()->sysname, init_utsname()->release,
		cdev->gadget->name);
		status = usb_string_id(cdev);
		if (status < 0)
		goto fail;
		strings_dev[STRING_MANUFACTURER_IDX].id = status;
		device_desc.iManufacturer = status;

		status = usb_string_id(cdev);
		if (status < 0)
		goto fail;
		strings_dev[STRING_PRODUCT_IDX].id = status;
		device_desc.iProduct = status;

		status = usb_add_config(cdev, &audio_config_driver);
		if (status < 0)
		goto fail;

		INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION);
		return 0;

		fail:
		return status;
		}

		static int __exit audio_unbind(struct usb_composite_dev *cdev)
		{
		return 0;
		}

		static struct usb_composite_driver audio_driver = {
		.name = "g_audio",
		.dev = &device_desc,
		.strings = audio_strings,
		.bind = audio_bind,
		.unbind = __exit_p(audio_unbind),
		};

		static int __init init(void)
		{
		return usb_composite_register(&audio_driver);
		}
		module_init(init);

		static void __exit cleanup(void)
		{
		usb_composite_unregister(&audio_driver);
		}
		module_exit(cleanup);

		MODULE_DESCRIPTION(DRIVER_DESC);
		MODULE_AUTHOR("Bryan Wu <cooloney@kernel.org>");
		MODULE_LICENSE("GPL");

drivers/usb/gadget/f_audio.c

0 → 100644

+707 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/usb/gadget/u_audio.c

0 → 100644

+319 −0

Original line number	Diff line number	Diff line
		/*
		* u_audio.c -- ALSA audio utilities for Gadget stack
		*
		* Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
		* Copyright (C) 2008 Analog Devices, Inc
		*
		* Enter bugs at http://blackfin.uclinux.org/
		*
		* Licensed under the GPL-2 or later.
		*/

		#include <linux/kernel.h>
		#include <linux/utsname.h>
		#include <linux/device.h>
		#include <linux/delay.h>
		#include <linux/ctype.h>
		#include <linux/random.h>
		#include <linux/syscalls.h>

		#include "u_audio.h"

		/*
		* This component encapsulates the ALSA devices for USB audio gadget
		*/

		#define FILE_PCM_PLAYBACK "/dev/snd/pcmC0D0p"
		#define FILE_PCM_CAPTURE "/dev/snd/pcmC0D0c"
		#define FILE_CONTROL "/dev/snd/controlC0"

		static char *fn_play = FILE_PCM_PLAYBACK;
		module_param(fn_play, charp, S_IRUGO);
		MODULE_PARM_DESC(fn_play, "Playback PCM device file name");

		static char *fn_cap = FILE_PCM_CAPTURE;
		module_param(fn_cap, charp, S_IRUGO);
		MODULE_PARM_DESC(fn_cap, "Capture PCM device file name");

		static char *fn_cntl = FILE_CONTROL;
		module_param(fn_cntl, charp, S_IRUGO);
		MODULE_PARM_DESC(fn_cntl, "Control device file name");

		/-------------------------------------------------------------------------/

		/**
		* Some ALSA internal helper functions
		*/
		static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
		{
		struct snd_interval t;
		t.empty = 0;
		t.min = t.max = val;
		t.openmin = t.openmax = 0;
		t.integer = 1;
		return snd_interval_refine(i, &t);
		}

		static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
		snd_pcm_hw_param_t var, unsigned int val,
		int dir)
		{
		int changed;
		if (hw_is_mask(var)) {
		struct snd_mask *m = hw_param_mask(params, var);
		if (val == 0 && dir < 0) {
		changed = -EINVAL;
		snd_mask_none(m);
		} else {
		if (dir > 0)
		val++;
		else if (dir < 0)
		val--;
		changed = snd_mask_refine_set(
		hw_param_mask(params, var), val);
		}
		} else if (hw_is_interval(var)) {
		struct snd_interval *i = hw_param_interval(params, var);
		if (val == 0 && dir < 0) {
		changed = -EINVAL;
		snd_interval_none(i);
		} else if (dir == 0)
		changed = snd_interval_refine_set(i, val);
		else {
		struct snd_interval t;
		t.openmin = 1;
		t.openmax = 1;
		t.empty = 0;
		t.integer = 0;
		if (dir < 0) {
		t.min = val - 1;
		t.max = val;
		} else {
		t.min = val;
		t.max = val+1;
		}
		changed = snd_interval_refine(i, &t);
		}
		} else
		return -EINVAL;
		if (changed) {
		params->cmask \|= 1 << var;
		params->rmask \|= 1 << var;
		}
		return changed;
		}
		/-------------------------------------------------------------------------/

		/**
		* Set default hardware params
		*/
		static int playback_default_hw_params(struct gaudio_snd_dev *snd)
		{
		struct snd_pcm_substream *substream = snd->substream;
		struct snd_pcm_hw_params *params;
		snd_pcm_sframes_t result;

		/*
		* SNDRV_PCM_ACCESS_RW_INTERLEAVED,
		* SNDRV_PCM_FORMAT_S16_LE
		* CHANNELS: 2
		* RATE: 48000
		*/
		snd->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
		snd->format = SNDRV_PCM_FORMAT_S16_LE;
		snd->channels = 2;
		snd->rate = 48000;

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

		_snd_pcm_hw_params_any(params);
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
		snd->access, 0);
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
		snd->format, 0);
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
		snd->channels, 0);
		_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
		snd->rate, 0);

		snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
		snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, params);

		result = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
		if (result < 0) {
		ERROR(snd->card,
		"Preparing sound card failed: %d\n", (int)result);
		kfree(params);
		return result;
		}

		/* Store the hardware parameters */
		snd->access = params_access(params);
		snd->format = params_format(params);
		snd->channels = params_channels(params);
		snd->rate = params_rate(params);

		kfree(params);

		INFO(snd->card,
		"Hardware params: access %x, format %x, channels %d, rate %d\n",
		snd->access, snd->format, snd->channels, snd->rate);

		return 0;
		}

		/**
		* Playback audio buffer data by ALSA PCM device
		*/
		static size_t u_audio_playback(struct gaudio card, void buf, size_t count)
		{
		struct gaudio_snd_dev *snd = &card->playback;
		struct snd_pcm_substream *substream = snd->substream;
		struct snd_pcm_runtime *runtime = substream->runtime;
		mm_segment_t old_fs;
		ssize_t result;
		snd_pcm_sframes_t frames;

		try_again:
		if (runtime->status->state == SNDRV_PCM_STATE_XRUN \|\|
		runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
		result = snd_pcm_kernel_ioctl(substream,
		SNDRV_PCM_IOCTL_PREPARE, NULL);
		if (result < 0) {
		ERROR(card, "Preparing sound card failed: %d\n",
		(int)result);
		return result;
		}
		}

		frames = bytes_to_frames(runtime, count);
		old_fs = get_fs();
		set_fs(KERNEL_DS);
		result = snd_pcm_lib_write(snd->substream, buf, frames);
		if (result != frames) {
		ERROR(card, "Playback error: %d\n", (int)result);
		set_fs(old_fs);
		goto try_again;
		}
		set_fs(old_fs);

		return 0;
		}

		static int u_audio_get_playback_channels(struct gaudio *card)
		{
		return card->playback.channels;
		}

		static int u_audio_get_playback_rate(struct gaudio *card)
		{
		return card->playback.rate;
		}

		/**
		* Open ALSA PCM and control device files
		* Initial the PCM or control device
		*/
		static int gaudio_open_snd_dev(struct gaudio *card)
		{
		struct snd_pcm_file *pcm_file;
		struct gaudio_snd_dev *snd;

		if (!card)
		return -ENODEV;

		/* Open control device */
		snd = &card->control;
		snd->filp = filp_open(fn_cntl, O_RDWR, 0);
		if (IS_ERR(snd->filp)) {
		int ret = PTR_ERR(snd->filp);
		ERROR(card, "unable to open sound control device file: %s\n",
		fn_cntl);
		snd->filp = NULL;
		return ret;
		}
		snd->card = card;

		/* Open PCM playback device and setup substream */
		snd = &card->playback;
		snd->filp = filp_open(fn_play, O_WRONLY, 0);
		if (IS_ERR(snd->filp)) {
		ERROR(card, "No such PCM playback device: %s\n", fn_play);
		snd->filp = NULL;
		}
		pcm_file = snd->filp->private_data;
		snd->substream = pcm_file->substream;
		snd->card = card;
		playback_default_hw_params(snd);

		/* Open PCM capture device and setup substream */
		snd = &card->capture;
		snd->filp = filp_open(fn_cap, O_RDONLY, 0);
		if (IS_ERR(snd->filp)) {
		ERROR(card, "No such PCM capture device: %s\n", fn_cap);
		snd->filp = NULL;
		}
		pcm_file = snd->filp->private_data;
		snd->substream = pcm_file->substream;
		snd->card = card;

		return 0;
		}

		/**
		* Close ALSA PCM and control device files
		*/
		static int gaudio_close_snd_dev(struct gaudio *gau)
		{
		struct gaudio_snd_dev *snd;

		/* Close control device */
		snd = &gau->control;
		if (!IS_ERR(snd->filp))
		filp_close(snd->filp, current->files);

		/* Close PCM playback device and setup substream */
		snd = &gau->playback;
		if (!IS_ERR(snd->filp))
		filp_close(snd->filp, current->files);

		/* Close PCM capture device and setup substream */
		snd = &gau->capture;
		if (!IS_ERR(snd->filp))
		filp_close(snd->filp, current->files);

		return 0;
		}

		/**
		* gaudio_setup - setup ALSA interface and preparing for USB transfer
		*
		* This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using.
		*
		* Returns negative errno, or zero on success
		*/
		int __init gaudio_setup(struct gaudio *card)
		{
		int ret;

		ret = gaudio_open_snd_dev(card);
		if (ret)
		ERROR(card, "we need at least one control device\n");

		return ret;

		}

		/**
		* gaudio_cleanup - remove ALSA device interface
		*
		* This is called to free all resources allocated by @gaudio_setup().
		*/
		void gaudio_cleanup(struct gaudio *card)
		{
		if (card)
		gaudio_close_snd_dev(card);
		}