• Linux ALSA驱动之Platform源码分析（wm8350.c）

    1、Platform概述

            ASoC被分为Machine，Platform和Codec三大部件，Platform驱动的主要作用是完成音频数据的管理，最终通过CPU的数字音频接口（DA〉把音频数据传送给Codec进行处理，最终由Codec输出驱动耳机或者是喇叭的音频信号。在具体实现上，ASoC又把Platform驱动分为两个部分: platform_driver和snd_soc_dai_driver。其中，platform_driver负责管理音频数据，把音频数据通过dma或其他操作传送至cpudai中，dai_driver则主要完成cpu一侧的dai的参数配置，同时也会通过一定的途径把必要的dma等参数与platform_driver进行交互。

    cpu_dai_driver 部分：
            在嵌入式系统里面通常指SoC的I2S、PCM总线控制器，负责把音频数据从I2S tx FIFO搬运到CODEC（这是音频播放的情形，录制则方向相反）。cpu_dai通过snd_soc_register_dai()/devm_snd_soc_register_component()来注册。

            注：DAI是 Digital Audio Interface的简称，分为cpu_dai和codec_dai，这两者通过 I2S/PCM 总线连接，AIF 是 Audio Interface 的简称，嵌入式系统中一般是I2S和PCM接口。

    platform_driver部分：
            负责把dma buffer中的音频数据搬运到I2S tx FIFO。音频DMA驱动通过 platform_driver_register()/module_platform_driver() 来注册，故也常用platform来指代音频DMA驱动（这里的 platform 需要与 SoC Platform 区分开）。

    2、snd_soc_dai_driver

    2.1、snd_soc_dai_driver注册流程

            DAI驱动通常对应cpu的一个或几个I2S/PCM接口，实现一个DAI驱动大致可以分为以下几个步骤:

                    1、定义一个snd_soc_dai_driver结构的实例；
                    2、在对应的platform_driver中的probe回调中通过API: snd_soc_register_dai或者snd_soc_register_dais注册snd_soc_dai实例；
                    3、实现snd_soc_dai_driver结构中的probe、suspend等回调;
                    4、实现snd_soc_dai_driver结构中的snd_soc_dai_ops字段中的回调函数;

            具体代码流程如下（sound/soc/codecs/wm8350.c）

    1. /* snd_soc_dai_ops 结构体实例 */
    2. static const struct snd_soc_dai_ops wm8350_dai_ops = {
    3. 	 .hw_params	= wm8350_pcm_hw_params,
    4. 	 .mute_stream	= wm8350_mute,
    5. 	 .set_fmt	= wm8350_set_dai_fmt,
    6. 	 .set_sysclk	= wm8350_set_dai_sysclk,
    7. 	 .set_pll	= wm8350_set_fll,
    8. 	 .set_clkdiv	= wm8350_set_clkdiv,
    9. 	 .no_capture_mute = 1,
    10. };
    11.  
    12. /* snd_soc_dai_driver结构体实例 */
    13. static struct snd_soc_dai_driver wm8350_dai = {
    14. 	.name = "wm8350-hifi",
    15. 	.playback = {
    16. 		.stream_name = "Playback",
    17. 		.channels_min = 1,
    18. 		.channels_max = 2,
    19. 		.rates = WM8350_RATES,
    20. 		.formats = WM8350_FORMATS,
    21. 	},
    22. 	.capture = {
    23. 		 .stream_name = "Capture",
    24. 		 .channels_min = 1,
    25. 		 .channels_max = 2,
    26. 		 .rates = WM8350_RATES,
    27. 		 .formats = WM8350_FORMATS,
    28. 	 },
    29. 	.ops = &wm8350_dai_ops,
    30. };
    31.  
    32. /* platform平台probe函数 */
    33. static int wm8350_probe(struct platform_device *pdev)
    34. {
    35.     /* 注册component组件参数为soc_component_dev_wm8350 wm8350_dai*/
    36. 	return devm_snd_soc_register_component(&pdev->dev,
    37. 			&soc_component_dev_wm8350,
    38. 			&wm8350_dai, 1);
    39. }
    40.  
    41. /**
    42.  * devm_snd_soc_register_component - resource managed component registration
    43.  * @dev: Device used to manage component
    44.  * @cmpnt_drv: Component driver
    45.  * @dai_drv: DAI driver
    46.  * @num_dai: Number of DAIs to register
    47.  *
    48.  * Register a component with automatic unregistration when the device is
    49.  * unregistered.
    50.  */
    51. /* 进入devm_snd_soc_register_component函数 */
    52. int devm_snd_soc_register_component(struct device *dev,
    53. 			 const struct snd_soc_component_driver *cmpnt_drv,
    54. 			 struct snd_soc_dai_driver *dai_drv, int num_dai)
    55. {
    56. 	const struct snd_soc_component_driver **ptr;
    57. 	int ret;
    58.  
    59.     /* 申请devm_component_release空间 */
    60. 	ptr = devres_alloc(devm_component_release, sizeof(*ptr), GFP_KERNEL);
    61. 	if (!ptr)
    62. 		return -ENOMEM;
    63.  
    64.     /*调用snd_soc_register_component注册cmpnt_drv、 dai_drv */
    65. 	ret = snd_soc_register_component(dev, cmpnt_drv, dai_drv, num_dai);
    66. 	if (ret == 0) {
    67. 		*ptr = cmpnt_drv;
    68. 		devres_add(dev, ptr);
    69. 	} else {
    70. 		devres_free(ptr);
    71. 	}
    72.  
    73. 	return ret;
    74. }
    75. EXPORT_SYMBOL_GPL(devm_snd_soc_register_component);
    76.  
    77. /* 进入snd_soc_register_component函数 */
    78. int snd_soc_register_component(struct device *dev,
    79. 			const struct snd_soc_component_driver *component_driver,
    80. 			struct snd_soc_dai_driver *dai_drv,
    81. 			int num_dai)
    82. {
    83. 	struct snd_soc_component *component;
    84. 	int ret;
    85.  
    86.     /* 申请component空间 */
    87. 	component = devm_kzalloc(dev, sizeof(*component), GFP_KERNEL);
    88. 	if (!component)
    89. 		return -ENOMEM;
    90.     
    91.     /* 调用snd_soc_component_initialize函数注册component_driver */
    92. 	ret = snd_soc_component_initialize(component, component_driver, dev);
    93. 	if (ret < 0)
    94. 		return ret;
    95.  
    96.     /* 调用snd_soc_add_component注册 dai_drv */
    97. 	return snd_soc_add_component(component, dai_drv, num_dai);
    98. }
    99. EXPORT_SYMBOL_GPL(snd_soc_register_component);
    100.  
    101.  
    102. /* 进入snd_soc_add_component函数 */
    103. int snd_soc_add_component(struct snd_soc_component *component,
    104. 			  struct snd_soc_dai_driver *dai_drv,
    105. 			  int num_dai)
    106. {
    107. 	int ret;
    108. 	int i;
    109.  
    110. 	mutex_lock(&client_mutex);
    111.  
    112. 	if (component->driver->endianness) {
    113. 		for (i = 0; i < num_dai; i++) {
    114. 			convert_endianness_formats(&dai_drv[i].playback);
    115. 			convert_endianness_formats(&dai_drv[i].capture);
    116. 		}
    117. 	}
    118.     
    119.     /* 调用snd_soc_register_dais函数注册dai_drv */
    120. 	ret = snd_soc_register_dais(component, dai_drv, num_dai);
    121. 	if (ret < 0) {
    122. 		dev_err(component->dev, "ASoC: Failed to register DAIs: %d\n",
    123. 			ret);
    124. 		goto err_cleanup;
    125. 	}
    126.  
    127. 	if (!component->driver->write && !component->driver->read) {
    128. 		if (!component->regmap)
    129. 			component->regmap = dev_get_regmap(component->dev,
    130. 							   NULL);
    131. 		if (component->regmap)
    132. 			snd_soc_component_setup_regmap(component);
    133. 	}
    134.  
    135. 	/* see for_each_component */
    136. 	list_add(&component->list, &component_list);
    137.  
    138. err_cleanup:
    139. 	if (ret < 0)
    140. 		snd_soc_del_component_unlocked(component);
    141.  
    142. 	mutex_unlock(&client_mutex);
    143.  
    144. 	if (ret == 0)
    145. 		snd_soc_try_rebind_card();
    146.  
    147. 	return ret;
    148. }
    149. EXPORT_SYMBOL_GPL(snd_soc_add_component);
    150.  
    151. /**
    152.  * snd_soc_register_dais - Register a DAI with the ASoC core
    153.  *
    154.  * @component: The component the DAIs are registered for
    155.  * @dai_drv: DAI driver to use for the DAIs
    156.  * @count: Number of DAIs
    157.  */
    158. /* 进入snd_soc_register_dais函数 */
    159. static int snd_soc_register_dais(struct snd_soc_component *component,
    160. 				 struct snd_soc_dai_driver *dai_drv,
    161. 				 size_t count)
    162. {
    163. 	struct snd_soc_dai *dai;
    164. 	unsigned int i;
    165. 	int ret;
    166.  
    167. 	for (i = 0; i < count; i++) {
    168.         /* 最终调用snd_soc_register_dai函数注册dai_drv */
    169. 		dai = snd_soc_register_dai(component, dai_drv + i, count == 1 &&
    170. 					   !component->driver->non_legacy_dai_naming);
    171. 		if (dai == NULL) {
    172. 			ret = -ENOMEM;
    173. 			goto err;
    174. 		}
    175. 	}
    176.  
    177. 	return 0;
    178.  
    179. err:
    180. 	snd_soc_unregister_dais(component);
    181.  
    182. 	return ret;
    183. }
    184.  
    185. /**
    186.  * snd_soc_register_dai - Register a DAI dynamically & create its widgets
    187.  *
    188.  * @component: The component the DAIs are registered for
    189.  * @dai_drv: DAI driver to use for the DAI
    190.  * @legacy_dai_naming: if %true, use legacy single-name format;
    191.  * 	if %false, use multiple-name format;
    192.  *
    193.  * Topology can use this API to register DAIs when probing a component.
    194.  * These DAIs's widgets will be freed in the card cleanup and the DAIs
    195.  * will be freed in the component cleanup.
    196.  */
    197. /* 进入到snd_soc_register_dai函数 */
    198. struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component,
    199. 					 struct snd_soc_dai_driver *dai_drv,
    200. 					 bool legacy_dai_naming)
    201. {
    202. 	struct device *dev = component->dev;
    203. 	struct snd_soc_dai *dai;
    204.  
    205. 	dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
    206.  
    207. 	lockdep_assert_held(&client_mutex);
    208.  
    209.     /* 申请dai空间 */
    210. 	dai = devm_kzalloc(dev, sizeof(*dai), GFP_KERNEL);
    211. 	if (dai == NULL)
    212. 		return NULL;
    213.  
    214. 	/*
    215. 	 * Back in the old days when we still had component-less DAIs,
    216. 	 * instead of having a static name, component-less DAIs would
    217. 	 * inherit the name of the parent device so it is possible to
    218. 	 * register multiple instances of the DAI. We still need to keep
    219. 	 * the same naming style even though those DAIs are not
    220. 	 * component-less anymore.
    221. 	 */
    222. 	if (legacy_dai_naming &&
    223. 	    (dai_drv->id == 0 || dai_drv->name == NULL)) {
    224. 		dai->name = fmt_single_name(dev, &dai->id);
    225. 	} else {
    226. 		dai->name = fmt_multiple_name(dev, dai_drv);
    227. 		if (dai_drv->id)
    228. 			dai->id = dai_drv->id;
    229. 		else
    230. 			dai->id = component->num_dai;
    231. 	}
    232. 	if (!dai->name)
    233. 		return NULL;
    234.  
    235. 	dai->component = component;
    236. 	dai->dev = dev;
    237. 	dai->driver = dai_drv;
    238.  
    239. 	/* see for_each_component_dais */
    240.     /* 将dai->list添加到component->dai_list中 */
    241. 	list_add_tail(&dai->list, &component->dai_list);
    242. 	component->num_dai++;
    243.  
    244. 	dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
    245. 	return dai;
    246. }
    247. EXPORT_SYMBOL_GPL(snd_soc_register_dai);
    248.  
    249. /* 至此cpu_dai添加完成 */

    2.2、snd_soc_dai结构体

    1. /*
    2.  * Digital Audio Interface runtime data.
    3.  *
    4.  * Holds runtime data for a DAI.
    5.  */
    6. struct snd_soc_dai {
    7. 	const char *name;
    8. 	int id;
    9. 	struct device *dev;
    10.  
    11. 	/* driver ops */
    12. 	struct snd_soc_dai_driver *driver;
    13.  
    14. 	/* DAI runtime info */
    15. 	unsigned int stream_active[SNDRV_PCM_STREAM_LAST + 1]; /* usage count */
    16.  
    17. 	struct snd_soc_dapm_widget *playback_widget;
    18. 	struct snd_soc_dapm_widget *capture_widget;
    19.  
    20. 	/* DAI DMA data */
    21. 	void *playback_dma_data;
    22. 	void *capture_dma_data;
    23.  
    24. 	/* Symmetry data - only valid if symmetry is being enforced */
    25. 	unsigned int rate;
    26. 	unsigned int channels;
    27. 	unsigned int sample_bits;
    28.  
    29. 	/* parent platform/codec */
    30. 	struct snd_soc_component *component;
    31.  
    32. 	/* CODEC TDM slot masks and params (for fixup) */
    33. 	unsigned int tx_mask;
    34. 	unsigned int rx_mask;
    35.  
    36. 	struct list_head list;
    37.  
    38. 	/* function mark */
    39. 	struct snd_pcm_substream *mark_startup;
    40. 	struct snd_pcm_substream *mark_hw_params;
    41. 	struct snd_pcm_substream *mark_trigger;
    42. 	struct snd_compr_stream  *mark_compr_startup;
    43.  
    44. 	/* bit field */
    45. 	unsigned int probed:1;
    46. };

            snd_soc_dai该结构在snd_soc_register_dai函数中通过动态内存申请获得．简要介绍一下几个重要字段：

                    1、driver指向关联的snd_soc_dai_driver结构，由注册时通过参数传入。
                    2、playback_dma_data 用于保存该dai播放stream的dma信息目标地址，dma传送单元大小和通道号等。
                    3、capture_dma_data 同上，用于录音stream。
                    4、component指向关联的snd_soc_component结构体中。

    2.3、snd_soc_dai_driver结构体

    1. /*
    2.  * Digital Audio Interface Driver.
    3.  *
    4.  * Describes the Digital Audio Interface in terms of its ALSA, DAI and AC97
    5.  * operations and capabilities. Codec and platform drivers will register this
    6.  * structure for every DAI they have.
    7.  *
    8.  * This structure covers the clocking, formating and ALSA operations for each
    9.  * interface.
    10.  */
    11. struct snd_soc_dai_driver {
    12. 	/* DAI description */
    13. 	const char *name;
    14. 	unsigned int id;
    15. 	unsigned int base;
    16. 	struct snd_soc_dobj dobj;
    17.  
    18. 	/* DAI driver callbacks */
    19. 	int (*probe)(struct snd_soc_dai *dai);
    20. 	int (*remove)(struct snd_soc_dai *dai);
    21. 	/* compress dai */
    22. 	int (*compress_new)(struct snd_soc_pcm_runtime *rtd, int num);
    23. 	/* Optional Callback used at pcm creation*/
    24. 	int (*pcm_new)(struct snd_soc_pcm_runtime *rtd,
    25. 		       struct snd_soc_dai *dai);
    26.  
    27. 	/* ops */
    28. 	const struct snd_soc_dai_ops *ops;
    29. 	const struct snd_soc_cdai_ops *cops;
    30.  
    31. 	/* DAI capabilities */
    32. 	struct snd_soc_pcm_stream capture;
    33. 	struct snd_soc_pcm_stream playback;
    34. 	unsigned int symmetric_rate:1;
    35. 	unsigned int symmetric_channels:1;
    36. 	unsigned int symmetric_sample_bits:1;
    37.  
    38. 	/* probe ordering - for components with runtime dependencies */
    39. 	int probe_order;
    40. 	int remove_order;
    41. };

            snd_soc_dai_driver结构体需要自己根据不同的soc芯片进行定义，这里只介绍几个关键字段：

                    1、probe、remove回调函数，分别在声卡加载和卸载时被调用。
                    2、ops指向snd_soc_dai_ops结构，用于配置和控制该dai，后面细讲。
                    3、playback snd_soc_pcm_stream结构，用于指出该dai支持的声道数，码率，数据格式等能力。
                    4、capture snd_soc_pcm_stream结构，用于指出该dai支持的声道数，码率，数据格式等能力。

    2.4、snd_soc_dai_ops结构体

            snd_soc_dai_driver结构体中的ops字段指向一个snd_soc_dai_ops结构体，该结构体实际上是一组回调函数的集合，dai的配置和控制几乎都是通过这些回调函数来实现的，这些回调函数基本可以分为3大类，驱动程序可以根据实际情况实现其中的一部分：

    1. struct snd_soc_dai_ops {
    2. 	/*
    3. 	 * DAI clocking configuration, all optional.
    4. 	 * Called by soc_card drivers, normally in their hw_params.
    5. 	 */
    6. 	int (*set_sysclk)(struct snd_soc_dai *dai,
    7. 		int clk_id, unsigned int freq, int dir);
    8. 	int (*set_pll)(struct snd_soc_dai *dai, int pll_id, int source,
    9. 		unsigned int freq_in, unsigned int freq_out);
    10. 	int (*set_clkdiv)(struct snd_soc_dai *dai, int div_id, int div);
    11. 	int (*set_bclk_ratio)(struct snd_soc_dai *dai, unsigned int ratio);
    12.  
    13. 	/*
    14. 	 * DAI format configuration
    15. 	 * Called by soc_card drivers, normally in their hw_params.
    16. 	 */
    17. 	int (*set_fmt)(struct snd_soc_dai *dai, unsigned int fmt);
    18. 	int (*xlate_tdm_slot_mask)(unsigned int slots,
    19. 		unsigned int *tx_mask, unsigned int *rx_mask);
    20. 	int (*set_tdm_slot)(struct snd_soc_dai *dai,
    21. 		unsigned int tx_mask, unsigned int rx_mask,
    22. 		int slots, int slot_width);
    23. 	int (*set_channel_map)(struct snd_soc_dai *dai,
    24. 		unsigned int tx_num, unsigned int *tx_slot,
    25. 		unsigned int rx_num, unsigned int *rx_slot);
    26. 	int (*get_channel_map)(struct snd_soc_dai *dai,
    27. 			unsigned int *tx_num, unsigned int *tx_slot,
    28. 			unsigned int *rx_num, unsigned int *rx_slot);
    29. 	int (*set_tristate)(struct snd_soc_dai *dai, int tristate);
    30.  
    31. 	int (*set_stream)(struct snd_soc_dai *dai,
    32. 			  void *stream, int direction);
    33. 	void *(*get_stream)(struct snd_soc_dai *dai, int direction);
    34.  
    35. 	/*
    36. 	 * DAI digital mute - optional.
    37. 	 * Called by soc-core to minimise any pops.
    38. 	 */
    39. 	int (*mute_stream)(struct snd_soc_dai *dai, int mute, int stream);
    40.  
    41. 	/*
    42. 	 * ALSA PCM audio operations - all optional.
    43. 	 * Called by soc-core during audio PCM operations.
    44. 	 */
    45. 	int (*startup)(struct snd_pcm_substream *,
    46. 		struct snd_soc_dai *);
    47. 	void (*shutdown)(struct snd_pcm_substream *,
    48. 		struct snd_soc_dai *);
    49. 	int (*hw_params)(struct snd_pcm_substream *,
    50. 		struct snd_pcm_hw_params *, struct snd_soc_dai *);
    51. 	int (*hw_free)(struct snd_pcm_substream *,
    52. 		struct snd_soc_dai *);
    53. 	int (*prepare)(struct snd_pcm_substream *,
    54. 		struct snd_soc_dai *);
    55. 	/*
    56. 	 * NOTE: Commands passed to the trigger function are not necessarily
    57. 	 * compatible with the current state of the dai. For example this
    58. 	 * sequence of commands is possible: START STOP STOP.
    59. 	 * So do not unconditionally use refcounting functions in the trigger
    60. 	 * function, e.g. clk_enable/disable.
    61. 	 */
    62. 	int (*trigger)(struct snd_pcm_substream *, int,
    63. 		struct snd_soc_dai *);
    64. 	int (*bespoke_trigger)(struct snd_pcm_substream *, int,
    65. 		struct snd_soc_dai *);
    66. 	/*
    67. 	 * For hardware based FIFO caused delay reporting.
    68. 	 * Optional.
    69. 	 */
    70. 	snd_pcm_sframes_t (*delay)(struct snd_pcm_substream *,
    71. 		struct snd_soc_dai *);
    72.  
    73. 	/*
    74. 	 * Format list for auto selection.
    75. 	 * Format will be increased if priority format was
    76. 	 * not selected.
    77. 	 * see
    78. 	 *	snd_soc_dai_get_fmt()
    79. 	 */
    80. 	u64 *auto_selectable_formats;
    81. 	int num_auto_selectable_formats;
    82.  
    83. 	/* bit field */
    84. 	unsigned int no_capture_mute:1;
    85. };

            工作时钟配置函数通常由machine驱动调用：

                    1、set_sysclk设置dai的主时钟。
                    2、set_pll设置PLL参数。
                    3、set_clkdiv设置分频系数。

            dai的格式配置参数，通常也由machine驱动调用：

                    1、set_fmt设置dai的格式。

                    2、set_tdm_slot如果dai支持时分复用，用于设置时分复用的slot、set_channel_map声道的时分复用映射设置。
                    3、set_tristate设置dai引脚的状态，当与其他dai并联使用同一引脚时需要使用该回调。

            标准的snd_soc_ops回调通常由soc-core在进行PCM操作时调用：

                    1、startup：打开设备，设备开始工作的时候回调
                    2、shutdown：关闭设备前调用
                    3、hw_params：设置硬件的相关参数
                    4、trigger：DAM开始时传输，结束传输，暂停传世，恢复传输的时候被回调。

    3、platform_driver

    3.1、platform_driver注册流程

    1. /* snd_soc_component_driver结构体实例化 */
    2. static const struct snd_soc_component_driver soc_component_dev_wm8350 = {
    3. 	.probe			= wm8350_component_probe,
    4. 	.remove			= wm8350_component_remove,
    5. 	.set_bias_level		= wm8350_set_bias_level,
    6. 	.controls		= wm8350_snd_controls,
    7. 	.num_controls		= ARRAY_SIZE(wm8350_snd_controls),
    8. 	.dapm_widgets		= wm8350_dapm_widgets,
    9. 	.num_dapm_widgets	= ARRAY_SIZE(wm8350_dapm_widgets),
    10. 	.dapm_routes		= wm8350_dapm_routes,
    11. 	.num_dapm_routes	= ARRAY_SIZE(wm8350_dapm_routes),
    12. 	.suspend_bias_off	= 1,
    13. 	.idle_bias_on		= 1,
    14. 	.use_pmdown_time	= 1,
    15. 	.endianness		= 1,
    16. 	.non_legacy_dai_naming	= 1,
    17. };
    18.  
    19. /* 进入到wm8350_probe函数 */
    20. static int wm8350_probe(struct platform_device *pdev)
    21. {
    22.     /* 通过devm_snd_soc_register_component函数注册soc_component_dev_wm8350 */
    23. 	return devm_snd_soc_register_component(&pdev->dev,
    24. 			&soc_component_dev_wm8350,
    25. 			&wm8350_dai, 1);
    26. }
    27.  
    28. /* 进入platform_driver函数 */
    29. static struct platform_driver wm8350_codec_driver = {
    30. 	.driver = {
    31. 		   .name = "wm8350-codec",
    32. 		   },
    33. 	.probe = wm8350_probe,
    34. };
    35.  
    36. /* 通过module_platform_driver宏来注册platform_driver */
    37. module_platform_driver(wm8350_codec_driver);

    3.2、platform_driver结构体

             在编写 platform 驱动的时候，首先定义一个platform_driver结构体变量,然后实现结构体中的各个成员变量，重点是实现匹配方法以及probe函数。当驱动和设备匹配成功以后 probe函数就会执行，具体的驱动程序在 probe 函数里面编写，比如字符设备驱动等等。

    1. struct platform_driver {
    2. 	int (*probe)(struct platform_device *);
    3. 	int (*remove)(struct platform_device *);
    4. 	void (*shutdown)(struct platform_device *);
    5. 	int (*suspend)(struct platform_device *, pm_message_t state);
    6. 	int (*resume)(struct platform_device *);
    7. 	struct device_driver driver;
    8. 	const struct platform_device_id *id_table;
    9. 	bool prevent_deferred_probe;
    10. 	/*
    11. 	 * For most device drivers, no need to care about this flag as long as
    12. 	 * all DMAs are handled through the kernel DMA API. For some special
    13. 	 * ones, for example VFIO drivers, they know how to manage the DMA
    14. 	 * themselves and set this flag so that the IOMMU layer will allow them
    15. 	 * to setup and manage their own I/O address space.
    16. 	 */
    17. 	bool driver_managed_dma;
    18. };

            platform_driver结构体用于注册驱动到Platform总线，此处只讲几个重点字段：

                    1、probe：当驱动与设备匹配成功以后probe函数就会执行。一般驱动的提供者会编写,如果自己要编写一个全新的驱动,那么 probe 就需要自行实现。
                    2、driver：device_driver 结构体变量，Linux 内核里面大量使用到了面向对象的思维, device_driver相当于基类，提供了最基础的驱动框架。 plaform_driver继承了这个基类，然后在此基础上又添加了一些特有的成员变量。

    3.3、snd_soc_component结构体

    1. struct snd_soc_component {
    2.     /* device_driver->name 和snd_soc_component_driver->id有关， */
    3. 	const char *name;
    4. 	int id;
    5. 	const char *name_prefix;
    6. 	struct device *dev;
    7. 	struct snd_soc_card *card;
    8.  
    9. 	unsigned int active;
    10.  
    11. 	unsigned int suspended:1; /* is in suspend PM state */
    12.     /* 用于把自己挂载到全局链表component_list下, component_list在soc-core中保持的全局变量 */
    13. 	struct list_head list;
    14. 	struct list_head card_aux_list; /* for auxiliary bound components */
    15. 	struct list_head card_list;
    16.  
    17.     /* 指向下属的snd_soc_component_driver, 该结构体一般由底层平台驱动实现 */
    18. 	const struct snd_soc_component_driver *driver;
    19.  
    20.     /* 链表头, 挂接snd_soc_dai->list   list_add(&dai->list, &component->dai_list) */
    21. 	struct list_head dai_list;
    22. 	int num_dai;
    23.  
    24. 	struct regmap *regmap;
    25. 	int val_bytes;
    26.  
    27. 	struct mutex io_mutex;
    28.  
    29. 	/* attached dynamic objects */
    30. 	struct list_head dobj_list;
    31.  
    32. 	/*
    33. 	 * DO NOT use any of the fields below in drivers, they are temporary and
    34. 	 * are going to be removed again soon. If you use them in driver code
    35. 	 * the driver will be marked as BROKEN when these fields are removed.
    36. 	 */
    37.  
    38. 	/* Don't use these, use snd_soc_component_get_dapm() */
    39. 	struct snd_soc_dapm_context dapm;
    40.  
    41. 	/* machine specific init */
    42. 	int (*init)(struct snd_soc_component *component);
    43.  
    44. 	/* function mark */
    45. 	void *mark_module;
    46. 	struct snd_pcm_substream *mark_open;
    47. 	struct snd_pcm_substream *mark_hw_params;
    48. 	struct snd_pcm_substream *mark_trigger;
    49. 	struct snd_compr_stream  *mark_compr_open;
    50. 	void *mark_pm;
    51.  
    52. 	struct dentry *debugfs_root;
    53. 	const char *debugfs_prefix;
    54. };

    3.4、snd_soc_component_driver结构体

    1. struct snd_soc_component_driver {
    2. 	const char *name;
    3.  
    4. 	/* Default control and setup, added after probe() is run */
    5. 	const struct snd_kcontrol_new *controls;
    6. 	unsigned int num_controls;
    7. 	const struct snd_soc_dapm_widget *dapm_widgets;
    8. 	unsigned int num_dapm_widgets;
    9. 	const struct snd_soc_dapm_route *dapm_routes;
    10. 	unsigned int num_dapm_routes;
    11.  
    12. 	int (*probe)(struct snd_soc_component *component);
    13. 	void (*remove)(struct snd_soc_component *component);
    14. 	int (*suspend)(struct snd_soc_component *component);
    15. 	int (*resume)(struct snd_soc_component *component);
    16.  
    17. 	unsigned int (*read)(struct snd_soc_component *component,
    18. 			     unsigned int reg);
    19. 	int (*write)(struct snd_soc_component *component,
    20. 		     unsigned int reg, unsigned int val);
    21.  
    22. 	/* pcm creation and destruction */
    23. 	int (*pcm_construct)(struct snd_soc_component *component,
    24. 			     struct snd_soc_pcm_runtime *rtd);
    25. 	void (*pcm_destruct)(struct snd_soc_component *component,
    26. 			     struct snd_pcm *pcm);
    27.  
    28. 	/* component wide operations */
    29. 	int (*set_sysclk)(struct snd_soc_component *component,
    30. 			  int clk_id, int source, unsigned int freq, int dir);
    31. 	int (*set_pll)(struct snd_soc_component *component, int pll_id,
    32. 		       int source, unsigned int freq_in, unsigned int freq_out);
    33. 	int (*set_jack)(struct snd_soc_component *component,
    34. 			struct snd_soc_jack *jack,  void *data);
    35.  
    36. 	/* DT */
    37. 	int (*of_xlate_dai_name)(struct snd_soc_component *component,
    38. 				 const struct of_phandle_args *args,
    39. 				 const char **dai_name);
    40. 	int (*of_xlate_dai_id)(struct snd_soc_component *comment,
    41. 			       struct device_node *endpoint);
    42. 	void (*seq_notifier)(struct snd_soc_component *component,
    43. 			     enum snd_soc_dapm_type type, int subseq);
    44. 	int (*stream_event)(struct snd_soc_component *component, int event);
    45. 	int (*set_bias_level)(struct snd_soc_component *component,
    46. 			      enum snd_soc_bias_level level);
    47.  
    48. 	int (*open)(struct snd_soc_component *component,
    49. 		    struct snd_pcm_substream *substream);
    50. 	int (*close)(struct snd_soc_component *component,
    51. 		     struct snd_pcm_substream *substream);
    52. 	int (*ioctl)(struct snd_soc_component *component,
    53. 		     struct snd_pcm_substream *substream,
    54. 		     unsigned int cmd, void *arg);
    55. 	int (*hw_params)(struct snd_soc_component *component,
    56. 			 struct snd_pcm_substream *substream,
    57. 			 struct snd_pcm_hw_params *params);
    58. 	int (*hw_free)(struct snd_soc_component *component,
    59. 		       struct snd_pcm_substream *substream);
    60. 	int (*prepare)(struct snd_soc_component *component,
    61. 		       struct snd_pcm_substream *substream);
    62. 	int (*trigger)(struct snd_soc_component *component,
    63. 		       struct snd_pcm_substream *substream, int cmd);
    64. 	int (*sync_stop)(struct snd_soc_component *component,
    65. 			 struct snd_pcm_substream *substream);
    66. 	snd_pcm_uframes_t (*pointer)(struct snd_soc_component *component,
    67. 				     struct snd_pcm_substream *substream);
    68. 	int (*get_time_info)(struct snd_soc_component *component,
    69. 		struct snd_pcm_substream *substream, struct timespec64 *system_ts,
    70. 		struct timespec64 *audio_ts,
    71. 		struct snd_pcm_audio_tstamp_config *audio_tstamp_config,
    72. 		struct snd_pcm_audio_tstamp_report *audio_tstamp_report);
    73. 	int (*copy_user)(struct snd_soc_component *component,
    74. 			 struct snd_pcm_substream *substream, int channel,
    75. 			 unsigned long pos, void __user *buf,
    76. 			 unsigned long bytes);
    77. 	struct page *(*page)(struct snd_soc_component *component,
    78. 			     struct snd_pcm_substream *substream,
    79. 			     unsigned long offset);
    80. 	int (*mmap)(struct snd_soc_component *component,
    81. 		    struct snd_pcm_substream *substream,
    82. 		    struct vm_area_struct *vma);
    83. 	int (*ack)(struct snd_soc_component *component,
    84. 		   struct snd_pcm_substream *substream);
    85. 	snd_pcm_sframes_t (*delay)(struct snd_soc_component *component,
    86. 				   struct snd_pcm_substream *substream);
    87.  
    88. 	const struct snd_compress_ops *compress_ops;
    89.  
    90. 	/* probe ordering - for components with runtime dependencies */
    91. 	int probe_order;
    92. 	int remove_order;
    93.  
    94. 	/*
    95. 	 * signal if the module handling the component should not be removed
    96. 	 * if a pcm is open. Setting this would prevent the module
    97. 	 * refcount being incremented in probe() but allow it be incremented
    98. 	 * when a pcm is opened and decremented when it is closed.
    99. 	 */
    100. 	unsigned int module_get_upon_open:1;
    101.  
    102. 	/* bits */
    103. 	unsigned int idle_bias_on:1;
    104. 	unsigned int suspend_bias_off:1;
    105. 	unsigned int use_pmdown_time:1; /* care pmdown_time at stop */
    106. 	/*
    107. 	 * Indicates that the component does not care about the endianness of
    108. 	 * PCM audio data and the core will ensure that both LE and BE variants
    109. 	 * of each used format are present. Typically this is because the
    110. 	 * component sits behind a bus that abstracts away the endian of the
    111. 	 * original data, ie. one for which the transmission endian is defined
    112. 	 * (I2S/SLIMbus/SoundWire), or the concept of endian doesn't exist (PDM,
    113. 	 * analogue).
    114. 	 */
    115. 	unsigned int endianness:1;
    116. 	unsigned int non_legacy_dai_naming:1;
    117.  
    118. 	/* this component uses topology and ignore machine driver FEs */
    119. 	const char *ignore_machine;
    120. 	const char *topology_name_prefix;
    121. 	int (*be_hw_params_fixup)(struct snd_soc_pcm_runtime *rtd,
    122. 				  struct snd_pcm_hw_params *params);
    123. 	bool use_dai_pcm_id;	/* use DAI link PCM ID as PCM device number */
    124. 	int be_pcm_base;	/* base device ID for all BE PCMs */
    125.  
    126. #ifdef CONFIG_DEBUG_FS
    127. 	const char *debugfs_prefix;
    128. #endif
    129. };

            module_platform_driver函数的详解请参考《module_platform_driver源码分析》
           

  • 相关阅读:
    bm8 bm9
    从零开始：使用Rust语言在STM32F4处理器上实现VGA风格视频输出的完整指南
    信噪比和比特误码率之间的关系通过matlab仿真计算出
    【JavaEE】_HTTP响应
    金九银十BAT互联网企业涨薪必备知识点：Jvm性能调优实战
    大数据在金融行业的深度应用与未来展望
    react（子传父、父传子）
    Web项目 - 登录注册业务逻辑
    sshpiper 在 Kubernetes 上的应用
    FPGA设计时序约束七、设置时钟不确定约束
  • 原文地址：https://blog.csdn.net/code_lyb/article/details/126583717