alsa声卡分析alsa-utils调用过程（一）-tinyplay

如何分析tinyplay 播放音频和tinymix的过程？需要相应的工具来支持追查；

一、分析tinyplay和tinymix：

1.1 利用strace工具：

strace -o tinyplay.log tinyplay 1.wav

strace -o tinymixer.log tinymixer "SEC_MI2S_RX Audio Mixer MultiMedia1" 1

利用strace工具获取APP的log，从应用层往下看；

1.2 分析alsa-utils源码：

tiny工具源码在android/external/tinyalsa目录下；

二、tinyplay调用分析（tinyplay.log搜索设备节点“/dev/snd/pcmC0D0p”）

2.1 tinyplay的open过程：

snd_pcm_f_ops[0]是播放音频的file_operations，snd_pcm_f_ops[1]则是录音的file_operations：

 const struct file_operations snd_pcm_f_ops[] = {
     {
         .owner =        THIS_MODULE,
         .write =        snd_pcm_write,
         .aio_write =        snd_pcm_aio_write,
         .open =            snd_pcm_playback_open,
         .release =        snd_pcm_release,
         .llseek =        no_llseek,
         .poll =            snd_pcm_playback_poll,
         .unlocked_ioctl =    snd_pcm_playback_ioctl,
         .compat_ioctl =     snd_pcm_ioctl_compat,
         .mmap =            snd_pcm_mmap,
         .fasync =        snd_pcm_fasync,
         .get_unmapped_area =    snd_pcm_get_unmapped_area,
     },
     {
         .owner =        THIS_MODULE,
         .read =            snd_pcm_read,
         .aio_read =        snd_pcm_aio_read,
         .open =            snd_pcm_capture_open,
         .release =        snd_pcm_release,
         .llseek =        no_llseek,
         .poll =            snd_pcm_capture_poll,
         .unlocked_ioctl =    snd_pcm_capture_ioctl,
         .compat_ioctl =     snd_pcm_ioctl_compat,
         .mmap =            snd_pcm_mmap,
         .fasync =        snd_pcm_fasync,
         .get_unmapped_area =    snd_pcm_get_unmapped_area,
     }
 };

我们从snd_pcm_playback_open函数开始向下分析：

 static int snd_pcm_playback_open(struct inode *inode, struct file *file)
 {
     struct snd_pcm *pcm;
     int err = nonseekable_open(inode, file);
     if (err < )
         return err;
     pcm = snd_lookup_minor_data(iminor(inode),
                     SNDRV_DEVICE_TYPE_PCM_PLAYBACK);　　//取得其私有数据并返回的
     err = snd_pcm_open(file, pcm, SNDRV_PCM_STREAM_PLAYBACK);
     if (pcm)
         snd_card_unref(pcm->card);　　　　　　//减少设备对象的引用计数 snd_card_unref(card);
     return err;
 }

在下面调用了snd_pcm_open函数：

 static int snd_pcm_open(struct file *file, struct snd_pcm *pcm, int stream)
 {
     int err;
     wait_queue_t wait;

     if (pcm == NULL) {
         err = -ENODEV;
         goto __error1;
     }
     err = snd_card_file_add(pcm->card, file);
     if (err < )
         goto __error1;
     if (!try_module_get(pcm->card->module)) {
         err = -EFAULT;
         goto __error2;
     }
     init_waitqueue_entry(&wait, current);
     add_wait_queue(&pcm->open_wait, &wait);
     mutex_lock(&pcm->open_mutex);
     while () {
         err = snd_pcm_open_file(file, pcm, stream);　　// 将操作该声卡card的应用程序添加到card->files_list
         if (err >= )
             break;
         if (err == -EAGAIN) {
             if (file->f_flags & O_NONBLOCK) {
                 err = -EBUSY;
                 break;
             }
         } else
             break;
         set_current_state(TASK_INTERRUPTIBLE);
         mutex_unlock(&pcm->open_mutex);
         schedule();
         mutex_lock(&pcm->open_mutex);
         if (pcm->card->shutdown) {
             err = -ENODEV;
             break;
         }
         if (signal_pending(current)) {
             err = -ERESTARTSYS;
             break;
         }
     }
     remove_wait_queue(&pcm->open_wait, &wait);
     mutex_unlock(&pcm->open_mutex);
     if (err < )
         goto __error;
     return err;

       __error:
     module_put(pcm->card->module);
       __error2:
           snd_card_file_remove(pcm->card, file);
       __error1:
           return err;
 }

再从snd_pcm_open_file继续向下看：

 static int snd_pcm_open_file(struct file *file,
                  struct snd_pcm *pcm,
                  int stream)
 {
     struct snd_pcm_file *pcm_file;
     struct snd_pcm_substream *substream;
     int err;

     err = snd_pcm_open_substream(pcm, stream, file, &substream);　　　　//打开substream结构体
     if (err < )
         return err;

     pcm_file = kzalloc(sizeof(*pcm_file), GFP_KERNEL);
     if (pcm_file == NULL) {
         snd_pcm_release_substream(substream);
         return -ENOMEM;
     }
     pcm_file->substream = substream;
     if (substream->ref_count == ) {
         substream->file = pcm_file;
         substream->pcm_release = pcm_release_private;
     }
     file->private_data = pcm_file;

     return ;
 }

 int snd_pcm_open_substream(struct snd_pcm *pcm, int stream,
                struct file *file,
                struct snd_pcm_substream **rsubstream)
 {
     struct snd_pcm_substream *substream;
     int err;

     err = snd_pcm_attach_substream(pcm, stream, file, &substream);
     if (err < )
         return err;
     if (substream->ref_count > ) {
         *rsubstream = substream;
         return ;
     }

     err = snd_pcm_hw_constraints_init(substream);    //初始化substream结构体
     if (err < ) {
         snd_printd("snd_pcm_hw_constraints_init failed\n");
         goto error;
     }

     if ((err = substream->ops->open(substream)) < )
         goto error;

     substream->hw_opened = ;

     err = snd_pcm_hw_constraints_complete(substream);
     if (err < ) {
         snd_printd("snd_pcm_hw_constraints_complete failed\n");
         goto error;
     }

     *rsubstream = substream;
     return ;

  error:
     snd_pcm_release_substream(substream);
     return err;
 }

snd_pcm_open_substream

在snd_pcm_open_substream函数中：

     if ((err = substream->ops->open(substream)) < )　　　　// substream->ops : snd_pcm_ops结构体
         goto error;

依次调用cpu_dai, dma, codec_dai, machine（三大模块）的open或startup函数；

msm_mi2s_snd_startup函数：

 struct snd_soc_pcm_runtime *rtd = substream->private_data;
 struct snd_soc_card *card = rtd->card;
 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 struct snd_soc_codec *codec = rtd->codec;

设置snd_soc_pcm_runtime的cpu、codec等模块；然后在snd_soc_pcm_runtime函数中对codec函数进行相应的设置，之后通过音频数据流通道播放出声音；

调用过程如下图：

2.2 tinyplay的ioctl过程：

同样也是snd_pcm_f_ops[0]结构体的file_operations：

 {
         .owner =        THIS_MODULE,
         .write =        snd_pcm_write,
         .aio_write =        snd_pcm_aio_write,
         .open =            snd_pcm_playback_open,
         .release =        snd_pcm_release,
         .llseek =        no_llseek,
         .poll =            snd_pcm_playback_poll,
         .unlocked_ioctl =    snd_pcm_playback_ioctl,
         .compat_ioctl =     snd_pcm_ioctl_compat,
         .mmap =            snd_pcm_mmap,
         .fasync =        snd_pcm_fasync,
         .get_unmapped_area =    snd_pcm_get_unmapped_area,
 },

从snd_pcm_playback_ioctl函数向下看：

 static long snd_pcm_playback_ioctl(struct file *file, unsigned int cmd,
                    unsigned long arg)
 {
     struct snd_pcm_file *pcm_file;

     pcm_file = file->private_data;　　　　//获取相应的私有数据

     if ((((cmd >> ) & 0xff) != 'A') && (((cmd >> ) & 0xff) != 'C'))
         return -ENOTTY;

     return snd_pcm_playback_ioctl1(file, pcm_file->substream, cmd,
                        (void __user *)arg);
 }

snd_pcm_playback_ioctl1：

 static int snd_pcm_playback_ioctl1(struct file *file,
                    struct snd_pcm_substream *substream,
                    unsigned int cmd, void __user *arg)
 {
     if (snd_BUG_ON(!substream))
         return -ENXIO;
     if (snd_BUG_ON(substream->stream != SNDRV_PCM_STREAM_PLAYBACK))
         return -EINVAL;
         //根据case不同，对播放进行相应的不同操作
     switch (cmd) {
     case SNDRV_PCM_IOCTL_WRITEI_FRAMES:
     {
         struct snd_xferi xferi;
         struct snd_xferi __user *_xferi = arg;
         struct snd_pcm_runtime *runtime = substream->runtime;
         snd_pcm_sframes_t result;
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
             return -EBADFD;
         if (put_user(, &_xferi->result))
             return -EFAULT;
         if (copy_from_user(&xferi, _xferi, sizeof(xferi)))
             return -EFAULT;
         result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames);
         __put_user(result, &_xferi->result);
         return result <  ? result : ;
     }
     case SNDRV_PCM_IOCTL_WRITEN_FRAMES:
     {
         struct snd_xfern xfern;
         struct snd_xfern __user *_xfern = arg;
         struct snd_pcm_runtime *runtime = substream->runtime;
         void __user **bufs;
         snd_pcm_sframes_t result;
         if (runtime->status->state == SNDRV_PCM_STATE_OPEN)
             return -EBADFD;
         if (runtime->channels > )
             return -EINVAL;
         if (put_user(, &_xfern->result))
             return -EFAULT;
         if (copy_from_user(&xfern, _xfern, sizeof(xfern)))
             return -EFAULT;

         bufs = memdup_user(xfern.bufs,
                    sizeof(void *) * runtime->channels);
         if (IS_ERR(bufs))
             return PTR_ERR(bufs);
         result = snd_pcm_lib_writev(substream, bufs, xfern.frames);
         kfree(bufs);
         __put_user(result, &_xfern->result);
         return result <  ? result : ;
     }
     case SNDRV_PCM_IOCTL_REWIND:
     {
         snd_pcm_uframes_t frames;
         snd_pcm_uframes_t __user *_frames = arg;
         snd_pcm_sframes_t result;
         if (get_user(frames, _frames))
             return -EFAULT;
         if (put_user(, _frames))
             return -EFAULT;
         result = snd_pcm_playback_rewind(substream, frames);
         __put_user(result, _frames);
         return result <  ? result : ;
     }
     case SNDRV_PCM_IOCTL_FORWARD:
     {
         snd_pcm_uframes_t frames;
         snd_pcm_uframes_t __user *_frames = arg;
         snd_pcm_sframes_t result;
         if (get_user(frames, _frames))
             return -EFAULT;
         if (put_user(, _frames))
             return -EFAULT;
         result = snd_pcm_playback_forward(substream, frames);
         __put_user(result, _frames);
         return result <  ? result : ;
     }
     }
     return snd_pcm_common_ioctl1(file, substream, cmd, arg);
 }

从snd_pcm_common_ioctl1继续分析，进入函数的prepare中：

当函数prepare完毕后，就一切准备就绪了，只等一个trigger；而trigger的执行会在上层的alsalib调用write的函数触发；prepare过程可以看下图，具体就不继续分析了：

下一节我们将来分析tinymixer的调用过程；

alsa声卡分析alsa-utils调用过程（二）-tinymixer