drivers/usb/gadget/u_audio.c

   1 /*
   2  * u_audio.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/slab.h>
  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
  20 #include "u_audio.h"
  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);
 256                 snd->substream = NULL;
 257                 snd->card = NULL;
 258                 snd->filp = NULL;
 259         } else {
 260                 pcm_file = snd->filp->private_data;
 261                 snd->substream = pcm_file->substream;
 262                 snd->card = card;
 263         }
 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;
 277         if (snd->filp)
 278                 filp_close(snd->filp, current->files);
 279
 280         /* Close PCM playback device and setup substream */
 281         snd = &gau->playback;
 282         if (snd->filp)
 283                 filp_close(snd->filp, current->files);
 284
 285         /* Close PCM capture device and setup substream */
 286         snd = &gau->capture;
 287         if (snd->filp)
 288                 filp_close(snd->filp, current->files);
 289
 290         return 0;
 291 }
 292
 293 static struct gaudio *the_card;
 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");
 308         else if (!the_card)
 309                 the_card = card;
 310
 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  */
 320 void gaudio_cleanup(void)
 321 {
 322         if (the_card) {
 323                 gaudio_close_snd_dev(the_card);
 324                 the_card = NULL;
 325         }
 326 }
 327