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_legacy.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 */ 32 static 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 42 static 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 */ 95 static 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 */ 155 size_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 ssize_t result; 161 snd_pcm_sframes_t frames; 162 163 try_again: 164 if (runtime->status->state == SNDRV_PCM_STATE_XRUN || 165 runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) { 166 result = snd_pcm_kernel_ioctl(substream, 167 SNDRV_PCM_IOCTL_PREPARE, NULL); 168 if (result < 0) { 169 ERROR(card, "Preparing sound card failed: %d\n", 170 (int)result); 171 return result; 172 } 173 } 174 175 frames = bytes_to_frames(runtime, count); 176 result = snd_pcm_kernel_write(snd->substream, buf, frames); 177 if (result != frames) { 178 ERROR(card, "Playback error: %d\n", (int)result); 179 goto try_again; 180 } 181 182 return 0; 183 } 184 185 int u_audio_get_playback_channels(struct gaudio *card) 186 { 187 return card->playback.channels; 188 } 189 190 int u_audio_get_playback_rate(struct gaudio *card) 191 { 192 return card->playback.rate; 193 } 194 195 /** 196 * Open ALSA PCM and control device files 197 * Initial the PCM or control device 198 */ 199 static int gaudio_open_snd_dev(struct gaudio *card) 200 { 201 struct snd_pcm_file *pcm_file; 202 struct gaudio_snd_dev *snd; 203 struct f_uac1_legacy_opts *opts; 204 char *fn_play, *fn_cap, *fn_cntl; 205 206 opts = container_of(card->func.fi, struct f_uac1_legacy_opts, 207 func_inst); 208 fn_play = opts->fn_play; 209 fn_cap = opts->fn_cap; 210 fn_cntl = opts->fn_cntl; 211 212 /* Open control device */ 213 snd = &card->control; 214 snd->filp = filp_open(fn_cntl, O_RDWR, 0); 215 if (IS_ERR(snd->filp)) { 216 int ret = PTR_ERR(snd->filp); 217 ERROR(card, "unable to open sound control device file: %s\n", 218 fn_cntl); 219 snd->filp = NULL; 220 return ret; 221 } 222 snd->card = card; 223 224 /* Open PCM playback device and setup substream */ 225 snd = &card->playback; 226 snd->filp = filp_open(fn_play, O_WRONLY, 0); 227 if (IS_ERR(snd->filp)) { 228 int ret = PTR_ERR(snd->filp); 229 230 ERROR(card, "No such PCM playback device: %s\n", fn_play); 231 snd->filp = NULL; 232 return ret; 233 } 234 pcm_file = snd->filp->private_data; 235 snd->substream = pcm_file->substream; 236 snd->card = card; 237 playback_default_hw_params(snd); 238 239 /* Open PCM capture device and setup substream */ 240 snd = &card->capture; 241 snd->filp = filp_open(fn_cap, O_RDONLY, 0); 242 if (IS_ERR(snd->filp)) { 243 ERROR(card, "No such PCM capture device: %s\n", fn_cap); 244 snd->substream = NULL; 245 snd->card = NULL; 246 snd->filp = NULL; 247 } else { 248 pcm_file = snd->filp->private_data; 249 snd->substream = pcm_file->substream; 250 snd->card = card; 251 } 252 253 return 0; 254 } 255 256 /** 257 * Close ALSA PCM and control device files 258 */ 259 static int gaudio_close_snd_dev(struct gaudio *gau) 260 { 261 struct gaudio_snd_dev *snd; 262 263 /* Close control device */ 264 snd = &gau->control; 265 if (snd->filp) 266 filp_close(snd->filp, NULL); 267 268 /* Close PCM playback device and setup substream */ 269 snd = &gau->playback; 270 if (snd->filp) 271 filp_close(snd->filp, NULL); 272 273 /* Close PCM capture device and setup substream */ 274 snd = &gau->capture; 275 if (snd->filp) 276 filp_close(snd->filp, NULL); 277 278 return 0; 279 } 280 281 /** 282 * gaudio_setup - setup ALSA interface and preparing for USB transfer 283 * 284 * This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using. 285 * 286 * Returns negative errno, or zero on success 287 */ 288 int gaudio_setup(struct gaudio *card) 289 { 290 int ret; 291 292 ret = gaudio_open_snd_dev(card); 293 if (ret) 294 ERROR(card, "we need at least one control device\n"); 295 296 return ret; 297 298 } 299 300 /** 301 * gaudio_cleanup - remove ALSA device interface 302 * 303 * This is called to free all resources allocated by @gaudio_setup(). 304 */ 305 void gaudio_cleanup(struct gaudio *the_card) 306 { 307 if (the_card) 308 gaudio_close_snd_dev(the_card); 309 } 310 311