高通ASOC中的codec驱动

继上一篇文章：高通Audio中ASOC的machine驱动（一）

ASOC的出现是为了让codec独立于CPU，减少和CPU之间的耦合，这样同一个codec驱动就无需修改就可以匹配任何一款平台。

在Machine中已经知道，snd_soc_dai_link结构就指明了该Machine所使用的Platform和Codec。在Codec这边通过codec_dai和Platform侧的cpu_dai相互通信，既然相互通信，就需要遵守一定的规则，其中codec_dai和cpu_dai统一抽象为struct snd_soc_dai结构，而将dai的相关操作使用snd_soc_dai_driver抽象。同时也需要对所有的codec设备进行抽象封装，linux使用snd_soc_codec进行所有codec设备的抽象，而将codec的驱动抽象为snd_soc_codec_driver结构。

 

 

1、重要的数据结构：

所有简单来说，Codec侧有四个重要的数据结构:

 

struct snd_soc_dai，struct snd_soc_dai_driver，struct snd_soc_codec，struct snd_soc_codec_driver。

 

snd_soc_dai:

 /*
  * Digital Audio Interface runtime data.
  *
  * Holds runtime data for a DAI.
  */
 struct snd_soc_dai {
     const char *name;  /* dai的名字 */
     struct device *dev;  /* 设备指针 */

     /* driver ops */
     struct snd_soc_dai_driver *driver;  /* 指向dai驱动结构的指针 */

     /* DAI runtime info */
     unsigned int capture_active:;        /* stream is in use */
     unsigned int playback_active:;        /* stream is in use */

     /* DAI DMA data */
     void *playback_dma_data;  /* 用于管理playback dma */
     void *capture_dma_data;  /* 用于管理capture dma */

     /* parent platform/codec */
     union {
         struct snd_soc_platform *platform;  /* 如果是cpu dai，指向所绑定的平台 */
         struct snd_soc_codec *codec;  /* 如果是codec dai指向所绑定的codec */
     };
     struct snd_soc_card *card;  /* 指向Machine驱动中的crad实例 */
 };

snd_soc_dai_driver:

 /*
  * Digital Audio Interface Driver.
  *
  * Describes the Digital Audio Interface in terms of its ALSA, DAI and AC97
  * operations and capabilities. Codec and platform drivers will register this
  * structure for every DAI they have.
  *
  * This structure covers the clocking, formating and ALSA operations for each
  * interface.
  */
 struct snd_soc_dai_driver {
     /* DAI description */
     const char *name;  /* dai驱动名字 */

     /* DAI driver callbacks */
     int (*probe)(struct snd_soc_dai *dai);  /* dai驱动的probe函数，由snd_soc_instantiate_card回调 */
     int (*remove)(struct snd_soc_dai *dai);
     int (*suspend)(struct snd_soc_dai *dai);  /* 电源管理 */
     int (*resume)(struct snd_soc_dai *dai);  

     /* ops */
     const struct snd_soc_dai_ops *ops;  /* 指向本dai的snd_soc_dai_ops结构 */

     /* DAI capabilities */
     struct snd_soc_pcm_stream capture;  /* 描述capture的能力 */
     struct snd_soc_pcm_stream playback;  /* 描述playback的能力 */
 };

snd_soc_codec：

 /* SoC Audio Codec device */
 struct snd_soc_codec {
     const char *name;  /* Codec的名字*/
     struct device *dev; /* 指向Codec设备的指针 */
     const struct snd_soc_codec_driver *driver; /* 指向该codec的驱动的指针 */
     struct snd_soc_card *card;    /* 指向Machine驱动的card实例 */
     int num_dai; /* 该Codec数字接口的个数，目前越来越多的Codec带有多个I2S或者是PCM接口 */
     int (*volatile_register)(...);  /* 用于判定某一寄存器是否是volatile */
     int (*readable_register)(...);  /* 用于判定某一寄存器是否可读 */
     int (*writable_register)(...);  /* 用于判定某一寄存器是否可写 */

     /* runtime */
     ......
     /* codec IO */
     void *control_data; /* 该指针指向的结构用于对codec的控制，通常和read，write字段联合使用 */
     enum snd_soc_control_type control_type;/* 可以是SND_SOC_SPI，SND_SOC_I2C，SND_SOC_REGMAP中的一种 */
     unsigned int (*read)(struct snd_soc_codec *, unsigned int);  /* 读取Codec寄存器的函数 */
     int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);  /* 写入Codec寄存器的函数 */
     /* dapm */
     struct snd_soc_dapm_context dapm;  /* 用于DAPM控件 */
 };

snd_soc_codec_driver：

 /* codec driver */
 struct snd_soc_codec_driver {
     /* driver ops */
     int (*probe)(struct snd_soc_codec *);  /* codec驱动的probe函数，由snd_soc_instantiate_card回调 */
     int (*remove)(struct snd_soc_codec *);
     int (*suspend)(struct snd_soc_codec *);  /* 电源管理 */
     int (*resume)(struct snd_soc_codec *);  /* 电源管理 */

     /* Default control and setup, added after probe() is run */
     const struct snd_kcontrol_new *controls;  /* 音频控件指针 */
     const struct snd_soc_dapm_widget *dapm_widgets;  /* dapm部件指针 */
     const struct snd_soc_dapm_route *dapm_routes;  /* dapm路由指针 */

     /* codec wide operations */
     int (*set_sysclk)(...);  /* 时钟配置函数 */
     int (*set_pll)(...);  /* 锁相环配置函数 */

     /* codec IO */
     unsigned int (*read)(...);  /* 读取codec寄存器函数 */
     int (*write)(...);  /* 写入codec寄存器函数 */
     int (*volatile_register)(...);  /* 用于判定某一寄存器是否是volatile */
     int (*readable_register)(...);  /* 用于判定某一寄存器是否可读 */
     int (*writable_register)(...);  /* 用于判定某一寄存器是否可写 */

     /* codec bias level */
     int (*set_bias_level)(...);  /* 偏置电压配置函数 */

 };

2、Codec代码分析：

2.1 找到codec的代码：

如何找到codec的代码呢？  答案是通过machine中的snd_soc_dai_link结构:

 {
         .name = LPASS_BE_TERT_MI2S_TX,
         .stream_name = "Tertiary MI2S Capture",
         .cpu_dai_name = "msm-dai-q6-mi2s.2",
         .platform_name = "msm-pcm-routing",
         .codec_name     = MSM8X16_CODEC_NAME,
         .codec_dai_name = "msm8x16_wcd_i2s_tx1",
         .no_pcm = ,
         .be_id = MSM_BACKEND_DAI_TERTIARY_MI2S_TX,
         .be_hw_params_fixup = msm_tx_be_hw_params_fixup,
         .ops = &msm8x16_mi2s_be_ops,
         .ignore_suspend = ,
 },

由dai_link中codec_name，可以知道我们的codec驱动在哪。

由高通Audio中ASOC的machine驱动这篇文章中的匹配并注册相应驱动的那一章分析可知，codec驱动代码就是msm8x16-wcd.c这个文件；

3、查看codec的probe函数：

因为Codec驱动的代码要做到平台无关性，要使得Machine驱动能够使用该Codec，Codec驱动的首要任务就是确定snd_soc_codec和snd_soc_dai的实例，并把它们注册到系统中，注册后的codec和dai才能为Machine驱动所用。

 static int msm8x16_wcd_spmi_probe(struct spmi_device *spmi)
 {
     int ret = ;
     struct msm8x16_wcd *msm8x16 = NULL;
     struct msm8x16_wcd_pdata *pdata;
     struct resource *wcd_resource;
     int modem_state;

     dev_dbg(&spmi->dev, "%s(%d):slave ID = 0x%x\n",
         __func__, __LINE__,  spmi->sid);

     modem_state = apr_get_modem_state();
     if (modem_state != APR_SUBSYS_LOADED) {
         dev_dbg(&spmi->dev, "Modem is not loaded yet %d\n",
                 modem_state);
         return -EPROBE_DEFER;
     }

     wcd_resource = spmi_get_resource(spmi, NULL, IORESOURCE_MEM, );
     if (!wcd_resource) {
         dev_err(&spmi->dev, "Unable to get Tombak base address\n");
         return -ENXIO;
     }

     switch (wcd_resource->start) {
     case TOMBAK_CORE_0_SPMI_ADDR:
         msm8x16_wcd_modules[].spmi = spmi;
         msm8x16_wcd_modules[].base = (spmi->sid << ) +
                         wcd_resource->start;
         wcd9xxx_spmi_set_dev(msm8x16_wcd_modules[].spmi, );
         device_init_wakeup(&spmi->dev, true);
         break;
     case TOMBAK_CORE_1_SPMI_ADDR:
         msm8x16_wcd_modules[].spmi = spmi;
         msm8x16_wcd_modules[].base = (spmi->sid << ) +
                         wcd_resource->start;
         wcd9xxx_spmi_set_dev(msm8x16_wcd_modules[].spmi, );
     if (wcd9xxx_spmi_irq_init()) {
         dev_err(&spmi->dev,
                 "%s: irq initialization failed\n", __func__);
     } else {
         dev_dbg(&spmi->dev,
                 "%s: irq initialization passed\n", __func__);
     }
         goto rtn;
     default:
         ret = -EINVAL;
         goto rtn;
     }

     dev_dbg(&spmi->dev, "%s(%d):start addr = 0x%pa\n",
         __func__, __LINE__,  &wcd_resource->start);

     if (wcd_resource->start != TOMBAK_CORE_0_SPMI_ADDR)
         goto rtn;

     dev_set_name(&spmi->dev, "%s", MSM8X16_CODEC_NAME);
     if (spmi->dev.of_node) {
         dev_dbg(&spmi->dev, "%s:Platform data from device tree\n",
             __func__);
         pdata = msm8x16_wcd_populate_dt_pdata(&spmi->dev);
         spmi->dev.platform_data = pdata;
     } else {
         dev_dbg(&spmi->dev, "%s:Platform data from board file\n",
             __func__);
         pdata = spmi->dev.platform_data;
     }

     msm8x16 = kzalloc(sizeof(struct msm8x16_wcd), GFP_KERNEL);
     if (msm8x16 == NULL) {
         dev_err(&spmi->dev,
             "%s: error, allocation failed\n", __func__);
         ret = -ENOMEM;
         goto rtn;
     }

     msm8x16->dev = &spmi->dev;
     msm8x16->read_dev = __msm8x16_wcd_reg_read;
     msm8x16->write_dev = __msm8x16_wcd_reg_write;
     ret = msm8x16_wcd_init_supplies(msm8x16, pdata);
     if (ret) {
         dev_err(&spmi->dev, "%s: Fail to enable Codec supplies\n",
             __func__);
         goto err_codec;
     }

     ret = msm8x16_wcd_enable_static_supplies(msm8x16, pdata);
     if (ret) {
         dev_err(&spmi->dev,
             "%s: Fail to enable Codec pre-reset supplies\n",
                __func__);
         goto err_codec;
     }
     usleep_range(, );

     ret = msm8x16_wcd_device_init(msm8x16);
     if (ret) {
         dev_err(&spmi->dev,
             "%s:msm8x16_wcd_device_init failed with error %d\n",
             __func__, ret);
         goto err_supplies;
     }
     dev_set_drvdata(&spmi->dev, msm8x16);

     ret = snd_soc_register_codec(&spmi->dev, &soc_codec_dev_msm8x16_wcd,
                      msm8x16_wcd_i2s_dai,
                      ARRAY_SIZE(msm8x16_wcd_i2s_dai));
     if (ret) {
         dev_err(&spmi->dev,
             "%s:snd_soc_register_codec failed with error %d\n",
             __func__, ret);
     } else {
         goto rtn;
     }
 err_supplies:
     msm8x16_wcd_disable_supplies(msm8x16, pdata);
 err_codec:
     kfree(msm8x16);
 rtn:
     return ret;
 }

msm8x16_wcd_spmi_probe

SPMI总线是高通电源管理的一种规范，也就是通过PMU控制音频（具体我也不够了解，有待以后深入理解）

看看最重要的函数：

 ret = snd_soc_register_codec(&spmi->dev, &soc_codec_dev_msm8x16_wcd,
                      msm8x16_wcd_i2s_dai,
                      ARRAY_SIZE(msm8x16_wcd_i2s_dai));

此函数通过snd_soc_register_codec函数注册了wcd9320的codec，同时传入了snd_soc_codec_driver和snd_soc_dai_driver结构。

 static struct snd_soc_codec_driver soc_codec_dev_msm8x16_wcd = {
     .probe    = msm8x16_wcd_codec_probe,　　/*codec驱动的probe函数，由snd_soc_instantiate_card回调*/
     .remove    = msm8x16_wcd_codec_remove,

     .read = msm8x16_wcd_read,
     .write = msm8x16_wcd_write,

     .suspend = msm8x16_wcd_suspend,　　　　/*电源管理*/
     .resume = msm8x16_wcd_resume,　　　　　/*电源管理*/

     .readable_register = msm8x16_wcd_readable,
     .volatile_register = msm8x16_wcd_volatile,

     .reg_cache_size = MSM8X16_WCD_CACHE_SIZE,
     .reg_cache_default = msm8x16_wcd_reset_reg_defaults,
     .reg_word_size = ,

     .controls = msm8x16_wcd_snd_controls,　　　　
     .num_controls = ARRAY_SIZE(msm8x16_wcd_snd_controls),
     .dapm_widgets = msm8x16_wcd_dapm_widgets,
     .num_dapm_widgets = ARRAY_SIZE(msm8x16_wcd_dapm_widgets),
     .dapm_routes = audio_map,
     .num_dapm_routes = ARRAY_SIZE(audio_map),
 };

 snd_soc_dai_driver结构:

 static struct snd_soc_dai_driver msm8x16_wcd_i2s_dai[] = {
     {
         .name = "msm8x16_wcd_i2s_rx1",
         .id = AIF1_PB,
         .playback = {
             .stream_name = "AIF1 Playback",
             .rates = MSM8X16_WCD_RATES,
             .formats = MSM8X16_WCD_FORMATS,
             .rate_max = ,
             .rate_min = ,
             .channels_min = ,
             .channels_max = ,
         },
         .ops = &msm8x16_wcd_dai_ops,
     },
     {
         .name = "msm8x16_wcd_i2s_tx1",
         .id = AIF1_CAP,
         .capture = {
             .stream_name = "AIF1 Capture",
             .rates = MSM8X16_WCD_RATES,
             .formats = MSM8X16_WCD_FORMATS,
             .rate_max = ,
             .rate_min = ,
             .channels_min = ,
             .channels_max = ,
         },
         .ops = &msm8x16_wcd_dai_ops,
     },
 };

4、snd_soc_register_codec函数分析：

首先，它申请了一个snd_soc_codec结构的实例：

 

 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);

确定codec的名字，这个名字很重要，Machine驱动定义的snd_soc_dai_link中会指定每个link的codec和dai的名字，进行匹配绑定时就是通过和这里的名字比较，从而找到该Codec的！

 codec->name = fmt_single_name(dev, &codec->id);

然后初始化它的各个字段，多数字段的值来自上面定义的snd_soc_codec_driver的实例：

     codec->write = codec_drv->write;
     codec->read = codec_drv->read;
     codec->volatile_register = codec_drv->volatile_register;
     codec->readable_register = codec_drv->readable_register;
     codec->writable_register = codec_drv->writable_register;
     codec->ignore_pmdown_time = codec_drv->ignore_pmdown_time;
     codec->dapm.bias_level = SND_SOC_BIAS_OFF;
     codec->dapm.dev = dev;
     codec->dapm.codec = codec;
     codec->dapm.seq_notifier = codec_drv->seq_notifier;
     codec->dapm.stream_event = codec_drv->stream_event;
     codec->dev = dev;
     codec->driver = codec_drv;
     codec->num_dai = num_dai;

在做了一些寄存器缓存的初始化和配置工作后，通过snd_soc_register_dais函数对本Codec的dai进行注册：

 /* register any DAIs */
 ret = snd_soc_register_dais(dev, dai_drv, num_dai);
 if (ret < ) {
         dev_err(codec->dev, "ASoC: Failed to regster DAIs: %d\n", ret);
         goto fail_codec_name;
 }

它把codec实例链接到全局链表codec_list中：

 mutex_lock(&client_mutex);
 list_add(&codec->list, &codec_list);
 mutex_unlock(&client_mutex);

并且调用snd_soc_instantiate_cards对machine驱动进行一次匹配绑定的操作；

至此，codec的注册就分析完毕。

关于codec侧驱动总结:

1.   分配名字为"codec_name"的平台驱动，注册。
2.   定义struct snd_soc_codec_driver结构，设置，初始化。

3.   定义struct snd_soc_dai_driver结构，设置，初始化。

4.   调用snd_soc_register_codec函数注册codec。