发帖
翼度科技»论坛 › 云主机 › LINUX › 查看内容

Linux 内核 ASoC DMA 引擎驱动程序

我是泥谁是水

4

主题

4

帖子

12

积分

新手上路

Rank: 1

积分
12
显示全部楼层
Linux 内核 ASoC 框架，在概念上将嵌入式音频系统拆分为多个可复用的组件驱动程序，包括 Codec 类驱动程序、平台类驱动程序和机器类驱动程序。在实现上，机器类驱动程序用 struct snd_soc_card 和 struct snd_soc_dai_link 结构描述，属于平台类驱动程序的 DMA 引擎驱动程序由 struct snd_soc_component_driver 结构描述，codec 类驱动程序和 I2S 等驱动程序，由 struct snd_soc_component_driver、struct snd_soc_dai_driver 和 struct snd_soc_dai_ops 等结构描述。除平台类驱动程序外的各种驱动程序都通过 component 抽象组织在一起，即这些驱动程序都作为 struct snd_soc_component_driver 注册给 Linux 内核 ASoC 框架，Linux 内核 ASoC 框架为它们各自创建 struct snd_soc_component 结构对象，并保存在 sound/soc/soc-core.c 文件中定义的全局链表 component_list 中。
一个 DMA 驱动程序的示例为 soc/pxa/pxa2xx-pcm.c：
  1. static const struct snd_soc_component_driver pxa2xx_soc_platform = {
  2.         .pcm_construct        = pxa2xx_soc_pcm_new,
  3.         .pcm_destruct        = pxa2xx_soc_pcm_free,
  4.         .open                = pxa2xx_soc_pcm_open,
  5.         .close                = pxa2xx_soc_pcm_close,
  6.         .hw_params        = pxa2xx_soc_pcm_hw_params,
  7.         .hw_free        = pxa2xx_soc_pcm_hw_free,
  8.         .prepare        = pxa2xx_soc_pcm_prepare,
  9.         .trigger        = pxa2xx_soc_pcm_trigger,
  10.         .pointer        = pxa2xx_soc_pcm_pointer,
  11.         .mmap                = pxa2xx_soc_pcm_mmap,
  12. };
  14. static int pxa2xx_soc_platform_probe(struct platform_device *pdev)
  15. {
  16.         return devm_snd_soc_register_component(&pdev->dev, &pxa2xx_soc_platform,
  17.                                                NULL, 0);
  18. }
  20. static struct platform_driver pxa_pcm_driver = {
  21.         .driver = {
  22.                 .name = "pxa-pcm-audio",
  23.         },
  25.         .probe = pxa2xx_soc_platform_probe,
  26. };
  28. module_platform_driver(pxa_pcm_driver);
复制代码
DMA 引擎驱动程序和 I2S 或 Codec 驱动程序一样，通过 devm_snd_soc_register_component() 函数以 struct snd_soc_component_driver 的形式注册给 Linux 内核 ASoC 框架，但比较特别的地方在于，它的 dai driver 参数为空。
机器类驱动程序定义的 struct snd_soc_dai_link 结构对象通过 struct snd_soc_dai_link_component 描述它引用的其它类型的驱动程序，如机器类驱动程序 sound/soc/pxa/e800_wm9712.c 有如下的代码片段：
  1. SND_SOC_DAILINK_DEFS(ac97,
  2.         DAILINK_COMP_ARRAY(COMP_CPU("pxa2xx-ac97")),
  3.         DAILINK_COMP_ARRAY(COMP_CODEC("wm9712-codec", "wm9712-hifi")),
  4.         DAILINK_COMP_ARRAY(COMP_PLATFORM("pxa-pcm-audio")));
  6. SND_SOC_DAILINK_DEFS(ac97_aux,
  7.         DAILINK_COMP_ARRAY(COMP_CPU("pxa2xx-ac97-aux")),
  8.         DAILINK_COMP_ARRAY(COMP_CODEC("wm9712-codec", "wm9712-aux")),
  9.         DAILINK_COMP_ARRAY(COMP_PLATFORM("pxa-pcm-audio")));
  11. static struct snd_soc_dai_link e800_dai[] = {
  12.         {
  13.                 .name = "AC97",
  14.                 .stream_name = "AC97 HiFi",
  15.                 SND_SOC_DAILINK_REG(ac97),
  16.         },
  17.         {
  18.                 .name = "AC97 Aux",
  19.                 .stream_name = "AC97 Aux",
  20.                 SND_SOC_DAILINK_REG(ac97_aux),
  21.         },
  22. };
  24. static struct snd_soc_card e800 = {
  25.         .name = "Toshiba e800",
  26.         .owner = THIS_MODULE,
  27.         .dai_link = e800_dai,
  28.         .num_links = ARRAY_SIZE(e800_dai),
  30.         .dapm_widgets = e800_dapm_widgets,
  31.         .num_dapm_widgets = ARRAY_SIZE(e800_dapm_widgets),
  32.         .dapm_routes = audio_map,
  33.         .num_dapm_routes = ARRAY_SIZE(audio_map),
  34. };
复制代码
SND_SOC_DAILINK_DEFS() 宏用于为 struct snd_soc_dai_link 方便地定义引用的 cpus、codecs 和 platforms 等 struct snd_soc_dai_link_component 数组，其中用于定义 platforms 的 DAILINK_COMP_ARRAY(COMP_PLATFORM("pxa-pcm-audio")) 引用了上面我们看到的 DMA 引擎驱动。
Linux 内核 ASoC 框架提供了一个通用的 DMA 引擎驱动程序，位于文件 sound/soc/soc-generic-dmaengine-pcm 中。这个驱动程序本身不会主动向 Linux 内核 ASoC 框架注册自己，需要使用 DMA 引擎在设备和内存之间传数据的驱动程序要在 probe 时注册它，如 sound/soc/rockchip/rockchip_pcm.c：
  1. static const struct snd_pcm_hardware snd_rockchip_hardware = {
  2.         .info                        = SNDRV_PCM_INFO_MMAP |
  3.                                   SNDRV_PCM_INFO_MMAP_VALID |
  4.                                   SNDRV_PCM_INFO_PAUSE |
  5.                                   SNDRV_PCM_INFO_RESUME |
  6.                                   SNDRV_PCM_INFO_INTERLEAVED,
  7.         .period_bytes_min        = 32,
  8.         .period_bytes_max        = 8192,
  9.         .periods_min                = 1,
  10.         .periods_max                = 52,
  11.         .buffer_bytes_max        = 64 * 1024,
  12.         .fifo_size                = 32,
  13. };
  15. static const struct snd_dmaengine_pcm_config rk_dmaengine_pcm_config = {
  16.         .pcm_hardware = &snd_rockchip_hardware,
  17.         .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
  18.         .prealloc_buffer_size = 32 * 1024,
  19. };
  21. int rockchip_pcm_platform_register(struct device *dev)
  22. {
  23.         return devm_snd_dmaengine_pcm_register(dev, &rk_dmaengine_pcm_config,
  24.                 SND_DMAENGINE_PCM_FLAG_COMPAT);
  25. }
  26. EXPORT_SYMBOL_GPL(rockchip_pcm_platform_register);
复制代码
这里的 rockchip_pcm_platform_register() 函数在 I2S 驱动程序的 probe 操作 (位于 sound/soc/rockchip/rockchip_i2s.c) 中调用：
  1. static int rockchip_i2s_probe(struct platform_device *pdev)
  2. {
  3. . . . . . .
  5.         ret = devm_snd_soc_register_component(&pdev->dev,
  6.                                               &rockchip_i2s_component,
  7.                                               soc_dai, 1);
  9.         if (ret) {
  10.                 dev_err(&pdev->dev, "Could not register DAI\n");
  11.                 goto err_suspend;
  12.         }
  14.         ret = rockchip_pcm_platform_register(&pdev->dev);
  15.         if (ret) {
  16.                 dev_err(&pdev->dev, "Could not register PCM\n");
  17.                 goto err_suspend;
  18.         }
  20.         return 0;
  21. . . . . . .
  22.         return ret;
  23. }
复制代码
rockchip_pcm_platform_register() 函数调用 devm_snd_dmaengine_pcm_register() 函数注册通用 DMA 引擎驱动程序。devm_snd_dmaengine_pcm_register() 函数定义 (位于 sound/soc/soc-devres.c) 如下：
  1. static void devm_dmaengine_pcm_release(struct device *dev, void *res)
  2. {
  3.         snd_dmaengine_pcm_unregister(*(struct device **)res);
  4. }
  6. /**
  7. * devm_snd_dmaengine_pcm_register - resource managed dmaengine PCM registration
  8. * @dev: The parent device for the PCM device
  9. * @config: Platform specific PCM configuration
  10. * @flags: Platform specific quirks
  11. *
  12. * Register a dmaengine based PCM device with automatic unregistration when the
  13. * device is unregistered.
  14. */
  15. int devm_snd_dmaengine_pcm_register(struct device *dev,
  16.         const struct snd_dmaengine_pcm_config *config, unsigned int flags)
  17. {
  18.         struct device **ptr;
  19.         int ret;
  21.         ptr = devres_alloc(devm_dmaengine_pcm_release, sizeof(*ptr), GFP_KERNEL);
  22.         if (!ptr)
  23.                 return -ENOMEM;
  25.         ret = snd_dmaengine_pcm_register(dev, config, flags);
  26.         if (ret == 0) {
  27.                 *ptr = dev;
  28.                 devres_add(dev, ptr);
  29.         } else {
  30.                 devres_free(ptr);
  31.         }
  33.         return ret;
  34. }
  35. EXPORT_SYMBOL_GPL(devm_snd_dmaengine_pcm_register);
  37. #endif
复制代码
devm_snd_dmaengine_pcm_register() 函数和之前看到的devm_snd_soc_register_card() 与 devm_snd_soc_register_component() 函数一样，只是它封装的是 snd_dmaengine_pcm_register() 函数。snd_dmaengine_pcm_register() 函数定义 (位于 sound/soc/soc-generic-dmaengine-pcm.c) 如下：
  1. static const struct snd_soc_component_driver dmaengine_pcm_component = {
  2.         .name                = SND_DMAENGINE_PCM_DRV_NAME,
  3.         .probe_order        = SND_SOC_COMP_ORDER_LATE,
  4.         .open                = dmaengine_pcm_open,
  5.         .close                = dmaengine_pcm_close,
  6.         .hw_params        = dmaengine_pcm_hw_params,
  7.         .trigger        = dmaengine_pcm_trigger,
  8.         .pointer        = dmaengine_pcm_pointer,
  9.         .pcm_construct        = dmaengine_pcm_new,
  10. };
  12. static const struct snd_soc_component_driver dmaengine_pcm_component_process = {
  13.         .name                = SND_DMAENGINE_PCM_DRV_NAME,
  14.         .probe_order        = SND_SOC_COMP_ORDER_LATE,
  15.         .open                = dmaengine_pcm_open,
  16.         .close                = dmaengine_pcm_close,
  17.         .hw_params        = dmaengine_pcm_hw_params,
  18.         .trigger        = dmaengine_pcm_trigger,
  19.         .pointer        = dmaengine_pcm_pointer,
  20.         .copy_user        = dmaengine_copy_user,
  21.         .pcm_construct        = dmaengine_pcm_new,
  22. };
  24. static const char * const dmaengine_pcm_dma_channel_names[] = {
  25.         [SNDRV_PCM_STREAM_PLAYBACK] = "tx",
  26.         [SNDRV_PCM_STREAM_CAPTURE] = "rx",
  27. };
  29. static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm *pcm,
  30.         struct device *dev, const struct snd_dmaengine_pcm_config *config)
  31. {
  32.         unsigned int i;
  33.         const char *name;
  34.         struct dma_chan *chan;
  36.         if ((pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_DT) || (!dev->of_node &&
  37.             !(config && config->dma_dev && config->dma_dev->of_node)))
  38.                 return 0;
  40.         if (config && config->dma_dev) {
  41.                 /*
  42.                  * If this warning is seen, it probably means that your Linux
  43.                  * device structure does not match your HW device structure.
  44.                  * It would be best to refactor the Linux device structure to
  45.                  * correctly match the HW structure.
  46.                  */
  47.                 dev_warn(dev, "DMA channels sourced from device %s",
  48.                          dev_name(config->dma_dev));
  49.                 dev = config->dma_dev;
  50.         }
  52.         for_each_pcm_streams(i) {
  53.                 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
  54.                         name = "rx-tx";
  55.                 else
  56.                         name = dmaengine_pcm_dma_channel_names[i];
  57.                 if (config && config->chan_names[i])
  58.                         name = config->chan_names[i];
  59.                 chan = dma_request_chan(dev, name);
  60.                 if (IS_ERR(chan)) {
  61.                         /*
  62.                          * Only report probe deferral errors, channels
  63.                          * might not be present for devices that
  64.                          * support only TX or only RX.
  65.                          */
  66.                         if (PTR_ERR(chan) == -EPROBE_DEFER)
  67.                                 return -EPROBE_DEFER;
  68.                         pcm->chan[i] = NULL;
  69.                 } else {
  70.                         pcm->chan[i] = chan;
  71.                 }
  72.                 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
  73.                         break;
  74.         }
  76.         if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
  77.                 pcm->chan[1] = pcm->chan[0];
  79.         return 0;
  80. }
  82. static void dmaengine_pcm_release_chan(struct dmaengine_pcm *pcm)
  83. {
  84.         unsigned int i;
  86.         for_each_pcm_streams(i) {
  87.                 if (!pcm->chan[i])
  88.                         continue;
  89.                 dma_release_channel(pcm->chan[i]);
  90.                 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
  91.                         break;
  92.         }
  93. }
  95. /**
  96. * snd_dmaengine_pcm_register - Register a dmaengine based PCM device
  97. * @dev: The parent device for the PCM device
  98. * @config: Platform specific PCM configuration
  99. * @flags: Platform specific quirks
  100. */
  101. int snd_dmaengine_pcm_register(struct device *dev,
  102.         const struct snd_dmaengine_pcm_config *config, unsigned int flags)
  103. {
  104.         const struct snd_soc_component_driver *driver;
  105.         struct dmaengine_pcm *pcm;
  106.         int ret;
  108.         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
  109.         if (!pcm)
  110.                 return -ENOMEM;
  112. #ifdef CONFIG_DEBUG_FS
  113.         pcm->component.debugfs_prefix = "dma";
  114. #endif
  115.         pcm->config = config;
  116.         pcm->flags = flags;
  118.         ret = dmaengine_pcm_request_chan_of(pcm, dev, config);
  119.         if (ret)
  120.                 goto err_free_dma;
  122.         if (config && config->process)
  123.                 driver = &dmaengine_pcm_component_process;
  124.         else
  125.                 driver = &dmaengine_pcm_component;
  127.         ret = snd_soc_component_initialize(&pcm->component, driver, dev);
  128.         if (ret)
  129.                 goto err_free_dma;
  131.         ret = snd_soc_add_component(&pcm->component, NULL, 0);
  132.         if (ret)
  133.                 goto err_free_dma;
  135.         return 0;
  137. err_free_dma:
  138.         dmaengine_pcm_release_chan(pcm);
  139.         kfree(pcm);
  140.         return ret;
  141. }
  142. EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register);
  144. /**
  145. * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device
  146. * @dev: Parent device the PCM was register with
  147. *
  148. * Removes a dmaengine based PCM device previously registered with
  149. * snd_dmaengine_pcm_register.
  150. */
  151. void snd_dmaengine_pcm_unregister(struct device *dev)
  152. {
  153.         struct snd_soc_component *component;
  154.         struct dmaengine_pcm *pcm;
  156.         component = snd_soc_lookup_component(dev, SND_DMAENGINE_PCM_DRV_NAME);
  157.         if (!component)
  158.                 return;
  160.         pcm = soc_component_to_pcm(component);
  162.         snd_soc_unregister_component_by_driver(dev, component->driver);
  163.         dmaengine_pcm_release_chan(pcm);
  164.         kfree(pcm);
  165. }
  166. EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister);
  168. MODULE_LICENSE("GPL");
复制代码
snd_dmaengine_pcm_register() 函数的执行过程如下：

  • 动态分配一个 struct dmaengine_pcm 结构对象，并初始化其 config 和 flags 等字段，struct dmaengine_pcm 结构定义 (位于 include/sound/dmaengine_pcm.h) 如下：
  1. struct dmaengine_pcm {
  2.         struct dma_chan *chan[SNDRV_PCM_STREAM_LAST + 1];
  3.         const struct snd_dmaengine_pcm_config *config;
  4.         struct snd_soc_component component;
  5.         unsigned int flags;
  6. };
复制代码
这个结构有一个 struct snd_soc_component 结构成员；

  • 为数据的发送和接收申请 DMA 通道，这个需要在设备树的设备节点定义中，指定发送和接收引用的 DMA 通道，像下面这样：
  1.         i2s0_8ch: i2s@fe470000 {
  2. . . . . . .
  3.                 dmas = <&dmac0 0>, <&dmac0 1>;
  4.                 dma-names = "tx", "rx";
  5. . . . . . .
  6.         };
复制代码

  • 根据传入的 config 参数，选择 struct snd_soc_component_driver，dmaengine_pcm_component_process 和 dmaengine_pcm_component 仅有的区别是，前者多定义了一个 copy_user 操作；
  • 初始化并添加 struct snd_soc_component 结构对象，有一个函数 (位于 include/sound/dmaengine_pcm.h) 可以通过 struct snd_soc_component 结构对象获得 struct dmaengine_pcm 结构对象：
  1. static inline struct dmaengine_pcm *soc_component_to_pcm(struct snd_soc_component *p)
  2. {
  3.         return container_of(p, struct dmaengine_pcm, component);
  4. }
复制代码
通用 DMA 引擎驱动程序支持的操作由 struct snd_soc_component_driver 定义。在全局  component 链表中，相应的 struct snd_soc_component 由注册它的 dev 标识。
使用了通用 DMA 引擎驱动程序的 ASoC 机器驱动程序，示例 (位于 sound/soc/rockchip/rockchip_rt5645.c) 如下：
  1. SND_SOC_DAILINK_DEFS(pcm,
  2.         DAILINK_COMP_ARRAY(COMP_EMPTY()),
  3.         DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5645-aif1")),
  4.         DAILINK_COMP_ARRAY(COMP_EMPTY()));
  6. static struct snd_soc_dai_link rk_dailink = {
  7.         .name = "rt5645",
  8.         .stream_name = "rt5645 PCM",
  9.         .init = rk_init,
  10.         .ops = &rk_aif1_ops,
  11.         /* set rt5645 as slave */
  12.         .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
  13.                 SND_SOC_DAIFMT_CBS_CFS,
  14.         SND_SOC_DAILINK_REG(pcm),
  15. };
  17. static struct snd_soc_card snd_soc_card_rk = {
  18.         .name = "I2S-RT5650",
  19.         .owner = THIS_MODULE,
  20.         .dai_link = &rk_dailink,
  21.         .num_links = 1,
  22.         .dapm_widgets = rk_dapm_widgets,
  23.         .num_dapm_widgets = ARRAY_SIZE(rk_dapm_widgets),
  24.         .dapm_routes = rk_audio_map,
  25.         .num_dapm_routes = ARRAY_SIZE(rk_audio_map),
  26.         .controls = rk_mc_controls,
  27.         .num_controls = ARRAY_SIZE(rk_mc_controls),
  28. };
  29. . . . . . .
  30. static int snd_rk_mc_probe(struct platform_device *pdev)
  31. {
  32. . . . . . .
  33.         rk_dailink.cpus->of_node = of_parse_phandle(np,
  34.                         "rockchip,i2s-controller", 0);
  35.         if (!rk_dailink.cpus->of_node) {
  36.                 dev_err(&pdev->dev,
  37.                         "Property 'rockchip,i2s-controller' missing or invalid\n");
  38.                 ret = -EINVAL;
  39.                 goto put_codec_of_node;
  40.         }
  42.         rk_dailink.platforms->of_node = rk_dailink.cpus->of_node;
  43. . . . . . .
  44. }
复制代码
这里为 dai link 定义的 cpus dai 数组和 platforms 数组中都只有一个空元素，但在 probe 操作中，根据设备树中设备节点的定义，查找了对应的 of_node。尽管 cpus dai 和 platforms 引用了相同的 of_node，但在 snd_soc_add_pcm_runtime() 函数中，为 CPU DAI 添加 struct snd_soc_component 的过程是，先查找对应的 struct snd_soc_dai，再从 struct snd_soc_dai 获得 struct snd_soc_component，这也就意味着，为 CPU DAI 查找  struct snd_soc_component 时，不会找到没有 struct snd_soc_dai 的通用 DMA 引擎的 struct snd_soc_component。为 platforms 添加 struct snd_soc_component 的过程，则是直接查找所有匹配的 struct snd_soc_component 并添加。
在为 PCM 创建 struct snd_soc_pcm_runtime 时，即在机器类驱动程序的 probe 操作中，如果为 snd_soc_dai_link 做了类似于这里的处理，使 CPU DAI 和 platform 指向相同的 of_node，且对应于 of_node 的设备驱动程序注册了通用 DMA 引擎驱动程序，通用 DMA 引擎的 struct snd_soc_component 将会包含在它的 component 链表中。
通用 DMA 引擎驱动程序的 struct snd_soc_component_driver 还有一个特别的地方是，指定了 probe_order 为 SND_SOC_COMP_ORDER_LATE，这使得它的 probe 和 init 操作，相对而言，执行的更晚，同时它在 snd_soc_card 中的位置也更靠后一点。如在 soc_probe_link_components() 函数 (位于 sound/soc/soc-core.c) 中：
  1. static int soc_probe_component(struct snd_soc_card *card,
  2.                                struct snd_soc_component *component)
  3. {
  4.         struct snd_soc_dapm_context *dapm =
  5.                 snd_soc_component_get_dapm(component);
  6.         struct snd_soc_dai *dai;
  7.         int probed = 0;
  8.         int ret;
  10.         if (!strcmp(component->name, "snd-soc-dummy"))
  11.                 return 0;
  13.         if (component->card) {
  14.                 if (component->card != card) {
  15.                         dev_err(component->dev,
  16.                                 "Trying to bind component to card "%s" but is already bound to card "%s"\n",
  17.                                 card->name, component->card->name);
  18.                         return -ENODEV;
  19.                 }
  20.                 return 0;
  21.         }
  23.         ret = snd_soc_component_module_get_when_probe(component);
  24.         if (ret < 0)
  25.                 return ret;
  27.         component->card = card;
  28.         soc_set_name_prefix(card, component);
  30.         soc_init_component_debugfs(component);
  32.         snd_soc_dapm_init(dapm, card, component);
  34.         ret = snd_soc_dapm_new_controls(dapm,
  35.                                         component->driver->dapm_widgets,
  36.                                         component->driver->num_dapm_widgets);
  38.         if (ret != 0) {
  39.                 dev_err(component->dev,
  40.                         "Failed to create new controls %d\n", ret);
  41.                 goto err_probe;
  42.         }
  44.         for_each_component_dais(component, dai) {
  45.                 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
  46.                 if (ret != 0) {
  47.                         dev_err(component->dev,
  48.                                 "Failed to create DAI widgets %d\n", ret);
  49.                         goto err_probe;
  50.                 }
  51.         }
  53.         ret = snd_soc_component_probe(component);
  54.         if (ret < 0) {
  55.                 dev_err(component->dev,
  56.                         "ASoC: failed to probe component %d\n", ret);
  57.                 goto err_probe;
  58.         }
  59.         WARN(dapm->idle_bias_off &&
  60.              dapm->bias_level != SND_SOC_BIAS_OFF,
  61.              "codec %s can not start from non-off bias with idle_bias_off==1\n",
  62.              component->name);
  63.         probed = 1;
  65.         /*
  66.          * machine specific init
  67.          * see
  68.          *        snd_soc_component_set_aux()
  69.          */
  70.         ret = snd_soc_component_init(component);
  71.         if (ret < 0)
  72.                 goto err_probe;
  74.         ret = snd_soc_add_component_controls(component,
  75.                                              component->driver->controls,
  76.                                              component->driver->num_controls);
  77.         if (ret < 0)
  78.                 goto err_probe;
  80.         ret = snd_soc_dapm_add_routes(dapm,
  81.                                       component->driver->dapm_routes,
  82.                                       component->driver->num_dapm_routes);
  83.         if (ret < 0) {
  84.                 if (card->disable_route_checks) {
  85.                         dev_info(card->dev,
  86.                                  "%s: disable_route_checks set, ignoring errors on add_routes\n",
  87.                                  __func__);
  88.                 } else {
  89.                         dev_err(card->dev,
  90.                                 "%s: snd_soc_dapm_add_routes failed: %d\n",
  91.                                 __func__, ret);
  92.                         goto err_probe;
  93.                 }
  94.         }
  96.         /* see for_each_card_components */
  97.         list_add(&component->card_list, &card->component_dev_list);
  99. err_probe:
  100.         if (ret < 0)
  101.                 soc_remove_component(component, probed);
  103.         return ret;
  104. }
  105. . . . . . .
  106. static int soc_probe_link_components(struct snd_soc_card *card)
  107. {
  108.         struct snd_soc_component *component;
  109.         struct snd_soc_pcm_runtime *rtd;
  110.         int i, ret, order;
  112.         for_each_comp_order(order) {
  113.                 for_each_card_rtds(card, rtd) {
  114.                         for_each_rtd_components(rtd, i, component) {
  115.                                 if (component->driver->probe_order != order)
  116.                                         continue;
  118.                                 ret = soc_probe_component(card, component);
  119.                                 if (ret < 0)
  120.                                         return ret;
  121.                         }
  122.                 }
  123.         }
  125.         return 0;
  126. }
复制代码
这里用到的 for_each_comp_order() 宏定义 (位于 include/sound/soc-component.h) 如下：
  1. #define SND_SOC_COMP_ORDER_FIRST        -2
  2. #define SND_SOC_COMP_ORDER_EARLY        -1
  3. #define SND_SOC_COMP_ORDER_NORMAL         0
  4. #define SND_SOC_COMP_ORDER_LATE                 1
  5. #define SND_SOC_COMP_ORDER_LAST                 2
  7. #define for_each_comp_order(order)                \
  8.         for (order  = SND_SOC_COMP_ORDER_FIRST;        \
  9.              order <= SND_SOC_COMP_ORDER_LAST;        \
  10.              order++)
复制代码
回到通用 DMA 引擎驱动程序的 pcm_construct 操作 dmaengine_pcm_new() 函数，这个函数定义 (位于 sound/soc/soc-generic-dmaengine-pcm.c) 如下：
  1. static const struct snd_soc_component_driver dmaengine_pcm_component = {
  2.         .name                = SND_DMAENGINE_PCM_DRV_NAME,
  3.         .probe_order        = SND_SOC_COMP_ORDER_LATE,
  4.         .open                = dmaengine_pcm_open,
  5.         .close                = dmaengine_pcm_close,
  6.         .hw_params        = dmaengine_pcm_hw_params,
  7.         .trigger        = dmaengine_pcm_trigger,
  8.         .pointer        = dmaengine_pcm_pointer,
  9.         .pcm_construct        = dmaengine_pcm_new,
  10. };
  12. static const struct snd_soc_component_driver dmaengine_pcm_component_process = {
  13.         .name                = SND_DMAENGINE_PCM_DRV_NAME,
  14.         .probe_order        = SND_SOC_COMP_ORDER_LATE,
  15.         .open                = dmaengine_pcm_open,
  16.         .close                = dmaengine_pcm_close,
  17.         .hw_params        = dmaengine_pcm_hw_params,
  18.         .trigger        = dmaengine_pcm_trigger,
  19.         .pointer        = dmaengine_pcm_pointer,
  20.         .copy_user        = dmaengine_copy_user,
  21.         .pcm_construct        = dmaengine_pcm_new,
  22. };
复制代码
这个函数分别为播放和录制申请 DMA 通道，并分配 DMA buffer 用于用户空间应用程序、内核 ALSA/ASoc 框架和硬件设备之间的数据交换。snd_pcm_set_managed_buffer() 函数分配 DMA 缓冲区。snd_pcm_set_managed_buffer() 函数定义 (位于 sound/core/pcm_memory.c) 如下：
  1. int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd)
  2. {
  3.         struct snd_soc_component *component;
  4.         int ret;
  5.         int i;
  7.         for_each_rtd_components(rtd, i, component) {
  8.                 if (component->driver->pcm_construct) {
  9.                         ret = component->driver->pcm_construct(component, rtd);
  10.                         if (ret < 0)
  11.                                 return soc_component_ret(component, ret);
  12.                 }
  13.         }
  15.         return 0;
  16. }
复制代码
open 操作 dmaengine_pcm_open() 函数完成数据传输之前的准备工作，这个函数定义如下：
  1. static int dmaengine_pcm_new(struct snd_soc_component *component,
  2.                              struct snd_soc_pcm_runtime *rtd)
  3. {
  4.         struct dmaengine_pcm *pcm = soc_component_to_pcm(component);
  5.         const struct snd_dmaengine_pcm_config *config = pcm->config;
  6.         struct device *dev = component->dev;
  7.         struct snd_pcm_substream *substream;
  8.         size_t prealloc_buffer_size;
  9.         size_t max_buffer_size;
  10.         unsigned int i;
  12.         if (config && config->prealloc_buffer_size) {
  13.                 prealloc_buffer_size = config->prealloc_buffer_size;
  14.                 max_buffer_size = config->pcm_hardware->buffer_bytes_max;
  15.         } else {
  16.                 prealloc_buffer_size = 512 * 1024;
  17.                 max_buffer_size = SIZE_MAX;
  18.         }
  20.         for_each_pcm_streams(i) {
  21.                 substream = rtd->pcm->streams[i].substream;
  22.                 if (!substream)
  23.                         continue;
  25.                 if (!pcm->chan[i] && config && config->chan_names[i])
  26.                         pcm->chan[i] = dma_request_slave_channel(dev,
  27.                                 config->chan_names[i]);
  29.                 if (!pcm->chan[i] && (pcm->flags & SND_DMAENGINE_PCM_FLAG_COMPAT)) {
  30.                         pcm->chan[i] = dmaengine_pcm_compat_request_channel(
  31.                                 component, rtd, substream);
  32.                 }
  34.                 if (!pcm->chan[i]) {
  35.                         dev_err(component->dev,
  36.                                 "Missing dma channel for stream: %d\n", i);
  37.                         return -EINVAL;
  38.                 }
  40.                 snd_pcm_set_managed_buffer(substream,
  41.                                 SNDRV_DMA_TYPE_DEV_IRAM,
  42.                                 dmaengine_dma_dev(pcm, substream),
  43.                                 prealloc_buffer_size,
  44.                                 max_buffer_size);
  46.                 if (!dmaengine_pcm_can_report_residue(dev, pcm->chan[i]))
  47.                         pcm->flags |= SND_DMAENGINE_PCM_FLAG_NO_RESIDUE;
  49.                 if (rtd->pcm->streams[i].pcm->name[0] == '\0') {
  50.                         strscpy_pad(rtd->pcm->streams[i].pcm->name,
  51.                                     rtd->pcm->streams[i].pcm->id,
  52.                                     sizeof(rtd->pcm->streams[i].pcm->name));
  53.                 }
  54.         }
  56.         return 0;
  57. }
复制代码
这里调用 snd_soc_dai_get_dma_data() 函数获得类型为 struct snd_dmaengine_dai_dma_data 的 DMA 数据。这是通用 DMA 引擎驱动程序和 I2S 等 DAI 驱动程序的一个约定，即需要在 DAI 驱动程序的 probe 操作中设置 DMA 数据，类似于下面这样：
  1. static void preallocate_pages(struct snd_pcm_substream *substream,
  2.                               int type, struct device *data,
  3.                               size_t size, size_t max, bool managed)
  4. {
  5.         if (snd_BUG_ON(substream->dma_buffer.dev.type))
  6.                 return;
  8.         substream->dma_buffer.dev.type = type;
  9.         substream->dma_buffer.dev.dev = data;
  11.         if (size > 0 && preallocate_dma && substream->number < maximum_substreams)
  12.                 preallocate_pcm_pages(substream, size);
  14.         if (substream->dma_buffer.bytes > 0)
  15.                 substream->buffer_bytes_max = substream->dma_buffer.bytes;
  16.         substream->dma_max = max;
  17.         if (max > 0)
  18.                 preallocate_info_init(substream);
  19.         if (managed)
  20.                 substream->managed_buffer_alloc = 1;
  21. }
  22. . . . . . .
  23. void snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
  24.                                 struct device *data, size_t size, size_t max)
  25. {
  26.         preallocate_pages(substream, type, data, size, max, true);
  27. }
  28. EXPORT_SYMBOL(snd_pcm_set_managed_buffer);
复制代码
dmaengine_pcm_open() 函数主要是为流设置了运行时硬件参数。
对于其它操作，暂时不做太多说明。
Done.

来源:https://www.cnblogs.com/wolfcs/p/17658297.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！

上一篇: shell简明教程2退出状态和返回代码

下一篇: shell简明教程3函数

发表于 2023-8-27 01:02:34

举报 回复 使用道具

返回列表 发新帖

Archiver|手机版|小黑屋|翼度科技

Copyright © 2001-2020, Tencent Cloud.　Powered by Discuz! X3.4