1/* 2 * u_uac1.c -- ALSA audio utilities for Gadget stack 3 * 4 * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org> 5 * Copyright (C) 2008 Analog Devices, Inc 6 * 7 * Enter bugs at http://blackfin.uclinux.org/ 8 * 9 * Licensed under the GPL-2 or later. 10 */ 11 12#include <linux/kernel.h> 13#include <linux/module.h> 14#include <linux/slab.h> 15#include <linux/device.h> 16#include <linux/delay.h> 17#include <linux/ctype.h> 18#include <linux/random.h> 19#include <linux/syscalls.h> 20 21#include "u_uac1.h" 22 23/* 24 * This component encapsulates the ALSA devices for USB audio gadget 25 */ 26 27/*-------------------------------------------------------------------------*/ 28 29/** 30 * Some ALSA internal helper functions 31 */ 32static int snd_interval_refine_set(struct snd_interval *i, unsigned int val) 33{ 34 struct snd_interval t; 35 t.empty = 0; 36 t.min = t.max = val; 37 t.openmin = t.openmax = 0; 38 t.integer = 1; 39 return snd_interval_refine(i, &t); 40} 41 42static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params, 43 snd_pcm_hw_param_t var, unsigned int val, 44 int dir) 45{ 46 int changed; 47 if (hw_is_mask(var)) { 48 struct snd_mask *m = hw_param_mask(params, var); 49 if (val == 0 && dir < 0) { 50 changed = -EINVAL; 51 snd_mask_none(m); 52 } else { 53 if (dir > 0) 54 val++; 55 else if (dir < 0) 56 val--; 57 changed = snd_mask_refine_set( 58 hw_param_mask(params, var), val); 59 } 60 } else if (hw_is_interval(var)) { 61 struct snd_interval *i = hw_param_interval(params, var); 62 if (val == 0 && dir < 0) { 63 changed = -EINVAL; 64 snd_interval_none(i); 65 } else if (dir == 0) 66 changed = snd_interval_refine_set(i, val); 67 else { 68 struct snd_interval t; 69 t.openmin = 1; 70 t.openmax = 1; 71 t.empty = 0; 72 t.integer = 0; 73 if (dir < 0) { 74 t.min = val - 1; 75 t.max = val; 76 } else { 77 t.min = val; 78 t.max = val+1; 79 } 80 changed = snd_interval_refine(i, &t); 81 } 82 } else 83 return -EINVAL; 84 if (changed) { 85 params->cmask |= 1 << var; 86 params->rmask |= 1 << var; 87 } 88 return changed; 89} 90/*-------------------------------------------------------------------------*/ 91 92/** 93 * Set default hardware params 94 */ 95static int playback_default_hw_params(struct gaudio_snd_dev *snd) 96{ 97 struct snd_pcm_substream *substream = snd->substream; 98 struct snd_pcm_hw_params *params; 99 snd_pcm_sframes_t result; 100 101 /* 102 * SNDRV_PCM_ACCESS_RW_INTERLEAVED, 103 * SNDRV_PCM_FORMAT_S16_LE 104 * CHANNELS: 2 105 * RATE: 48000 106 */ 107 snd->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED; 108 snd->format = SNDRV_PCM_FORMAT_S16_LE; 109 snd->channels = 2; 110 snd->rate = 48000; 111 112 params = kzalloc(sizeof(*params), GFP_KERNEL); 113 if (!params) 114 return -ENOMEM; 115 116 _snd_pcm_hw_params_any(params); 117 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS, 118 snd->access, 0); 119 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT, 120 snd->format, 0); 121 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS, 122 snd->channels, 0); 123 _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE, 124 snd->rate, 0); 125 126 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL); 127 snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, params); 128 129 result = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL); 130 if (result < 0) { 131 ERROR(snd->card, 132 "Preparing sound card failed: %d\n", (int)result); 133 kfree(params); 134 return result; 135 } 136 137 /* Store the hardware parameters */ 138 snd->access = params_access(params); 139 snd->format = params_format(params); 140 snd->channels = params_channels(params); 141 snd->rate = params_rate(params); 142 143 kfree(params); 144 145 INFO(snd->card, 146 "Hardware params: access %x, format %x, channels %d, rate %d\n", 147 snd->access, snd->format, snd->channels, snd->rate); 148 149 return 0; 150} 151 152/** 153 * Playback audio buffer data by ALSA PCM device 154 */ 155size_t u_audio_playback(struct gaudio *card, void *buf, size_t count) 156{ 157 struct gaudio_snd_dev *snd = &card->playback; 158 struct snd_pcm_substream *substream = snd->substream; 159 struct snd_pcm_runtime *runtime = substream->runtime; 160 mm_segment_t old_fs; 161 ssize_t result; 162 snd_pcm_sframes_t frames; 163 164try_again: 165 if (runtime->status->state == SNDRV_PCM_STATE_XRUN || 166 runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) { 167 result = snd_pcm_kernel_ioctl(substream, 168 SNDRV_PCM_IOCTL_PREPARE, NULL); 169 if (result < 0) { 170 ERROR(card, "Preparing sound card failed: %d\n", 171 (int)result); 172 return result; 173 } 174 } 175 176 frames = bytes_to_frames(runtime, count); 177 old_fs = get_fs(); 178 set_fs(KERNEL_DS); 179 result = snd_pcm_lib_write(snd->substream, (void __user *)buf, frames); 180 if (result != frames) { 181 ERROR(card, "Playback error: %d\n", (int)result); 182 set_fs(old_fs); 183 goto try_again; 184 } 185 set_fs(old_fs); 186 187 return 0; 188} 189 190int u_audio_get_playback_channels(struct gaudio *card) 191{ 192 return card->playback.channels; 193} 194 195int u_audio_get_playback_rate(struct gaudio *card) 196{ 197 return card->playback.rate; 198} 199 200/** 201 * Open ALSA PCM and control device files 202 * Initial the PCM or control device 203 */ 204static int gaudio_open_snd_dev(struct gaudio *card) 205{ 206 struct snd_pcm_file *pcm_file; 207 struct gaudio_snd_dev *snd; 208 struct f_uac1_opts *opts; 209 char *fn_play, *fn_cap, *fn_cntl; 210 211 opts = container_of(card->func.fi, struct f_uac1_opts, func_inst); 212 fn_play = opts->fn_play; 213 fn_cap = opts->fn_cap; 214 fn_cntl = opts->fn_cntl; 215 216 if (!card) 217 return -ENODEV; 218 219 /* Open control device */ 220 snd = &card->control; 221 snd->filp = filp_open(fn_cntl, O_RDWR, 0); 222 if (IS_ERR(snd->filp)) { 223 int ret = PTR_ERR(snd->filp); 224 ERROR(card, "unable to open sound control device file: %s\n", 225 fn_cntl); 226 snd->filp = NULL; 227 return ret; 228 } 229 snd->card = card; 230 231 /* Open PCM playback device and setup substream */ 232 snd = &card->playback; 233 snd->filp = filp_open(fn_play, O_WRONLY, 0); 234 if (IS_ERR(snd->filp)) { 235 int ret = PTR_ERR(snd->filp); 236 237 ERROR(card, "No such PCM playback device: %s\n", fn_play); 238 snd->filp = NULL; 239 return ret; 240 } 241 pcm_file = snd->filp->private_data; 242 snd->substream = pcm_file->substream; 243 snd->card = card; 244 playback_default_hw_params(snd); 245 246 /* Open PCM capture device and setup substream */ 247 snd = &card->capture; 248 snd->filp = filp_open(fn_cap, O_RDONLY, 0); 249 if (IS_ERR(snd->filp)) { 250 ERROR(card, "No such PCM capture device: %s\n", fn_cap); 251 snd->substream = NULL; 252 snd->card = NULL; 253 snd->filp = NULL; 254 } else { 255 pcm_file = snd->filp->private_data; 256 snd->substream = pcm_file->substream; 257 snd->card = card; 258 } 259 260 return 0; 261} 262 263/** 264 * Close ALSA PCM and control device files 265 */ 266static int gaudio_close_snd_dev(struct gaudio *gau) 267{ 268 struct gaudio_snd_dev *snd; 269 270 /* Close control device */ 271 snd = &gau->control; 272 if (snd->filp) 273 filp_close(snd->filp, NULL); 274 275 /* Close PCM playback device and setup substream */ 276 snd = &gau->playback; 277 if (snd->filp) 278 filp_close(snd->filp, NULL); 279 280 /* Close PCM capture device and setup substream */ 281 snd = &gau->capture; 282 if (snd->filp) 283 filp_close(snd->filp, NULL); 284 285 return 0; 286} 287 288/** 289 * gaudio_setup - setup ALSA interface and preparing for USB transfer 290 * 291 * This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using. 292 * 293 * Returns negative errno, or zero on success 294 */ 295int gaudio_setup(struct gaudio *card) 296{ 297 int ret; 298 299 ret = gaudio_open_snd_dev(card); 300 if (ret) 301 ERROR(card, "we need at least one control device\n"); 302 303 return ret; 304 305} 306 307/** 308 * gaudio_cleanup - remove ALSA device interface 309 * 310 * This is called to free all resources allocated by @gaudio_setup(). 311 */ 312void gaudio_cleanup(struct gaudio *the_card) 313{ 314 if (the_card) { 315 gaudio_close_snd_dev(the_card); 316 } 317} 318 319