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