drivers/usb/gadget/u_uac1.c - arm/linux-arm-legacy - Git at Google

 /*
  * u_uac1.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/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/ctype.h>
 #include <linux/random.h>
 #include <linux/syscalls.h>

 #include "u_uac1.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, (void __user *)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)) {
 		int ret = PTR_ERR(snd->filp);

 		ERROR(card, "No such PCM playback device: %s\n", fn_play);
 		snd->filp = NULL;
 		return ret;
 	}
 	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->substream = NULL;
 		snd->card = NULL;
 		snd->filp = NULL;
 	} else {
 		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 (snd->filp)
 		filp_close(snd->filp, NULL);

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

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

 	return 0;
 }

 static struct gaudio *the_card;
 /**
  * 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");
 	else if (!the_card)
 		the_card = card;

 	return ret;

 }

 /**
  * gaudio_cleanup - remove ALSA device interface
  *
  * This is called to free all resources allocated by @gaudio_setup().
  */
 void gaudio_cleanup(void)
 {
 	if (the_card) {
 		gaudio_close_snd_dev(the_card);
 		the_card = NULL;
 	}
 }
	/*
	* u_uac1.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/slab.h>
	#include <linux/device.h>
	#include <linux/delay.h>
	#include <linux/ctype.h>
	#include <linux/random.h>
	#include <linux/syscalls.h>

	#include "u_uac1.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, (void __user *)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)) {
	int ret = PTR_ERR(snd->filp);

	ERROR(card, "No such PCM playback device: %s\n", fn_play);
	snd->filp = NULL;
	return ret;
	}
	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->substream = NULL;
	snd->card = NULL;
	snd->filp = NULL;
	} else {
	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 (snd->filp)
	filp_close(snd->filp, NULL);

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

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

	return 0;
	}

	static struct gaudio *the_card;
	/**
	* 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");
	else if (!the_card)
	the_card = card;

	return ret;

	}

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