Rockchip RK3399 - Machine驱动（simple-card）

rt5651_card: rt5651-sound {
    status = "okay";
    compatible = "simple-audio-card";
    pinctrl-names = "default";
    pinctrl-0 = <&hp_det>;

    simple-audio-card,name = "realtek,rt5651-codec";
    simple-audio-card,format = "i2s";
    simple-audio-card,mclk-fs = <256>;
    simple-audio-card,hp-det-gpio = <&gpio4 28 GPIO_ACTIVE_HIGH>;

    simple-audio-card,widgets =
        "Microphone", "Mic Jack",
        "Headphone", "Headphones";
    simple-audio-card,routing =
        "Mic Jack", "micbias1",
        "IN2P", "Mic Jack",
　　　　 "IN2N", "Mic Jack",
        "Headphones", "HPOL",
        "Headphones", "HPOR";

    simple-audio-card,cpu {
        sound-dai = <&i2s0>;
    };
    simple-audio-card,codec {
        sound-dai = <&rt5651>;
    };
};

SND_SOC_DAPM_MIC("Microphone", NULL),

SND_SOC_DAPM_HP("Headphone", NULL)

SND_SOC_DAPM_SUPPLY("micbias1", RT5651_PWR_ANLG2,   // ALC5651电源控制寄存器4 地址0x64
                RT5651_PWR_MB1_BIT, 0, NULL, 0)     // 位11用于MICBIAS1 Power Control电源控制，0：下电  1上电

SND_SOC_DAPM_INPUT("IN2P") // IN2P为ALC5651麦克风2输入引脚

SND_SOC_DAPM_INPUT("IN2N") // IN2N为ALC5651麦克风2输入引脚

SND_SOC_DAPM_OUTPUT("HPOL")    // HPOL为ALC5651耳机输出引脚

SND_SOC_DAPM_OUTPUT("HPOR")    // HPOR为ALC5651耳机输出引脚

headphone {
        hp_det: hp-det {
                rockchip,pins =
                        <4 RK_PD4 RK_FUNC_GPIO &pcfg_pull_up>;
        };
};

static const struct of_device_id simple_of_match[] = {  // 用于匹配设备树
        { .compatible = "simple-audio-card", },
        { .compatible = "simple-scu-audio-card",
          .data = (void *)DPCM_SELECTABLE },
        {},
};
MODULE_DEVICE_TABLE(of, simple_of_match);

static struct platform_driver asoc_simple_card = {
        .driver = {
                .name = "asoc-simple-card",
                .pm = &snd_soc_pm_ops,
                .of_match_table = simple_of_match,
        },
        .probe = asoc_simple_probe,
        .remove = asoc_simple_remove,
};

module_platform_driver(asoc_simple_card);  // 注册平台驱动asoc_simple_card

static int asoc_simple_probe(struct platform_device *pdev)
{
        struct asoc_simple_priv *priv;
        struct device *dev = &pdev->dev;
        struct device_node *np = dev->of_node;
        struct snd_soc_card *card;
        struct link_info *li;
        int ret;

        /* Allocate the private data and the DAI link array */
        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);  // 动态分配struct asoc_simple_priv数据结构
        if (!priv)
                return -ENOMEM;

        card = simple_priv_to_card(priv);            // 获取成员变量&priv->snd_card
        card->owner             = THIS_MODULE;
        card->dev               = dev;               // 设置dev，为平台设备的device
        card->probe             = simple_soc_probe;  // 设置probe 该函数会解析设备属性"simple-audio-card,hp-det-gpio"，并为之申请GPIO中断
                                                     // 并在中断处理函数中检测耳机是插入还是拔出，根据判断结果调用snd_soc_jack_report向上层汇报EV_KEY、EV_SW事件                            
        card->driver_name       = "simple-card";     // 设置驱动名称

        li = devm_kzalloc(dev, sizeof(*li), GFP_KERNEL);     // 动态分配struct link_info数据结构，用于保存音频数据链路信息
        if (!li)
                return -ENOMEM;

        ret = simple_get_dais_count(priv, li);  //  解析rt5651-sound设备节点中音频数据链路相关节点，获取每条音频数据链路cpu、codec、platfrom的数量
        if (ret < 0)
                return ret;

        if (!li->link)
                return -EINVAL;

        ret = asoc_simple_init_priv(priv, li);  // 根据每个音频数据链路中的cpu数量、codec数量、platfom数量来初始化priv的成员
        if (ret < 0)
                return ret;

        if (np && of_device_is_available(np)) {   // 使用设备树，走这里
                ret = simple_parse_of(priv, li);   // 解析rt5651-sound设备节点的属性信息
                if (ret < 0) {
                        dev_err_probe(dev, ret, "parse error\n");
                        goto err;
                }

        } else {   // 没有使用设备树
                struct asoc_simple_card_info *cinfo;
                struct snd_soc_dai_link_component *cpus;
                struct snd_soc_dai_link_component *codecs;
                struct snd_soc_dai_link_component *platform;
                struct snd_soc_dai_link *dai_link = priv->dai_link;
                struct simple_dai_props *dai_props = priv->dai_props;

                cinfo = dev->platform_data;
                if (!cinfo) {
                        dev_err(dev, "no info for asoc-simple-card\n");
                        return -EINVAL;
                }
                if (!cinfo->name ||
                    !cinfo->codec_dai.name ||
                    !cinfo->codec ||
                    !cinfo->platform ||
                    !cinfo->cpu_dai.name) {
                        dev_err(dev, "insufficient asoc_simple_card_info settings\n");
                        return -EINVAL;
                }

                cpus                    = dai_link->cpus;
                cpus->dai_name          = cinfo->cpu_dai.name;

                codecs                  = dai_link->codecs;
                codecs->name            = cinfo->codec;
                codecs->dai_name        = cinfo->codec_dai.name;

                platform                = dai_link->platforms;
                platform->name          = cinfo->platform;

                card->name              = (cinfo->card) ? cinfo->card : cinfo->name;
                dai_link->name          = cinfo->name;
                dai_link->stream_name   = cinfo->name;
                dai_link->dai_fmt       = cinfo->daifmt;
                dai_link->init          = asoc_simple_dai_init;
                memcpy(dai_props->cpu_dai, &cinfo->cpu_dai,
                                        sizeof(*dai_props->cpu_dai));
                memcpy(dai_props->codec_dai, &cinfo->codec_dai,
                                        sizeof(*dai_props->codec_dai));
        }

        snd_soc_card_set_drvdata(card, priv);   // 设置snd_soc_card的私有数据drvdata为priv

        asoc_simple_debug_info(priv);  // 输出调试信息

        ret = devm_snd_soc_register_card(dev, card);  // 注册ASoC声卡设备
        if (ret < 0)
                goto err;

        devm_kfree(dev, li);
        return 0;
err:
        asoc_simple_clean_reference(card);

        return ret;
}

/* A Minimal ASoC Sound Card - Single DAI Link */
struct asoc_simple_card_info cinfo = {
        .name = "rochchip-i2s-rt5651",
        .card = "realtek,rt5651-codec",
        .codec = "rt5651",
        .platform = NULL,
        .daifmt = 1,
　　　　 .cpu_dai = {
　　　　　　.name = "rochchip-i2s",
          .sysclk = xxxx,
        }
        .codec_dai = {
　　　　　　.name = "rt5651",
          .sysclk = xxxx,
　　　　}
};

/* A Minimal ASoC Sound Card - Single DAI Link */
struct snd_soc_dai_link dai_link = {
        .name = "rockchip-i2s-rt5651",
        .stream_name = "rockchip-i2s-rt5651",
        .dai_fmt = 1,
        .init = asoc_simple_dai_init,
        .cpus = {
　　　　　　 .dai_name = "rockchip-i2s",  // 用于匹配component dai_list链表中的dai 
　　　　　},
        .num_cpus = 1, 
        .codec = {
           .name = "rt5651",        // 用于匹配全局链表component_list中的component
 　　　　　　.dai_name = "rt5651",    // 用于匹配component dai_list链表中的dai  
　　　　 },
        .num_codecs = 1,
        .platform = {
           .name = NULL, 
 　　　　}
        .num_platforms = 1,
        .ops = simple_ops,
};

struct snd_soc_card card = {
        .name = "realtek,rt5651-codec",
        .dai_link = &dai_link,
        .num_links = 1,
        .num_dapm_widgets = 2,
        .dapm_widgers = xxx,
        .num_dapm_routes = 4,
        .dapm_routes = xxx,
};

snd_soc_register_card(&card);

struct asoc_simple_priv {
        struct snd_soc_card snd_card;
        struct simple_dai_props {  // 每个成员，代表一个音频数据链路，用于描述每个音频链路上所有属性
                struct asoc_simple_dai *cpu_dai;          // 存储当前链路上所有的cpu_dai  指向一个数组，数组长度由num.cpus决定
                struct asoc_simple_dai *codec_dai;        // 存储当前链路上所有的codec_dai 指向一个数组，数组长度由num.codecs决定
                struct snd_soc_dai_link_component *cpus;  // 存储当前链路上所有的cpu设备 指向一个数组，数组长度由num.cpus决定
                struct snd_soc_dai_link_component *codecs;     // 存储当前链路上的所有codec设备 指向一个数组，数组长度由num.codecss决定
                struct snd_soc_dai_link_component *platforms;  // 存储当前链路上所有的platform设备 指向一个数组，数组长度由num.platforms决定
                struct asoc_simple_data adata;
                struct snd_soc_codec_conf *codec_conf;   // 这个我们不会使用
                struct prop_nums num;   // 保存当前音频数据链路的cpu、codec、platform数量
                unsigned int mclk_fs;   // MCLK频率 存放simple-audio-card,mclk-fs属性的值
        } *dai_props;
        struct asoc_simple_jack hp_jack;
        struct asoc_simple_jack mic_jack;
        struct snd_soc_jack *aux_jacks;
        struct snd_soc_dai_link *dai_link;
        struct asoc_simple_dai *dais;
        struct snd_soc_dai_link_component *dlcs;
        struct snd_soc_dai_link_component dummy;
        struct snd_soc_codec_conf *codec_conf;
        struct gpio_desc *pa_gpio;
        const struct snd_soc_ops *ops;
        unsigned int dpcm_selectable:1;
        unsigned int force_dpcm:1;
};

struct link_info {
        int link; /* number of link */
        int cpu;  /* turn for CPU / Codec */
        struct prop_nums num[SNDRV_MAX_LINKS];
};

struct prop_nums {
        int cpus;
        int codecs;
        int platforms;
};

#define simple_priv_to_card(priv)       (&(priv)->snd_card)

    simple-audio-card,cpu {
        sound-dai = <&i2s0>;
    };
    simple-audio-card,codec {
        sound-dai = <&rt5651>;
    };

simple-audio-card,dai-link@0 {
        format = "i2s";
        cpu {
                sound-dai = <&i2s0>;
        };

        codec {
                sound-dai = <&rt5651>;
        };
};

simple-audio-card,dai-link@1 {
        format = "i2s2";
        cpu {
                sound-dai = <&i2s>;
        };

        codec {
                sound-dai = <&hdmi>;
        };
};

static int simple_for_each_link(struct asoc_simple_priv *priv,
                                struct link_info *li,
                                int (*func_noml)(struct asoc_simple_priv *priv,
                                                 struct device_node *np,
                                                 struct device_node *codec,
                                                 struct link_info *li, bool is_top),
                                int (*func_dpcm)(struct asoc_simple_priv *priv,
                                                 struct device_node *np,
                                                 struct device_node *codec,
                                                 struct link_info *li, bool is_top))
{
        int ret;
        /*
         * Detect all CPU first, and Detect all Codec 2nd.
         *
         * In Normal sound case, all DAIs are detected
         * as "CPU-Codec".
         *
         * In DPCM sound case,
         * all CPUs   are detected as "CPU-dummy", and
         * all Codecs are detected as "dummy-Codec".
         * To avoid random sub-device numbering,
         * detect "dummy-Codec" in last;
         */
        for (li->cpu = 1; li->cpu >= 0; li->cpu--) {  // 设置li->cpu=1、0，然后执行__simple_for_each_link函数
                ret = __simple_for_each_link(priv, li, func_noml, func_dpcm);
                if (ret < 0)
                        break;
        }

        return ret;
}

static int simple_count_noml(struct asoc_simple_priv *priv,
                             struct device_node *np,
                             struct device_node *codec,
                             struct link_info *li, bool is_top)
{
        if (li->link >= SNDRV_MAX_LINKS) {  // 链路数已经达到上限  
                struct device *dev = simple_priv_to_dev(priv);

                dev_err(dev, "too many links\n");
                return -EINVAL;
        }

        li->num[li->link].cpus          = 1;   // cpu数量
        li->num[li->link].codecs        = 1;   // codec数量
        li->num[li->link].platforms     = 1;   // platform数量 

        li->link += 1;   // 音频数据链路计数+1

        return 0;
}

static int simple_parse_of(struct asoc_simple_priv *priv, struct link_info *li)
{
        struct snd_soc_card *card = simple_priv_to_card(priv);
        int ret;

        ret = asoc_simple_parse_widgets(card, PREFIX);
        if (ret < 0)
                return ret;

        ret = asoc_simple_parse_routing(card, PREFIX);
        if (ret < 0)
                return ret;

        ret = asoc_simple_parse_pin_switches(card, PREFIX);
        if (ret < 0)
                return ret;

        /* Single/Muti DAI link(s) & New style of DT node */
        memset(li, 0, sizeof(*li));
        ret = simple_for_each_link(priv, li,
                                   simple_dai_link_of,
                                   simple_dai_link_of_dpcm);
        if (ret < 0)
                return ret;

        ret = asoc_simple_parse_card_name(card, PREFIX);
        if (ret < 0)
                return ret;

        ret = snd_soc_of_parse_aux_devs(card, PREFIX "aux-devs");

        return ret;
}

simple-audio-card,widgets =
    "Microphone", "Mic Jack",
    "Headphone", "Headphones";

int asoc_simple_parse_widgets(struct snd_soc_card *card,
                              char *prefix)    // "simple-audio-card,"
{
        struct device_node *node = card->dev->of_node;    // 获取平台设备的设备节点，即rt5651-sound
        char prop[128];

        if (!prefix)
                prefix = "";

        snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets"); // simple-audio-card,widgets

        if (of_property_read_bool(node, prop))  // 如果该属性存在，进入
                return snd_soc_of_parse_audio_simple_widgets(card, prop);

        /* no widgets is not error */
        return 0;
}

static const struct snd_soc_dapm_widget simple_widgets[] = {
        SND_SOC_DAPM_MIC("Microphone", NULL),
        SND_SOC_DAPM_LINE("Line", NULL),
        SND_SOC_DAPM_HP("Headphone", NULL),
        SND_SOC_DAPM_SPK("Speaker", NULL),
};

simple-audio-card,routing =
    "Mic Jack", "micbias1",
    "IN2P", "Mic Jack",
    "IN2N"，"Mic Jack", 
    "Headphones", "HPOL",
    "Headphones", "HPOR";

int asoc_simple_parse_routing(struct snd_soc_card *card,
                              char *prefix)
{
        struct device_node *node = card->dev->of_node;  // 获取平台设备的设备节点，即rt5651-sound
        char prop[128];

        if (!prefix)
                prefix = "";

        snprintf(prop, sizeof(prop), "%s%s", prefix, "routing");  // simple-audio-card,routing

        if (!of_property_read_bool(node, prop))  // 如果属性不存在，则进入
                return 0;

        return snd_soc_of_parse_audio_routing(card, prop);
}

simple-audio-card,pin-switches = "Speaker";

int asoc_simple_parse_pin_switches(struct snd_soc_card *card,
                                   char *prefix)
{
        char prop[128];

        if (!prefix)
                prefix = "";

        snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches");

        return snd_soc_of_parse_pin_switches(card, prop);
}

static int simple_dai_link_of(struct asoc_simple_priv *priv,
                              struct device_node *np,    // 为simple-audio-card,cpu设备节点，即{sound-dai = <&i2s0>;};
                              struct device_node *codec, // 为simple-audio-card,codec设备节点，即{sound-dai = <&rt5651>;};
                              struct link_info *li,      // 音频数据链路信息 此时该数据结构内存全部被设置为了0
                              bool is_top)   // 1
{
        struct device *dev = simple_priv_to_dev(priv);  // 获取&priv->snd_card.dev，即获取平台设备的device
        struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);      //  获取成员变量priv->dai_link[li->link]  获取第0个音频数据链路
        struct snd_soc_dai_link_component *cpus = asoc_link_to_cpu(dai_link, 0);      // 获取当前链路上第0个cpu设备&(dai_link)->cpus[0]
        struct snd_soc_dai_link_component *codecs = asoc_link_to_codec(dai_link, 0);  // 获取当前链路上第0个的codec设备 &(dai_link)->codecs[0]
        struct snd_soc_dai_link_component *platforms = asoc_link_to_platform(dai_link, 0); // 获取当前链路上第0个的platform设备 &(dai_link)->platforms[0]
        struct device_node *cpu = NULL;
        struct device_node *node = NULL;
        struct device_node *plat = NULL;
        char dai_name[64];
        char prop[128];
        char *prefix = "";
        int ret, single_cpu = 0;

        cpu  = np;                  // 设置为simple-audio-card,cpu设备节点
        node = of_get_parent(np);   // 获取父设备节点，即rt5651-sound设备节点

        dev_dbg(dev, "link_of (%pOF)\n", node);

        /* For single DAI link & old style of DT node */
        if (is_top)
                prefix = PREFIX;  // prefix = "simple-audio-card,"

        snprintf(prop, sizeof(prop), "%splat", prefix);  // "simple-audio-card,plat"
        plat = of_get_child_by_name(node, prop);   // 未定义该设备节点，所以返回NULL

        ret = simple_parse_node(priv, cpu, li, prefix, &single_cpu);  // 这个函数很重要，单独介绍，主要目的解析simple-audio-card,cpu设备节点
        if (ret < 0)
                goto dai_link_of_err;

        ret = simple_parse_node(priv, codec, li, prefix, NULL);    // 这个函数很重要，单独介绍，主要目的simple-audio-card,codec设备节点
        if (ret < 0)
                goto dai_link_of_err;

        ret = asoc_simple_parse_platform(plat, platforms);  // 直接返回，忽略即可
        if (ret < 0)
                goto dai_link_of_err;

        snprintf(dai_name, sizeof(dai_name),
                 "%s-%s", cpus->dai_name, codecs->dai_name); 

        asoc_simple_canonicalize_cpu(cpus, single_cpu);
        asoc_simple_canonicalize_platform(platforms, cpus);

        ret = simple_link_init(priv, node, codec, li, prefix, dai_name); // 初始化音频数据链路snd_soc_dai_link的部分成员

dai_link_of_err:
        of_node_put(plat);
        of_node_put(node);

        li->link++; // 自增

        return ret;
}

int asoc_simple_parse_card_name(struct snd_soc_card *card,
                                char *prefix)
{
        int ret;

        if (!prefix)
                prefix = "";

        /* Parse the card name from DT */
        ret = snd_soc_of_parse_card_name(card, "label");  // 获取rt5651-sound设备节点label属性
        if (ret < 0 || !card->name) {  // 属性不存在
                char prop[128];

                snprintf(prop, sizeof(prop), "%sname", prefix);  // simple-audio-card,name
                ret = snd_soc_of_parse_card_name(card, prop);    // 获取rt5651-sound设备节点simple-audio-card,name属性值"realtek,rt5651-codec"，保存到card->name
                if (ret < 0)
                        return ret;
        }

        if (!card->name && card->dai_link)
                card->name = card->dai_link->name;

        return 0;
}

int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname)  // "simple-audio-card,aux-devs"
{
        struct device_node *node = card->dev->of_node;
        struct snd_soc_aux_dev *aux;
        int num, i;

        num = of_count_phandle_with_args(node, propname, NULL); //  根据属性名和参数的要求，统计节点中符合条件的 phandle 的数量  这里找不到匹配的属性，返回负数
        if (num == -ENOENT) {
                return 0;
        } else if (num < 0) {
                dev_err(card->dev, "ASOC: Property '%s' could not be read: %d\n",
                        propname, num);
                return num;
        }

        aux = devm_kcalloc(card->dev, num, sizeof(*aux), GFP_KERNEL);  // 动态分配数组，每个元素都是一个struct snd_soc_aux_dev
        if (!aux)
                return -ENOMEM;
        card->aux_dev = aux;
        card->num_aux_devs = num;

        for_each_card_pre_auxs(card, i, aux) {
                aux->dlc.of_node = of_parse_phandle(node, propname, i);
                if (!aux->dlc.of_node)
                        return -EINVAL;
        }
}

/* device driver data */
static inline void snd_soc_card_set_drvdata(struct snd_soc_card *card,
                                            void *data)
{
        card->drvdata = data;
}

static inline void asoc_simple_debug_info(struct asoc_simple_priv *priv)
{
        struct snd_soc_card *card = simple_priv_to_card(priv);
        struct device *dev = simple_priv_to_dev(priv);

        int i;

        if (card->name)
                dev_dbg(dev, "Card Name: %s\n", card->name);

        for (i = 0; i < card->num_links; i++) {   // 遍历每一个音频数据链路
                struct simple_dai_props *props = simple_priv_to_props(priv, i);   // 获取priv->dai_props[i]
                struct snd_soc_dai_link *link = simple_priv_to_link(priv, i);     // 获取成员变量priv->dai_link[i]
                struct asoc_simple_dai *dai;
                struct snd_soc_codec_conf *cnf;
                int j;

                dev_dbg(dev, "DAI%d\n", i);

                dev_dbg(dev, "cpu num = %d\n", link->num_cpus);
                for_each_prop_dai_cpu(props, j, dai)     // 遍历当前链路上每一个cpu_dai
                        asoc_simple_debug_dai(priv, "cpu", dai);        // 输出dai各个字段信息
                dev_dbg(dev, "codec num = %d\n", link->num_codecs);
                for_each_prop_dai_codec(props, j, dai)    // 遍历当前链路上每一个codec_dai
                        asoc_simple_debug_dai(priv, "codec", dai);       // 输出dai各个字段信息

                if (link->name)
                        dev_dbg(dev, "dai name = %s\n", link->name);
                if (link->dai_fmt)
                        dev_dbg(dev, "dai format = %04x\n", link->dai_fmt);
                if (props->adata.convert_rate)
                        dev_dbg(dev, "convert_rate = %d\n", props->adata.convert_rate);
                if (props->adata.convert_channels)
                        dev_dbg(dev, "convert_channels = %d\n", props->adata.convert_channels);
                for_each_prop_codec_conf(props, j, cnf)
                        if (cnf->name_prefix)
                                dev_dbg(dev, "name prefix = %s\n", cnf->name_prefix);
                if (props->mclk_fs)
                        dev_dbg(dev, "mclk-fs = %d\n", props->mclk_fs);
        }
}

/**
 * devm_snd_soc_register_card - resource managed card registration
 * @dev: Device used to manage card
 * @card: Card to register
 *
 * Register a card with automatic unregistration when the device is
 * unregistered.
 */
int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card)
{
        struct snd_soc_card **ptr;
        int ret;

        ptr = devres_alloc(devm_card_release, sizeof(*ptr), GFP_KERNEL);   // 动态分配内存，指向struct *snd_soc_card，在设备释放时自动调用devm_card_release函数
        if (!ptr)
                return -ENOMEM;

        ret = snd_soc_register_card(card);  // 注册ASoC声卡设备
        if (ret == 0) {                     // 注册成功，则将声卡指针存储到之前分配的指针中，并通过devres_add函数将指针添加到设备的资源列表中；
                                            // 这样，当设备注销时，资源管理机制会自动调用释放函数，从而卸载声卡。
                *ptr = card;
                devres_add(dev, ptr);
        } else {
                devres_free(ptr);
        }

        return ret;
}

static int simple_parse_node(struct asoc_simple_priv *priv,
                             struct device_node *np,   //simple-audio-card,cpu设备节点、或simple-audio-card,codec设备节点
                             struct link_info *li,
                             char *prefix, // simple-audio-card,
                             int *cpu)
{
        struct device *dev = simple_priv_to_dev(priv);            // 获取&priv->snd_card.dev，即获取平台设备的device
        struct device_node *top = dev->of_node;                   // rt5651-sound设备节点
        struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);       //  获取成员变量priv->dai_link[li->link]  即获取第0个音频数据链路
        struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);     //  获取priv->dai_props[li->link] 即获取第0个音频数据链路上的属性
        struct snd_soc_dai_link_component *dlc;                   // 存放音频链路中的设备
        struct asoc_simple_dai *dai;
        int ret;

        if (cpu) { // np如果是simple-audio-card,cpu设备节点
                dlc = asoc_link_to_cpu(dai_link, 0);                // 获取dai_link链路上第0个cpu设备&(dai_link)->cpus[0]
                dai = simple_props_to_dai_cpu(dai_props, 0);        // dai_props->cpu_dai[0] 
        } else {  // np如果是imple-audio-card,codec设备节点
                dlc = asoc_link_to_codec(dai_link, 0);             // 获取dai_link链路上第0个codec设备&(dai_link)->codec[0]
                dai = simple_props_to_dai_codec(dai_props, 0);     // dai_props->codec_dai[0] 
        }

        simple_parse_mclk_fs(top, np, dai_props, prefix);  // 从设备节点解析simple-audio-card,mclk-fs属性的值，保存到dai_props->mclk_fs

        ret = asoc_simple_parse_dai(np, dlc, cpu);         // 解析设备节点np，初始化dlc成员of_node、dai_name
        if (ret)
                return ret;

        ret = asoc_simple_parse_clk(dev, np, dai, dlc);   // 解析i2s0或者rt5651设备节点获取时钟，初始化dai->sysclk
        if (ret)
                return ret;

        ret = asoc_simple_parse_tdm(np, dai);
        if (ret)
                return ret;

        return 0;
}

static void simple_parse_mclk_fs(struct device_node *top,    // rt5651-sound设备节点 
                                 struct device_node *np,     //simple-audio-card,cpu设备节点、或simple-audio-card,codec设备节点
                                 struct simple_dai_props *props,  // 第0个音频数据链路上的属性
                                 char *prefix)                    // simple-audio-card,
{ 
        struct device_node *node = of_get_parent(np); // rt5651-sound设备节点 
        char prop[128];

        snprintf(prop, sizeof(prop), "%smclk-fs", PREFIX);    // simple-audio-card,mclk-fs
        of_property_read_u32(top,       prop, &props->mclk_fs);  // 获取top节点simple-audio-card,mclk-fs属性的值，保存到props->mclk_fs

        snprintf(prop, sizeof(prop), "%smclk-fs", prefix);     // simple-audio-card,mclk-fs
        of_property_read_u32(node,      prop, &props->mclk_fs);  // 获取node节点simple-audio-card,mclk-fs属性的值，保存到props->mclk_fs
        of_property_read_u32(np,        prop, &props->mclk_fs);  // np不存在simple-audio-card,mclk-fs属性

        of_node_put(node);
}

static int asoc_simple_parse_dai(struct device_node *node,   //simple-audio-card,cpu设备节点、或simple-audio-card,codec设备节点
                                 struct snd_soc_dai_link_component *dlc, // 音频数据链路中的设备
                                 int *is_single_link)
{
        struct of_phandle_args args;
        int ret;

        if (!node)
                return 0;

        /*
         * Get node via "sound-dai = <&phandle port>"
         * it will be used as xxx_of_node on soc_bind_dai_link()
         */
        ret = of_parse_phandle_with_args(node, DAI, CELL, 0, &args); // 如果是simple-audio-card,cpu设备节点，DAI为"sound-dai"，CELL为"#sound-dai-cells", 
                                                                     // 即获取phandle列表中的第0个元素i2s0
        if (ret)
                return ret;

        /*
         * FIXME
         *
         * Here, dlc->dai_name is pointer to CPU/Codec DAI name.
         * If user unbinded CPU or Codec driver, but not for Sound Card,
         * dlc->dai_name is keeping unbinded CPU or Codec
         * driver's pointer.
         *
         * If user re-bind CPU or Codec driver again, ALSA SoC will try
         * to rebind Card via snd_soc_try_rebind_card(), but because of
         * above reason, it might can't bind Sound Card.
         * Because Sound Card is pointing to released dai_name pointer.
         *
         * To avoid this rebind Card issue,
         * 1) It needs to alloc memory to keep dai_name eventhough
         *    CPU or Codec driver was unbinded, or
         * 2) user need to rebind Sound Card everytime
         *    if he unbinded CPU or Codec.
         */
        ret = snd_soc_of_get_dai_name(node, &dlc->dai_name); // 设置dlc->dai_name，以为例simple-audio-card,codec {sound-dai = <&rt5651>;};
                                                             // 查找rt5651设备节点所属的component，遍历其dai_list链表，设置dai_name为其中某一个dai的名称   

        if (ret < 0)
                return ret;

        dlc->of_node = args.np;    // 设置成员of_node，指向i2s0设备节点

        if (is_single_link)
                *is_single_link = !args.args_count;

        return 0;
}

int asoc_simple_parse_clk(struct device *dev,        // 平台设备的device
                          struct device_node *node,  // simple-audio-card,cpu设备节点、或simple-audio-card,codec设备节点
                          struct asoc_simple_dai *simple_dai,
                          struct snd_soc_dai_link_component *dlc) // 音频链路中的设备
{
        struct clk *clk;
        u32 val;

        /*
         * Parse dai->sysclk come from "clocks = <&xxx>"
         * (if system has common clock)
         *  or "system-clock-frequency = <xxx>"
         *  or device's module clock.
         */
        clk = devm_get_clk_from_child(dev, node, NULL);
        simple_dai->clk_fixed = of_property_read_bool(
                node, "system-clock-fixed");
        if (!IS_ERR(clk)) {
                simple_dai->sysclk = clk_get_rate(clk);

                simple_dai->clk = clk;
        } else if (!of_property_read_u32(node, "system-clock-frequency", &val)) {
                simple_dai->sysclk = val;
                simple_dai->clk_fixed = true;
        } else {  // 走这里
                clk = devm_get_clk_from_child(dev, dlc->of_node, NULL);   // 获取i2s0设备节点的时钟
                if (!IS_ERR(clk))
                        simple_dai->sysclk = clk_get_rate(clk);  // 获取clk的频率
        }

        if (of_property_read_bool(node, "system-clock-direction-out"))
                simple_dai->clk_direction = SND_SOC_CLOCK_OUT;

        return 0;
}

static int simple_link_init(struct asoc_simple_priv *priv,
                            struct device_node *node,     // rt5651-sound设备节点
                            struct device_node *codec,    // simple-audio-card,codec设备节点，即{sound-dai = <&rt5651>;};
                            struct link_info *li,         // 音频数据链路信息 此时该数据结构内存全部被设置为了0
                            char *prefix, char *name)     // "simple-audio-card,"   "rockchip-i2s-rt5651"    
{
        struct device *dev = simple_priv_to_dev(priv);       // 获取&priv->snd_card.dev，即获取平台设备的device
        struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);  //  获取成员变量priv->dai_link[li->link]  即获取第0个音频数据链路
        int ret;

        ret = asoc_simple_parse_daifmt(dev, node, codec,
                                       prefix, &dai_link->dai_fmt);  // 解析设备节点simple-audio-card,format属性，获取数字音频接口格式保存到dai_link->dai_fmt
        if (ret < 0)
                return 0;

        dai_link->init                  = asoc_simple_dai_init;      // 初始化函数
        dai_link->ops                   = &simple_ops;               // 音频相关的操作集

        return asoc_simple_set_dailink_name(dev, dai_link, name);  // 设置dai_link成员name、stream_name
}

int asoc_simple_parse_daifmt(struct device *dev,
                             struct device_node *node,   // rt5651-sound设备节点
                             struct device_node *codec,
                             char *prefix,
                             unsigned int *retfmt)
{
        struct device_node *bitclkmaster = NULL;
        struct device_node *framemaster = NULL;
        unsigned int daifmt;

        daifmt = snd_soc_daifmt_parse_format(node, prefix);  // 解析simple-audio-card,format属性，获取i2s接口对应的数值1

        snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster); // 解析simple-audio-card,bitclock-master、simple-audio-card,frame-master属性，这俩属性我们都未使用
        if (!bitclkmaster && !framemaster) {  // 走这里
                /*
                 * No dai-link level and master setting was not found from
                 * sound node level, revert back to legacy DT parsing and
                 * take the settings from codec node.
                 */
                dev_dbg(dev, "Revert to legacy daifmt parsing\n");

                daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL);
        } else {
                daifmt |= snd_soc_daifmt_clock_provider_from_bitmap(
                                ((codec == bitclkmaster) << 4) | (codec == framemaster));
        }

        of_node_put(bitclkmaster);
        of_node_put(framemaster);

        *retfmt = daifmt;

        return 0;
}

/* DAI physical PCM data formats.
 * Add new formats to the end of the list.
 */
#define SND_SOC_DAI_FORMAT_I2S          1 /* I2S mode */
#define SND_SOC_DAI_FORMAT_RIGHT_J      2 /* Right Justified mode */
#define SND_SOC_DAI_FORMAT_LEFT_J       3 /* Left Justified mode */
#define SND_SOC_DAI_FORMAT_DSP_A        4 /* L data MSB after FRM LRC */
#define SND_SOC_DAI_FORMAT_DSP_B        5 /* L data MSB during FRM LRC */
#define SND_SOC_DAI_FORMAT_AC97         6 /* AC97 */
#define SND_SOC_DAI_FORMAT_PDM          7 /* Pulse density modulation */

/* left and right justified also known as MSB and LSB respectively */
#define SND_SOC_DAI_FORMAT_MSB          SND_SOC_DAI_FORMAT_LEFT_J
#define SND_SOC_DAI_FORMAT_LSB          SND_SOC_DAI_FORMAT_RIGHT_J

int asoc_simple_dai_init(struct snd_soc_pcm_runtime *rtd)
{
        struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
        struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);  //   获取priv->dai_props[rtd->num] 即获取第rtd->num个音频数据链路上的属性
        struct asoc_simple_dai *dai;
        int i, ret;

        for_each_prop_dai_codec(props, i, dai) {  // 遍历音频数据链路上的codec_dai，即dai = props->codec_dai[i]
                ret = asoc_simple_init_dai(asoc_rtd_to_codec(rtd, i), dai);    // (rtd)->dais[i + (rtd)->dai_link->num_cpus],接着作为参数传递给asoc_simple_init_dai函数
                if (ret < 0)
                        return ret;
        }
        for_each_prop_dai_cpu(props, i, dai) {    // 遍历音频数据链路上的cpu_dai，即dai = props->cpu_dai[i]
                ret = asoc_simple_init_dai(asoc_rtd_to_cpu(rtd, i), dai);     // (rtd)->dais[i]，接着作为参数传递给asoc_simple_init_dai函数
                if (ret < 0)
                        return ret;
        }

        ret = asoc_simple_init_for_codec2codec(rtd, props);
        if (ret < 0)
                return ret;

        return 0;
}

static int asoc_simple_init_dai(struct snd_soc_dai *dai,
                                     struct asoc_simple_dai *simple_dai)
{
        int ret;

        if (!simple_dai)
                return 0;

        if (simple_dai->sysclk) {        // 已经在asoc_simple_parse_clk函数中初始化
                ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk,
                                             simple_dai->clk_direction);
                if (ret && ret != -ENOTSUPP) {
                        dev_err(dai->dev, "simple-card: set_sysclk error\n");
                        return ret;
                }
        }

        if (simple_dai->slots) {  // 不会进入
                ret = snd_soc_dai_set_tdm_slot(dai,
                                               simple_dai->tx_slot_mask,
                                               simple_dai->rx_slot_mask,
                                               simple_dai->slots,
                                               simple_dai->slot_width);
                if (ret && ret != -ENOTSUPP) {
                        dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
                        return ret;
                }
        }

        return 0;
}

/**
 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
 * @dai: DAI
 * @clk_id: DAI specific clock ID
 * @freq: new clock frequency in Hz
 * @dir: new clock direction - input/output.
 *
 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
 */
int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
                           unsigned int freq, int dir)
{
        int ret;

        if (dai->driver->ops &&
            dai->driver->ops->set_sysclk)
                ret = dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
        else
                ret = snd_soc_component_set_sysclk(dai->component, clk_id, 0,
                                                   freq, dir);

        return soc_dai_ret(dai, ret);
}

static const struct snd_soc_ops simple_ops = {
        .startup        = asoc_simple_startup,
        .shutdown       = asoc_simple_shutdown,
        .hw_params      = asoc_simple_hw_params,
};

int asoc_simple_startup(struct snd_pcm_substream *substream)
{
        struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
        struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
        struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
        struct asoc_simple_dai *dai;
        unsigned int fixed_sysclk = 0;
        int i1, i2, i;
        int ret;

        for_each_prop_dai_cpu(props, i1, dai) {
                ret = asoc_simple_clk_enable(dai);
                if (ret)
                        goto cpu_err;
                ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
                if (ret)
                        goto cpu_err;
        }

        for_each_prop_dai_codec(props, i2, dai) {
                ret = asoc_simple_clk_enable(dai);
                if (ret)
                        goto codec_err;
                ret = asoc_simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
                if (ret)
                        goto codec_err;
        }

        if (fixed_sysclk && props->mclk_fs) {
                unsigned int fixed_rate = fixed_sysclk / props->mclk_fs;

                if (fixed_sysclk % props->mclk_fs) {
                        dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n",
                                fixed_sysclk, props->mclk_fs);
                        return -EINVAL;
                }
                ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE,
                        fixed_rate, fixed_rate);
                if (ret)
                        goto codec_err;
        }

        return 0;

codec_err:
        for_each_prop_dai_codec(props, i, dai) {
                if (i >= i2)
                        break;
                asoc_simple_clk_disable(dai);
        }
cpu_err:
        for_each_prop_dai_cpu(props, i, dai) {
                if (i >= i1)
                        break;
                asoc_simple_clk_disable(dai);
        }
        return ret;
}

void asoc_simple_shutdown(struct snd_pcm_substream *substream)
{
        struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
        struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
        struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
        struct asoc_simple_dai *dai;
        int i;

        for_each_prop_dai_cpu(props, i, dai) {
                struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, i);

                if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(cpu_dai))
                        snd_soc_dai_set_sysclk(cpu_dai,
                                               0, 0, SND_SOC_CLOCK_OUT);

                asoc_simple_clk_disable(dai);
        }
        for_each_prop_dai_codec(props, i, dai) {
                struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, i);

                if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(codec_dai))
                        snd_soc_dai_set_sysclk(codec_dai,
                                               0, 0, SND_SOC_CLOCK_IN);

                asoc_simple_clk_disable(dai);
        }
}

int asoc_simple_hw_params(struct snd_pcm_substream *substream,
                          struct snd_pcm_hw_params *params)
{
        struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
        struct asoc_simple_dai *pdai;
        struct snd_soc_dai *sdai;
        struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(rtd->card);
        struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
        unsigned int mclk, mclk_fs = 0;
        int i, ret;

        if (props->mclk_fs)
                mclk_fs = props->mclk_fs;

        if (mclk_fs) {
                struct snd_soc_component *component;
                mclk = params_rate(params) * mclk_fs;

                for_each_prop_dai_codec(props, i, pdai) {
                        ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk);
                        if (ret < 0)
                                return ret;
                }

                for_each_prop_dai_cpu(props, i, pdai) {
                        ret = asoc_simple_set_clk_rate(rtd->dev, pdai, mclk);
                        if (ret < 0)
                                return ret;
                }

                /* Ensure sysclk is set on all components in case any
                 * (such as platform components) are missed by calls to
                 * snd_soc_dai_set_sysclk.
                 */
                for_each_rtd_components(rtd, i, component) {
                        ret = snd_soc_component_set_sysclk(component, 0, 0,
                                                           mclk, SND_SOC_CLOCK_IN);
                        if (ret && ret != -ENOTSUPP)
                                return ret;
                }

                for_each_rtd_codec_dais(rtd, i, sdai) {
                        ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN);
                        if (ret && ret != -ENOTSUPP)
                                return ret;
                }

                for_each_rtd_cpu_dais(rtd, i, sdai) {
                        ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT);
                        if (ret && ret != -ENOTSUPP)
                                return ret;
                }
        }

        for_each_prop_dai_codec(props, i, pdai) {
                sdai = asoc_rtd_to_codec(rtd, i);
                ret = asoc_simple_set_tdm(sdai, pdai, params);
                if (ret < 0)
                        return ret;
        }

        for_each_prop_dai_cpu(props, i, pdai) {
                sdai = asoc_rtd_to_cpu(rtd, i);
                ret = asoc_simple_set_tdm(sdai, pdai, params);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

int asoc_simple_set_dailink_name(struct device *dev,
                                 struct snd_soc_dai_link *dai_link,
                                 const char *fmt, ...)   //   "rockchip-i2s-rt5651"
{
        va_list ap;
        char *name = NULL;
        int ret = -ENOMEM;

        va_start(ap, fmt);
        name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap);
        va_end(ap);

        if (name) {
                ret = 0;

                dai_link->name          = name;  // 设置名称
                dai_link->stream_name   = name;  // 设置流名称
        }

        return ret;
}