/* * 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, 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->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; } }