Quelle  u_uac1_legacy.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * u_uac1.c -- ALSA audio utilities for Gadget stack
 *
 * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
 * Copyright (C) 2008 Analog Devices, Inc
 */

#include <linux/kernel.h>
#include <linux/module.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_legacy.h"

/*
 * This component encapsulates the ALSA devices for USB audio gadget
 */

/*-------------------------------------------------------------------------*/

/*
 * 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
 */
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;
 ssize_t result;
 snd_pcm_sframes_t frames;

try_again:
 if (runtime->state == SNDRV_PCM_STATE_XRUN ||
  runtime->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);
 result = snd_pcm_kernel_write(snd->substream, buf, frames);
 if (result != frames) {
  ERROR(card, "Playback error: %d\n", (int)result);
  goto try_again;
 }

 return 0;
}

int u_audio_get_playback_channels(struct gaudio *card)
{
 return card->playback.channels;
}

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;
 struct f_uac1_legacy_opts *opts;
 char *fn_play, *fn_cap, *fn_cntl;

 opts = container_of(card->func.fi, struct f_uac1_legacy_opts,
       func_inst);
 fn_play = opts->fn_play;
 fn_cap = opts->fn_cap;
 fn_cntl = opts->fn_cntl;

 /* 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)) {
  int ret = PTR_ERR(snd->filp);

  ERROR(card, "No such PCM playback device: %s\n", fn_play);
  snd->filp = NULL;
  return ret;
 }
 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;
}

/*
 * 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 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");

 return ret;

}

/*
 * gaudio_cleanup - remove ALSA device interface
 *
 * This is called to free all resources allocated by @gaudio_setup().
 */
void gaudio_cleanup(struct gaudio *the_card)
{
 if (the_card)
  gaudio_close_snd_dev(the_card);
}