浅析打开/dev/dsp设备节点代码流程

浅析打开/dev/dsp设备节点代码流程

《浅析uda134x声卡驱动probe的精简步骤》
《浅析放音模式--向/dev/dsp设备write写入音频数据的代码流》
《浅析alsa声卡放音模式时s3c24xx处理器DMA中断如何建立和处理》

  设备节点/dev/dsp的主节点号为SOUND_MAJOR即14,该节点方法集为soundcore_fops,
对应的open方法实现为：
soundcore_open
==> __look_for_unit查找在alsa_pcm_oss_init()中使用snd_pcm_notify(&snd_pcm_oss_notify, 0)
    登记的当创建pcm节点时snd_pcm_notify通知回调结构体:snd_pcm_oss_notify,
    函数snd_pcm_oss_register_minor调用register_oss_dsp-->snd_register_oss_device
    登记snd_oss_minors[minor] = preg;同时preg->private_data = private_data;
    就是preg->private_data = pcm;以备下面的fops方法集snd_pcm_oss_f_reg在open,read,write等时使用
    函数register_sound_special_device-->sound_insert_unit插入的pcm,该pcm的fops为[luther.gliethttp]
    函数snd_pcm_oss_f_reg
==> file->f_op = new_fops;将查找到的pcm对应的fops,即:snd_pcm_oss_f_reg赋值给f_op
    作为应用程序操作/dev/dsp设备的默认fops方法集
==> file->f_op->open(inode,file);调用snd_pcm_oss_f_reg中的open方法snd_pcm_oss_open
==> snd_pcm_oss_open
// 在snd_soc_new_pcms==>soc_new_pcm中设置放音和录音流的ops为soc_pcm_ops
// /* ASoC PCM operations */
// static struct snd_pcm_ops soc_pcm_ops = {
//     .open        = soc_pcm_open,
//     .close        = soc_codec_close,
//     .hw_params    = soc_pcm_hw_params,
//     .hw_free    = soc_pcm_hw_free,
//     .prepare    = soc_pcm_prepare,
//     .trigger    = soc_pcm_trigger,
// };
// ==> snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback, capture, &pcm);
// ==> static struct snd_device_ops ops = {
//         .dev_free = snd_pcm_dev_free,
//         .dev_register =    snd_pcm_dev_register,  在snd_card_register==>snd_device_register_all中将调用snd_pcm_dev_register注册对应的pcm
//         .dev_disconnect = snd_pcm_dev_disconnect,
//     };
// 在snd_pcm_dev_register执行的最后将调用alsa_pcm_oss_init注册的snd_pcm_oss_notify回调结构体
// oss的snd_pcm_oss_register_minor处理函数将被调用
// 于是register_oss_dsp将调用,相应/dev/dsp节点或/dev/dsp1将被创建,同时操作该节点的
// 方法集snd_pcm_oss_f_reg将被登记.
static int snd_pcm_oss_open(struct inode *inode, struct file *file)
{
    int err;
    char task_name[32];
    struct snd_pcm *pcm;
    struct snd_pcm_oss_file *pcm_oss_file;
    struct snd_pcm_oss_setup setup[2];
    int nonblock;
    wait_queue_t wait;

    pcm = snd_lookup_oss_minor_data(iminor(inode),
                    SNDRV_OSS_DEVICE_TYPE_PCM); // 返回preg->private_data,也就是pcm[luther.gliethttp]
    if (pcm == NULL) {
        err = -ENODEV;
        goto __error1;
    }
    err = snd_card_file_add(pcm->card, file);// 将操作该声卡card的应用程序添加到card->files_list
                                             // 链表上list_add(&mfile->list, &card->files_list);
    if (err < 0)
        goto __error1;
    if (!try_module_get(pcm->card->module)) {
        err = -EFAULT;
        goto __error2;
    }
    if (snd_task_name(current, task_name, sizeof(task_name)) < 0) {
        err = -EFAULT;                       // 获取打开/dev/dsp节点的应用程序名称[luther.gliethttp]
        goto __error;                        // 比如我们测试程序a.out,那么这里task_name将等于"a.out"
    }
    memset(setup, 0, sizeof(setup));
    if (file->f_mode & FMODE_WRITE)          // 如果具有写模式,那么打开pcm的放音通道
        snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                       task_name, &setup[0]);
    if (file->f_mode & FMODE_READ)           // 如果具有读模式,那么打开pcm的录音通道
        snd_pcm_oss_look_for_setup(pcm, SNDRV_PCM_STREAM_CAPTURE,
                       task_name, &setup[1]);

    nonblock = !!(file->f_flags & O_NONBLOCK);
    if (!nonblock)
        nonblock = nonblock_open;

    init_waitqueue_entry(&wait, current);
    add_wait_queue(&pcm->open_wait, &wait);  // 该应用程序有可能在下面的while(1)中睡眠
    mutex_lock(&pcm->open_mutex);
    while (1) {
        err = snd_pcm_oss_open_file(file, pcm, &pcm_oss_file,
                        iminor(inode), setup);// 为该应用程序a.out进行尝试性打开/dev/dsp设备
        if (err >= 0)
            break;
        if (err == -EAGAIN) {
            if (nonblock) {
                err = -EBUSY;
                break;
            }
        } else
            break;
        set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&pcm->open_mutex);
        schedule();                         // 因为当前pcm设备,被其他程序使用中,所以这里pending该
        mutex_lock(&pcm->open_mutex);       // 再次尝试打开/dev/dsp的a.out应用程序[luther.gliethttp]
        if (signal_pending(current)) {
            err = -ERESTARTSYS;
            break;
        }
    }
    remove_wait_queue(&pcm->open_wait, &wait);
    mutex_unlock(&pcm->open_mutex);
    if (err < 0)
        goto __error;
    return err;

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

static int snd_pcm_oss_open_file(struct file *file,
                 struct snd_pcm *pcm,
                 struct snd_pcm_oss_file **rpcm_oss_file,
                 int minor,
                 struct snd_pcm_oss_setup *setup)
{
    int idx, err;
    struct snd_pcm_oss_file *pcm_oss_file;
    struct snd_pcm_substream *substream;
    fmode_t f_mode = file->f_mode;

    if (rpcm_oss_file)
        *rpcm_oss_file = NULL;

    pcm_oss_file = kzalloc(sizeof(*pcm_oss_file), GFP_KERNEL);
    if (pcm_oss_file == NULL)
        return -ENOMEM;

    if ((f_mode & (FMODE_WRITE|FMODE_READ)) == (FMODE_WRITE|FMODE_READ) &&
        (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX)) // 为半双工的话,那么强制选择放音模式
        f_mode = FMODE_WRITE;

    file->f_flags &= ~O_APPEND;
    for (idx = 0; idx < 2; idx++) {
        if (setup[idx].disable)                         // 第1次进来的话,setup[idx].disable等于0
            continue;
        if (! pcm->streams[idx].substream_count)        // 如果本card的该pcm没有对应的放音或录音流通道
            continue; /* no matching substream */
        if (idx == SNDRV_PCM_STREAM_PLAYBACK) {
            if (! (f_mode & FMODE_WRITE))               // 当前处理放音,但f_mode不做放音操作,那么continue.
                continue;
        } else {
            if (! (f_mode & FMODE_READ))                // 当前处理录音,但f_mode不做录音操作,那么continue.
                continue;
        }
        err = snd_pcm_open_substream(pcm, idx, file, &substream); // ok, 匹配, 尝试打开该stream流
        if (err < 0) {
            snd_pcm_oss_release_file(pcm_oss_file);
            return err;
        }

        pcm_oss_file->streams[idx] = substream;         // 本应用程序a.out持有的idx类型的stream流
        substream->file = pcm_oss_file;                 // 该stream流归本pcm_oss_file使用
        snd_pcm_oss_init_substream(substream, &setup[idx], minor);
        // 赋值setup[idx]到substream->oss.setup
        // 初始化runtime->oss默认数值
        // runtime->oss.params = 1;
        // runtime->oss.trigger = 1;
        // runtime->oss.rate = 8000;
        // runtime->oss.format = AFMT_U8;或runtime->oss.format = AFMT_S16_LE;或runtime->oss.format = AFMT_MU_LAW;
        // runtime->oss.channels = 1;
        // runtime->oss.subdivision = 0;
    }
    
    // pcm_oss_file->streams[idx] = substream;
    // 如果成功获取到stream流通道,那么pcm_oss_file->streams[2]中至少有1个非0
    if (!pcm_oss_file->streams[0] && !pcm_oss_file->streams[1]) {
        snd_pcm_oss_release_file(pcm_oss_file);
        return -EINVAL;
    }

    file->private_data = pcm_oss_file;                  // ok, 正常打开stream流通道,存入private_data
    if (rpcm_oss_file)                                  // 以备close,read和write中使用[luther.gliethttp]
        *rpcm_oss_file = pcm_oss_file;
    return 0;
}

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); // 尝试为打开/dev/dsp设备节点的本应用程序attach一个stream音频控制流逻辑[luther.gliethttp]
    if (err < 0)
        return err;
    if (substream->ref_count > 1) { // 只有当O_APPEND追加模式才会出现ref_count大于1的情况
        *rsubstream = substream;
        return 0;
    }
// O_APPEND或者非O_APPEND,执行到这里,表示ref_count等于1,是第1次打开该stream流通道[luther.gliethttp]
    err = snd_pcm_hw_constraints_init(substream); // 初始化runtime硬性约束条件
    if (err < 0) {
        snd_printd("snd_pcm_hw_constraints_init failed\n");
        goto error;
    }
// 在snd_soc_new_pcms==>soc_new_pcm中设置放音和录音流的ops为soc_pcm_ops
// /* ASoC PCM operations */
// static struct snd_pcm_ops soc_pcm_ops = {
//     .open        = soc_pcm_open,
//     .close        = soc_codec_close,
//     .hw_params    = soc_pcm_hw_params,
//     .hw_free    = soc_pcm_hw_free,
//     .prepare    = soc_pcm_prepare,
//     .trigger    = soc_pcm_trigger,
// };
    if ((err = substream->ops->open(substream)) < 0) // 执行soc_pcm_open,分析见后
        goto error;

    substream->hw_opened = 1;

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

    *rsubstream = substream;                         // 至此stream流初始化工作全部完成
    return 0;

 error:
    snd_pcm_release_substream(substream);
    return err;
}

int snd_pcm_attach_substream(struct snd_pcm *pcm, int stream,
                 struct file *file,
                 struct snd_pcm_substream **rsubstream)
{
    struct snd_pcm_str * pstr;
    struct snd_pcm_substream *substream;
    struct snd_pcm_runtime *runtime;
    struct snd_ctl_file *kctl;
    struct snd_card *card;
    int prefer_subdevice = -1;
    size_t size;

    if (snd_BUG_ON(!pcm || !rsubstream))
        return -ENXIO;
    *rsubstream = NULL;
    pstr = &pcm->streams[stream];
    if (pstr->substream == NULL || pstr->substream_count == 0)
        return -ENODEV;

    card = pcm->card;
    read_lock(&card->ctl_files_rwlock);
    list_for_each_entry(kctl, &card->ctl_files, list) {
        if (kctl->pid == current->pid) { // ctl_files控制文件中如果为本current->pid应用程序强制干预
                                         // 事先做了流通道优选,
            prefer_subdevice = kctl->prefer_pcm_subdevice; // 那么将kctl->prefer_pcm_subdevice
            if (prefer_subdevice != -1)  // 存入prefer_subdevice流通道优选变量[luther.gliethttp]
                break;                   // 应用程序在O_APPEND模式下,
                                         // prefer_subdevice将作为应用程序唯一可选可操作stream.
        }
    }
    read_unlock(&card->ctl_files_rwlock);

    switch (stream) {
    case SNDRV_PCM_STREAM_PLAYBACK:
        if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
// 如果为半双工,那么检查录音stream是否占用,如果录音正在使用,那么放音open操作将失败[luther.gliethttp]
            for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next) {
                if (SUBSTREAM_BUSY(substream)) // 检查ref_count引用计数是否大于0
                    return -EAGAIN;
            }
        }
        break;
    case SNDRV_PCM_STREAM_CAPTURE:
        if (pcm->info_flags & SNDRV_PCM_INFO_HALF_DUPLEX) {
// 如果为半双工,那么进查放音stream是否占用,如果放音正在使用,那么录音open操作将失败[luther.gliethttp]
            for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next) {
                if (SUBSTREAM_BUSY(substream)) // 检查ref_count引用计数是否大于0
                    return -EAGAIN;
            }
        }
        break;
    default:
        return -EINVAL;
    }

    if (file->f_flags & O_APPEND) { // 追加模式
        if (prefer_subdevice < 0) {
        // prefer_subdevice小于0,表示驱动这里可以任意选择一个符合条件的
            if (pstr->substream_count > 1) // 该pcm的stream子流只能等于1
                return -EINVAL; /* must be unique */
            substream = pstr->substream;
        } else {
        // prefer_subdevice非负,说明,驱动这里只能选择prefer_subdevice索引号对应的pcm流.
            for (substream = pstr->substream; substream;
                 substream = substream->next)
                if (substream->number == prefer_subdevice) // 等于prefer_subdevice
                    break;
        }
        if (! substream) // 没有在pcm下找到匹配条件的stream流
            return -ENODEV;
        if (! SUBSTREAM_BUSY(substream))// 匹配上的stream流必须非busy,即substream->ref_count等于0
            return -EBADFD;
        substream->ref_count++; // 增加引用计数,
        *rsubstream = substream;// 查找任务完成,return 0;返回
        return 0;
    }

    // 非O_APPEND追加模式, 如果prefer_subdevice优选stream没有找到,那么可以在pstr->substream链表上
    // 任意选择1个可用非busy的stream,作为此次操作的返回结果[luther.gliethttp].
    if (prefer_subdevice >= 0) {
        // prefer_subdevice非负,说明,驱动这里只能选择prefer_subdevice索引号对应的pcm流.
        for (substream = pstr->substream; substream; substream = substream->next)
            if (!SUBSTREAM_BUSY(substream) && substream->number == prefer_subdevice)
                goto __ok; // 如果找到匹配的stream,那么__ok,否则一个个的来,查找其他候选可用stream
    }
    // 如果prefer_subdevice非负,同时还执行到了这里,说明prefer_subdevice优选的stream没有找到,那么
    // 下面将遍历pstr->substream,查找所有stream选择第1个可用stream
    for (substream = pstr->substream; substream; substream = substream->next)
        if (!SUBSTREAM_BUSY(substream)) // 如果非busy,那么太好了
            break;
      __ok:
    if (substream == NULL)
        return -EAGAIN;

    runtime = kzalloc(sizeof(*runtime), GFP_KERNEL);      // 为该stream申请runtime运行空间
    if (runtime == NULL)
        return -ENOMEM;

    size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status));
    runtime->status = snd_malloc_pages(size, GFP_KERNEL); // 申请空间
    if (runtime->status == NULL) {
        kfree(runtime);
        return -ENOMEM;
    }
    memset((void*)runtime->status, 0, size);

    size = PAGE_ALIGN(sizeof(struct snd_pcm_mmap_control));
    runtime->control = snd_malloc_pages(size, GFP_KERNEL);// 申请空间
    if (runtime->control == NULL) {
        snd_free_pages((void*)runtime->status,
                   PAGE_ALIGN(sizeof(struct snd_pcm_mmap_status)));
        kfree(runtime);
        return -ENOMEM;
    }
    memset((void*)runtime->control, 0, size);

    init_waitqueue_head(&runtime->sleep);

    runtime->status->state = SNDRV_PCM_STATE_OPEN;

    substream->runtime = runtime;                        // 本stream对应的runtime运行空间
    substream->private_data = pcm->private_data;
    substream->ref_count = 1;                            // 本stream引用计数置1
    substream->f_flags = file->f_flags;
    pstr->substream_opened++;                            // 本pcm相应的放音或录音stream使用计数++
    *rsubstream = substream;                             // ok,在本pcm中成功打开一个stream,
    return 0;                                            // 并为其建立了runtime运行空间.
}

// 初始化runtime->oss默认数值
static void snd_pcm_oss_init_substream(struct snd_pcm_substream *substream,
                       struct snd_pcm_oss_setup *setup,
                       int minor)
{
    struct snd_pcm_runtime *runtime;

    substream->oss.oss = 1;
    substream->oss.setup = *setup;
    if (setup->nonblock)
        substream->f_flags |= O_NONBLOCK;
    else if (setup->block)
        substream->f_flags &= ~O_NONBLOCK;
    runtime = substream->runtime;
    runtime->oss.params = 1;
    runtime->oss.trigger = 1;
    runtime->oss.rate = 8000;
    mutex_init(&runtime->oss.params_lock);
    switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
    case SNDRV_MINOR_OSS_PCM_8:
        runtime->oss.format = AFMT_U8;
        break;
    case SNDRV_MINOR_OSS_PCM_16:
        runtime->oss.format = AFMT_S16_LE;
        break;
    default:
        runtime->oss.format = AFMT_MU_LAW;
    }
    runtime->oss.channels = 1;
    runtime->oss.fragshift = 0;
    runtime->oss.maxfrags = 0;
    runtime->oss.subdivision = 0;
    substream->pcm_release = snd_pcm_oss_release_substream;
}

soc_pcm_open  // 将初始化runtime->hw所有硬件匹配数据
==> platform->pcm_ops->open
对于s3c24xx平台来说就是
s3c24xx_soc_platform
==> s3c24xx_pcm_ops
==> s3c24xx_pcm_open
==> snd_soc_set_runtime_hwparams(substream, &s3c24xx_pcm_hardware); 配置runtime->hw部分硬件参数
static const struct snd_pcm_hardware s3c24xx_pcm_hardware = {
    .info            = SNDRV_PCM_INFO_INTERLEAVED |
                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
                    SNDRV_PCM_INFO_MMAP |
                    SNDRV_PCM_INFO_MMAP_VALID |
                    SNDRV_PCM_INFO_PAUSE |
                    SNDRV_PCM_INFO_RESUME,
    .formats        = SNDRV_PCM_FMTBIT_S16_LE |
                    SNDRV_PCM_FMTBIT_U16_LE |
                    SNDRV_PCM_FMTBIT_U8 |
                    SNDRV_PCM_FMTBIT_S8,
    .channels_min        = 2,
    .channels_max        = 2,
    .buffer_bytes_max    = 128*1024,
    .period_bytes_min    = PAGE_SIZE,
    .period_bytes_max    = PAGE_SIZE*2,
    .periods_min        = 2,
    .periods_max        = 128,
    .fifo_size        = 32,
};