From a2d661e8938acc821972b7bc42c6a9055db768b2 Mon Sep 17 00:00:00 2001 From: annie_wangli Date: Tue, 28 Dec 2021 15:26:46 +0800 Subject: [PATCH] update docs Signed-off-by: annie_wangli --- en/device-dev/driver/Readme-EN.md | 1 + .../driver/driver-peripherals-audio-des.md | 1409 +++++++++++++++++ en/device-dev/driver/driver-peripherals.md | 4 +- .../driver/figures/ADM_control_flowchart.png | Bin 0 -> 35853 bytes .../driver/figures/ADM_playback_flowchart.png | Bin 0 -> 120 bytes .../driver/figures/ADM_startup_flowchart.png | Bin 0 -> 90137 bytes .../driver/figures/Audio_architecture.png | Bin 0 -> 120 bytes .../figures/development_flowchart_1.png | Bin 0 -> 9698 bytes .../figures/development_flowchart_2.png | Bin 0 -> 9744 bytes 9 files changed, 1413 insertions(+), 1 deletion(-) create mode 100644 en/device-dev/driver/driver-peripherals-audio-des.md create mode 100644 en/device-dev/driver/figures/ADM_control_flowchart.png create mode 100644 en/device-dev/driver/figures/ADM_playback_flowchart.png create mode 100644 en/device-dev/driver/figures/ADM_startup_flowchart.png create mode 100644 en/device-dev/driver/figures/Audio_architecture.png create mode 100644 en/device-dev/driver/figures/development_flowchart_1.png create mode 100644 en/device-dev/driver/figures/development_flowchart_2.png diff --git a/en/device-dev/driver/Readme-EN.md b/en/device-dev/driver/Readme-EN.md index c2c3dea84d..124245d205 100644 --- a/en/device-dev/driver/Readme-EN.md +++ b/en/device-dev/driver/Readme-EN.md @@ -34,4 +34,5 @@ - [TOUCHSCREEN](driver-peripherals-touch-des.md) - [Sensor](driver-peripherals-sensor-des.md) - [WLAN](driver-peripherals-external-des.md) + - [AUDIO](driver-peripherals-audio-des.md) - [USB](driver-peripherals-usb-des.md) \ No newline at end of file diff --git a/en/device-dev/driver/driver-peripherals-audio-des.md b/en/device-dev/driver/driver-peripherals-audio-des.md new file mode 100644 index 0000000000..f83fc8b294 --- /dev/null +++ b/en/device-dev/driver/driver-peripherals-audio-des.md @@ -0,0 +1,1409 @@ +# Audio + +- **[Audio Driver Overview](#section1000)** + +- **[Audio Driver Architecture](#section2000)** + +- **[Audio Driver Development](#section3000)** + + - **[Audio ADM Architecture](#section3100)** + - [Startup Process](#section3111) + - [Playback Process](#section3112) + - [Control Process](#section3113) + + - **[Audio Driver Development Procedure](#section3200)** + - [Development on the Existing Platform](#section3221) + - [Development on a New Platform](#section3222) + +- **[Audio Driver Development Examples](#section4000)** + - [Codec Driver Development Example](#section4100) + - [Filling in Codec Data Structures](#section4111) + - [Initializing codecDevice and codecDai Devices](#section4112) + - [Implementing the Codec Operation Function Set](#section4113) + - [Registering and Binding Codec to HDF](#section4114) + - [Configuring HCS](#section4115) + - [Accessory Driver Development Example](#section4200) + - [Filling in Accessory Data Structures](#section4221) + - [Initializing accessoryDevice and accessoryDai Devices](#section4222) + - [Implementing the Accessory Operation Function Set](#section4223) + - [Registering and Binding Accessory to HDF](#section4224) + - [Configuring HCS](#section4225) + - [Platform Driver Development Example](#section4300) + - [Filling in Platform Data Structures](#section4331) + - [Initializing the dmaDevice Device](#section4332) + - [Implementing the DMA Operation Function Set](#section4333) + - [Registering and Binding Platform to HDF](#sectionsection4334) + - [Configuring HCS](#section4335) + - [DAI Driver Development Example](#section4400) + - [Filling in DAI Data Structures](#section4441) + - [Initializing the daiDevice Device](#section4442) + - [Implementing the DAI Operation Function Set](#section4443) + - [Registering and Binding DAI to HDF](#section4444) + - [Configuring HCS](#section4445) + - [Adding Compilation Configuration to Makefile](#section4500) + - [Source Code Structure and Directory](#section4600) + +- **[Development Procedure and Example Using HAL](#section5000)** + - [Development Procedure](#section5100) + - [Development Example](#section5200) + +- **[Summary](#section9999)** + +# Audio Driver Overview + +A multimedia system is an indispensable part in Internet of Things (IoT) devices. Audio is an important module of the multimedia system, and building an audio driver model is particularly important in development. + +This document describes the audio driver architecture and functional components and how to develop the audio driver based on the Hardware Driver Foundation (HDF). Chip vendors can develop their own drivers and Hardware abstraction layer (HAL) API invocation based on the driver architecture. + + + +# Audio Driver Architecture + +The audio driver architecture is implemented based on the [HDF](https://device.harmonyos.com/en/docs/documentation/guide/driver-hdf-overview-0000001051715456). The audio driver architecture is as follows: +![](figures/Audio_architecture.png) + +The driver architecture consists of the following: +- Hardware Device Interface (HDI) adapter: implements the audio HAL driver (HDI adaptation) and provides hardware driver capability interfaces for the audio service (frameworks). The HDI adapter provides interface objects such as Audio Manager, Audio Adapter, Audio Control, Audio Capture and Audio Render. +- Audio interface lib: works with the audio driver model in the kernel to control audio hardware, read recording data, and write playback data. It contains **Stream\_ctrl\_common**, which is used to interact with the audio HDI adapter layer. +- Audio Driver Model (ADM): serves the multimedia audio subsystem and enables system developers to develop applications based on scenarios. With ADM, codec and DSP device vendors can adapt their driver code based on the unified interfaces provided by the ADM and implement quick development and easy adaptation to the OpenHarmony system. +- Audio Control Dispatch: receives control instructions from the library layer and distributes the control instructions to the driver layer. +- Audio Stream Dispatch: receives data from the library layer and distributes the data to the driver layer. + +- Card Manager: performs management of multiple audio cards. Each audio adapter consists of the digital audio interface (DAI), Platform, Codec, Accessory, DSP and Smart Audio Power Manager (SAPM) modules. +- Platform Driver: servers as the driver adaptation layer. +- Smart Audio Power Manager (SAPM): optimizes the power consumption policy of the ADM. + +# Audio Driver Development + +The following uses the Hi3516D V300 as an example to describe how to develop drivers based on the audio driver framework. + +## Audio ADM Architecture +The audio driver provides the **hdf\_audio\_render**, **hdf\_audio\_capture** and **hdf\_audio\_control** services for the HDI layer. The driver service nodes in the **dev** directory of the development board are as follows: + +```c +# ls -l hdf_audio* +crw-rw---- 1 system system 248, 6 1970-01-01 00:00 hdf_audio_capture // Audio data recording streaming service. +crw-rw---- 1 system system 248, 4 1970-01-01 00:00 hdf_audio_codec_dev0 // Name of audio adapter device 0. +crw-rw---- 1 system system 248, 4 1970-01-01 00:00 hdf_audio_codec_dev1 // Name of audio adapter device 1. +crw-rw---- 1 system system 248, 5 1970-01-01 00:00 hdf_audio_control // Audio control streaming service. +crw-rw---- 1 system system 248, 7 1970-01-01 00:00 hdf_audio_render // Audio data playback streaming service. +``` + +The audio adapter devices have the following driver services: + +hdf\_audio\_codec\_dev0 +- **dma\_service\_0**: DMA service +- **dai_service**: CPU DAI service +- **codec\_service\_0**: codec service (built-in codec) +- **dsp\_service\_0**: DSP service (optional) + +hdf\_audio\_codec\_dev1 +- **dma\_service\_0**: DMA service +- **dai_service**: CPU DAI service +- **codec\_service\_1**: accessory service (SmartPA) +- **dsp\_service\_0**: DSP service (optional) + +### Startup Process + +![](figures/ADM_startup_flowchart.png) + +1. When the system starts, the Platform, Codec, Accessory, DSP and DAI drivers of the audio module are loaded first. Each driver obtains the configuration information from its configuration file and saves the obtained information to the data structures. + +2. Each driver module calls the ADM registration interface to add itself to the linked list of the driver module. + +3. The ADM reads the hdf\_audio\_driver\_0 and hdf\_audio\_driver\_1 configuration and loads the devices of each module. + +4. The ADM module initializes each module device by calling the initialization API of each module. + +5. Add the initialized audio devices to the cardManager linked list. + +### Playback Process +![=](figures/ADM_playback_flowchart.png) +1. The Interface Lib dispatches the **Render Open** instruction through the service launched by the driver for handling the playback streaming (referred to as driver service hereinafter). Upon receiving the instruction, the Stream Dispatch service calls the API of each module to deliver the instruction. + +2. The Interface Lib dispatches a path select instruction through the control service. Upon receiving the instruction, the Control Dispatch service calls the DAI API to set the path. + +3. The Interface Lib dispatches hardware parameters through the driver service. Upon receiving the parameters, the Stream Dispatch service calls the API of each module to set hardware parameters. + +4. The Interface Lib dispatches the start playing instruction through the driver service. Upon receiving the instruction, the Stream Dispatch service calls the API of each module to perform related settings for each module. + +5. The Interface Lib dispatches audio data through the driver service. Upon receiving the data, the Stream Dispatch service calls the **Platform AudioPcmWrite** API to send the audio data to direct memory access (DMA). + +6. The Interface Lib dispatches the stop playing instruction through the driver service. Upon receiving the instruction, the Stream Dispatch service calls the stop API of each module to perform related settings for each module. + +7. The Interface Lib dispatches the **Render Close** instruction through the driver service. Upon receiving the instruction, the Stream Dispatch service calls the **Platform AudioRenderClose** API to release resources. + +### Control Process + +![](figures/ADM_control_flowchart.png) + +1. When the volume needs to be adjusted, the Interface Lib dispatches the instruction for obtaining the volume range through the control service. Upon receiving the instruction, the Control Dispatch service parses the instruction and calls **get()** of the Codec module to obtain the volume range. +2. The Interface Lib dispatches the instruction for setting the volume through the control service. Upon receiving the instruction, the Control Dispatch service parses the instruction and calls **Set()** of the Codec module to set the volume. + +## Audio Driver Development Procedure + +### Development on the Existing Platform + +The following figure shows the driver development process for adapting the ADM to the codec or accessory (SmartPA) of the existing platform (Hi3516D V300). + +![](figures/development_flowchart_1.png) + +- Add register information to the private HDF configuration source (HCS) of codec or smartPA based on the chip description. + +- If the workflow of the newly added codec or SmartPA is the same as that of the existing codec or SmartPA, you do not need to implement the operation function set or configure the compilation file for the newly added codec or SmartPA. + + +- Perform build, debugging, and testing. + +### Development on a New Platform + +The following figure shows the driver development process of the ADM on a new platform. + +![](figures/development_flowchart_2.png) + +The audio-related drivers codec (optional), DAI, DMA, DSP (optional), and SmartPA (optional) need to be adapted to the new platform. + +- Add register information of each module driver to the private configuration file of each module according to the chip description. + +- Implement the operation function set of each module. + +- Modify the compilation file of the audio module. + +- Perform build, debugging, and testing. + + + +# Audio Driver Development Examples + +Code path: **drivers/peripheral/audio** + +The following uses Hi3516D V300 as an example to describe how to develop the audio codec driver, accessory driver, DAI driver, and platform driver. + +## Codec Driver Development Example +Code path: **drivers/peripheral/audio/chipsets/hi3516dv300/codec** + +The major steps for developing the codec driver are as follows: +1. Define and fill in a codec instance. +2. Implement callbacks for the codec instance. +3. Register and bind the codec instance to the HDF. +4. Configure the HCS and makefile. + +### Filling in Codec Data Structures + +Fill in the following data structures for the codec module: + +- **g_codecData**: operation function set and private data set of the codec device. + +- **g_codecDaiDeviceOps**: codecDai operation function set, including APIs for starting transmission and setting parameters. + +- **g_codecDaiData**: operation function set and private data set of the digital audio interface of the codec. + +```c +struct CodecData g_codecData = { + .Init = CodecDeviceInit, // Initialize the codec device (need to be implemented for a new platform). + .Read = AudioDeviceReadReg, // Read the register (already implemented in the existing framework and no adaptation needed). + .Write = AudioDeviceWriteReg, // Write the register (already implemented in the existing framework and no adaptation needed). +}; + +struct AudioDaiOps g_codecDaiDeviceOps = { + .Startup = CodecDaiStartup, // Start transmission (need to be implemented for a new platform). + .HwParams = CodecDaiHwParams, // Set parameters (need to be implemented for a new platform). +}; + +struct DaiData g_codecDaiData = { + .DaiInit = CodecDaiDeviceInit, // Initialize the codecdai device (need to be implemented for a new platform). + .ops = &g_codecDaiDeviceOps, // codecdai operation functions. +}; +``` + +### Initializing CodecDevice and CodecDai Devices + +**CODECDeviceInit** sets audio input/audio output (AIAO), initializes registers, inserts **g_audioControls** into the controller linked list, initializes the power management, and selects a path. + +```c +int32_t CodecDeviceInit(struct AudioCard *audioCard, struct CodecDevice *codec) +{ + ... + /* Register set() and get() of the AIAO module on the Hi3516 platform.*/ + CodecSetCtlFunc(codec->devData, AudioCodecAiaoGetCtrlOps, AudioCodecAiaoSetCtrlOps) + ... + /* Hi3516 codec register IoRemap*/ + CodecHalSysInit(); + ... + /* Initialize the codec registers of the Hi3516 platform.*/ + CodecRegDefaultInit(codec->devData->regCfgGroup); + ... + /* Insert g_audioControls of the Hi3516 platform to the controller linked list.*/ + AudioAddControls(audioCard, codec->devData->controls, codec->devData->numControls); + ... + /* Load the codec of the Hi3516 platform to the SAPM.*/ + AudioSapmNewComponents(audioCard, codec->devData->sapmComponents, codec->devData->numSapmComponent); + ... + /* Insert the codec of the Hi3516 platform to the audioRoutes linked list.*/ + AudioSapmAddRoutes(audioCard, g_audioRoutes, HDF_ARRAY_SIZE(g_audioRoutes); + ... + AudioSapmNewControls(audioCard); + ... + /* Hi3516 codec power management*/ + AudioSapmSleep(audioCard); + ... + return HDF_SUCCESS; +} +``` + +**CodecDaiDeviceInit** initializes codecDai. This API is not used on the Hi3516 and is reserved. + +```c +int32_t CodecDaiDeviceInit(struct AudioCard *card, const struct DaiDevice *device) + +{ + ... + AUDIO_DRIVER_LOG_DEBUG("codec dai device name: %s\n", device->devDaiName); + (void)card; + return HDF_SUCCESS; +} +``` + +### Implementing the Codec Operation Function Set + +The codec module is encapsulated with the **read()** and **write()** functions of the read and write registers at the operating system abstraction layer (OSAL). + +If the new platform cannot use the OSAL read and write functions to operate registers, the developer should implement the **read()** and **write()**. + +```c +int32_t AudioDeviceReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *val) +{ + ... + *val = OSAL_READL((void *)((uintptr_t)(virtualAddress + reg))); + return HDF_SUCCESS; +} + +int32_t AudioDeviceWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value) +{ + OSAL_WRITEL(value, (void *)((uintptr_t)(virtualAddress + reg))); + return HDF_SUCCESS; +} +``` + +**CodecDaiStartup** completes startup settings. + +```c +int32_t CodecDaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + int32_t ret; + ... + (void)card; + ret = CodecSetAdcTuneEnable(device->devData->regCfgGroup); + ... + return HDF_SUCCESS; +} +``` + +**CodecDaiHwParams** sets parameters, including the sampling rate and bit width. + +```c +int32_t CodecDaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + unsigned int bitWidth; + struct CodecDaiParamsVal codecDaiParamsVal; + ... + int ret = AudioFramatToBitWidth(param->format, &bitWidth); + ... + codecDaiParamsVal.frequencyVal = param->rate; + codecDaiParamsVal.formatVal = bitWidth; + ret = CodecDaiParamsUpdate(card->rtd->codecDai->devData->regCfgGroup, codecDaiParamsVal); + ... + return HDF_SUCCESS; +} +``` + +### Registering and Binding Codec to HDF + +This process depends on the driver implementation mode of the HDF. For details, see [HDF](https://gitee.com/openharmony/docs/blob/master/en/device-dev/driver/driver-hdf.md). + +Fill in the **g_codecDriverEntry** structure. Ensure that the value of **moduleName** is the same as that in **device_info.hcs**. Implement the pointers to the **Bind**, **Init**, and **Release** functions. + +drivers/peripheral/audio/chipsets/hi3516dv300/codec/src/hi3516_codec_adapter.c + +```c +struct HdfDriverEntry g_codecDriverEntry = { + .moduleVersion = 1, + .moduleName = "CODEC_HI3516", + .Bind = CodecDriverBind, + .Init = CodecDriverInit, + .Release = CodecDriverRelease, +}; +HDF_INIT(g_codecDriverEntry); +``` + +**CodecDriverBind** binds the device in the HDF to the codec and registers the codec service with the HDF. + +```c +static int32_t CodecDriverBind(struct HdfDeviceObject *device) +{ + struct CodecHost *codecHost = (struct CodecHost *)OsalMemCalloc(sizeof(*codecHost)); + ... + codecHost->device = device; + device->service = &codecHost->service; + return HDF_SUCCESS; +} +``` + +**CodecDriverInit** obtains the codec service name and private register configuration, and inserts them into the linked list by using **AudioRegisterCodec**. + +```c +static int32_t CodecDriverInit(struct HdfDeviceObject *device) +{ + ... + CodecGetConfigInfo(device, &g_codecData); + CodecSetConfigInfo(&g_codecData, &g_codecDaiData); + CodecGetServiceName(device, &g_codecData.drvCodecName); + CodecGetDaiName(device, &g_codecDaiData.drvDaiName); + AudioRegisterCodec(device, &g_codecData, &g_codecDaiData); + ... + return HDF_SUCCESS; +} +``` + +**CodecDriverRelease** releases driver resources. + +```c +static void CodecDriverRelease(struct HdfDeviceObject *device) +{ + codecHost = (struct CodecHost *)device->service; + OsalMemFree(codecHost); +} +``` + +### Configuring HCS + +Configure the driver node, loading sequence, and service name in the .hcs file. For details about the HCS syntax, see [Driver Configuration Management](https://gitee.com/openharmony/docs/blob/master/en/device-dev/driver/driver-hdf-manage.md) in the HDF framework. + +Path of the standard-system configuration file: + +**vendor/hisilicon/Hi3516DV300/hdf_config/khdf/** + +Path of the small-system configuration file: + +**vendor/hisilicon/hispark_taurus/hdf_config/** + +**Configuring Codec Device Information in device_info.hcs** + +Add codec node configuration. Modify **moduleName** in the configuration file. The value must be the same as **moduleName** in the **HdfDriverEntry** structure. Generally, the value should present the hardware platform, for example, **moduleName = "CODEC_HI3516"**. + +The code snippet is as follows: + +```c + audio :: host { + device_codec :: device { + device0 :: deviceNode { + policy = 1; // The codec module provides services only for the kernel. + priority = 50; // The codec module must be loaded before the load of the HDF_AUDIO module. + preload = 0; + permission = 0666; + moduleName = "CODEC_HI3516"; // The value must be the same as moduleName in HdfDriverEntry. + serviceName = "codec_service_0"; // Name of the service provided externally. + deviceMatchAttr = "hdf_codec_driver"; // Name of the private attribute, which is used to match the corresponding private data (including the register configuration). + } + } +``` + +**Configuring Dependencies in audio_config.hcs** + +Configure dependencies between the codec, platform, DAI, DSP, and accessory for the audio_card device. + +The code snippet is as follows: + +```c +root { + platfrom { + ... + controller_0x120c1001 :: card_controller { + // Set the private data attribute name, which must be the same as deviceMatchAttr in device_info.hcs. + match_attr = "hdf_audio_driver_1"; + serviceName = "hdf_audio_smartpa_dev0"; // Name of the service provided externally. + accessoryName = "codec_service_1"; // External codec service name. + platformName = "dma_service_0"; // DMA service. + cpuDaiName = "dai_service"; // CPU DAI service. + accessoryDaiName = "accessory_dai"; // External DAI. + dspName = "dsp_service_0"; // DSP service name. + dspDaiName = "dsp_dai"; // DSP DAI + } + } +} +``` + +**Configuring Private Registers in codec_config.hcs** + +The configuration matches **deviceMatchAttr** of the codec configured in **device_info.hcs**. It includes the register configuration. + +Binding the control function configuration is to configure the control functions and their register parameters in the .hcs file according to unified structure specifications. The configuration can be obtained and parsed, and added to the controller linked list. + +- **regConfig**: register and control function configuration + +- **ctrlParamsSeqConfig**: control function register configuration + +- **daiStartupSeqConfig**: DAI startup configuration + +- **daiParamsSeqConfig**: playback parameter configuration + +- **resetSeqConfig**: reset process register configuration + +- **initSeqConfig**: initialization process register configuration + +- **controlsConfig**: control function configuration. The **array index** (specific service scenario) and **iface** (same as the HAL) are of fixed values. + +``` +array index +0: Main Playback Volume +1: Main Capture Volume +2: Playback Mute +3: Capture Mute +4: Mic Left Gain +5: Mic Right Gain +6: External Codec Enable +7: Internally Codec Enable +8: Render Channel Mode +9: Capture Channel Mode +iface +0: virtual dac device +1: virtual adc device +2: virtual adc device +3: virtual mixer device +4: Codec device +5: PGA device +6: AIAO device +``` + +**ctrlParamsSeqConfig**: control function register configuration. The **item** sequence corresponds to the **item** sequence in **controlsConfig**, indicating the register configuration corresponding to a function. + +```c + root { + platfrom { + template codec_controller { + match_attr = ""; + serviceName = ""; + codecDaiName = ""; + } + controller_0x120c1030 :: codec_controller { + match_attr = "hdf_codec_driver"; + serviceName = "codec_service_0"; + codecDaiName = "codec_dai"; + + /* Base address of the Hi3516 register*/ + idInfo { + chipName = "hi3516"; // Codec name + chipIdRegister = 0x113c0000; // Codec base address + chipIdSize = 0x1000; // Codec address offset + } + + /* Register configuration, including configuration of registers*/ + regConfig { + /* reg: register address + rreg: register address + shift: shift bits + rshift: rshift bits + min: min value + max: max value + mask: mask of value + invert: enum InvertVal 0-uninvert 1-invert + value: value + */ + + /* reg, value */ + initSeqConfig = [ + 0x14, 0x04000002, + 0x18, 0xFD200004, + 0x1C, 0x00180018, + 0x20, 0x83830028, + 0x24, 0x00005C5C, + 0x28, 0x00130000, + 0x30, 0xFF035A00, + 0x34, 0x08000001, + 0x38, 0x06062424, + 0x3C, 0x1E1EC001, + 0x14, 0x04000002 + ]; + + /* control function config + array index, iface, enable*/ + controlsConfig = [ + 0, 0, 0, + 1, 1, 1, + 2, 0, 1, + 3, 1, 1, + 4, 2, 1, + 5, 2, 1, + 8, 6, 0, + 9, 6, 0, + ]; + /* control function register config + reg, rreg, shift, rshift, min, max, mask, invert, value */ + ctrlParamsSeqConfig = [ + 0x3c, 0x3c, 24, 24, 0x0, 0x57, 0x7F, 1, 0, //"Main Capture Volume" + 0x38, 0x38, 31, 31, 0x0, 0x1, 0x1, 0, 0, //"Playback Mute" + 0x3c, 0x3c, 31, 31, 0x0, 0x1, 0x1, 0, 0, //"Capture Mute" + 0x20, 0x20, 16, 16, 0x0, 0xF, 0x1F, 0, 0, //"Mic Left Gain" + 0x20, 0x20, 24, 24, 0x0, 0xF, 0x1F, 0, 0, //"Mic Right Gain" + 0x2000, 0x2000, 16, 16, 0x0, 0x7, 0x7, 0, 0, //"Render Channel Mode" + 0x1000, 0x1000, 16, 16, 0x0, 0x7, 0x7, 0, 0 //"Captrue Channel Mode" + ]; + + /* After the upper layer delivers parameters, write audio-related data to registers. + reg, rreg, shift, rshift, min, max, mask, invert, value */ + daiParamsSeqConfig = [ + 0x30, 0x30, 13, 13, 0x0, 0x1F, 0x1F, 0, 0x0, // i2s_frequency + 0x1C, 0x1C, 6, 6, 0x0, 0x3, 0x3, 0, 0x0, // adc_mode_sel + 0x30, 0x30, 22, 22, 0x0, 0x3, 0x3, 0, 0x0, // i2s_datawith + ]; + + /* Configuration of the power management function register. + reg, rreg, shift, rshift, min, max, mask, invert, value */ + ctrlSapmParamsSeqConfig = [ + 0x20, 0x20, 23, 23, 0x0, 0x1, 0x1, 0, 0, //LPGA MIC 0 -- connect MIC + 0x20, 0x20, 31, 31, 0x0, 0x1, 0x1, 0, 0, //RPGA MIC 0 -- connect MIC + 0x30, 0x30, 27, 27, 0x0, 0x1, 0x1, 0, 0, //dacl to dacr mixer + 0x30, 0x30, 26, 26, 0x0, 0x1, 0x1, 0, 0 //dacr to dacl mixer + ]; + + /* + Power management component configuration + componentName: function name, {"ADCL", "ADCR", "DACL", "DACR", "LPGA", "RPGA", "SPKL", "SPKR", "MIC"} array index. + sapmType,compNameIndex,reg, mask,shift,invert, kcontrolNews,kcontrolsNum + */ + sapmComponent = [ + 10, 0, 0x20, 0x1, 15, 1, 0, 0, //ADCL + 10, 1, 0x20, 0x1, 14, 1, 0, 0, //ADCR + 11, 2, 0x14, 0x1, 11, 1, 0, 0, //DACL + 11, 3, 0x14, 0x1, 12, 1, 0, 0, //DACR + 8, 4, 0x20, 0x1, 13, 1, 1, 1, //LPGA + 8, 5, 0x20, 0x1, 12, 1, 2, 1, //RPGA + 15, 6, 0, 0x1, 0, 0, 3, 1, //SPKL + 15, 7, 0, 0x1, 0, 0, 4, 1, //SPKR + 0, 8, 0, 0x1, 0, 0, 0, 0 //MIC + ]; + + /* Power management function configuration + array index, iface, enable + */ + sapmConfig = [ + 0, 5, 1, + 1, 5, 1, + 2, 0, 1, + 3, 0, 1 + ]; + } + } + } +} +``` + +Read the .hcs files in the C code to obtain register configuration. + +```c +static int32_t CodecDriverInit(struct HdfDeviceObject *device) +{ + ... + CodecGetConfigInfo(device, &g_codecData) ; + CodecSetConfigInfo(&g_codecData, &g_codecDaiData); + ... + return HDF_SUCCESS; +} +``` + +When the codec is registered, the input parameter **device** contains controller_0x120c1030 node information. You only need to parse the node to obtain the configuration information. + +```c +int32_t CodecGetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData) +{ + codecData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(codecData->regConfig))); + CodecGetRegConfig(device, codecData->regConfig); + return HDF_SUCCESS; +} +``` + +Obtain the node configuration to configure the node. + +```c +int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData) +{ + ... + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + ... + idNode = drsOps->GetChildNode(root, "idInfo"); + ParseAudioAttr(drsOps, idNode, &configData->audioIdInfo); + regCfgNode = drsOps->GetChildNode(root, "regConfig"); + ... + DEV_RES_NODE_FOR_EACH_ATTR(regCfgNode, regAttr) { + ... + return HDF_SUCCESS; +} +``` + +Obtain and use the configuration of the **regConfig** node. After the configuration files are parsed, the register information in the code can be directly updated. + +```c +int32_t CodecDeviceInit(struct AudioCard *audioCard, struct CodecDevice *codec) +{ +... + if (CodecRegDefaultInit(codec->devData->regCfgGroup) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("CodecRegDefaultInit failed."); + return HDF_FAILURE; + } +... + return HDF_SUCCESS; +} +``` + + + +## Accessory Driver Development Example +Code path: **drivers/peripheral/audio/chipsets/tfa9879/accessory** + +SmartPA is a type of accessory driver. The SmartPA development procedure is similar to the codec development procedure. +1. Define and fill in an accessory instance. +2. Implement callbacks for the accessory instance. +3. Register and bind the accessory instance to the HDF. +4. Configure the HCS and makefile. + +### Filling in Accessory Data Structures + +Fill in the following data structures for the accessory module: + +- **g_tfa9879Data**: operation function set of the accessory device. It contains the configuration in the .hcs file, and defines and maps the methods for initializing the accessory device and reading and writing registers. + +- **g_tfa9879DaiDeviceOps**: data set of the DAI of the accessory device. It defines and maps the driver name, initialization, and operation set of the data access interface of the accessory device. + +- **g_tfa9879DaiData**: data set of the DAI of the accessory device. It defines and maps the driver name, initialization, and operation set of the data access interface of the accessory device. + +```c +struct AccessoryData g_tfa9879Data = { + .Init = Tfa9879DeviceInit, + .Read = AccessoryDeviceRegRead, + .Write = AccessoryDeviceRegWrite, +}; + +struct AudioDaiOps g_tfa9879DaiDeviceOps = { + .Startup = Tfa9879DaiStartup, + .HwParams = Tfa9879DaiHwParams, +}; + +struct DaiData g_tfa9879DaiData = { + .drvDaiName = "accessory_dai", + .DaiInit = Tfa9879DaiDeviceInit, + .ops = &g_tfa9879DaiDeviceOps, +}; +``` + +### Initializing accessoryDevice and accessoryDai Devices + +As the entry function for device initialization, **Tfa9879DeviceInit** sets the address of the SmartPA I2C device, obtains configuration data, initializes (including resets) the device registers, and adds the control function to the controller linked list. The current demo also includes the initialization of the registers related to the Hi3516D V300 device, such as initialization of GPIO pins. + +```c +int32_t Tfa9879DeviceInit(struct AudioCard *audioCard, const struct AccessoryDevice *device) +{ + int32_t ret; + ... + g_accessoryTransferData.i2cDevAddr = TFA9879_I2C_DEV_ADDR; // 0x6D + // Obtain configuration data. + ret = AccessoryDeviceCfgGet(device->devData, &g_accessoryTransferData); + ... + // Initialize GPIO pins. + ret = Hi35xxGpioPinInit(); + ... + // Initialize device registers. + ret = AccessoryDeviceCtrlRegInit(); + ... + // Bind the control function configuration. + ret = AudioAddControls(audioCard, g_accessoryTransferData.accessoryControls, + g_accessoryTransferData.accessoryCfgCtrlCount); + ... +} +``` + +**AccessoryI2cReadWrite** reads and writes I2C registers. + +```c +int32_t AccessoryI2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag) +{ + int32_t ret; + DevHandle i2cHandle; + int16_t transferMsgCount = 1; + uint8_t regs[I2C_REG_LEN]; + struct I2cMsg msgs[I2C_MSG_NUM]; + ... + i2cHandle = I2cOpen(I2C_BUS_NUM); + ... + if (rwFlag == I2C_FLAG_READ) { + transferMsgCount = I2C_MSG_NUM; + } + ret = AccessoryI2cMsgFill(regAttr, rwFlag, regs, msgs); + ... + ret = I2cTransfer(i2cHandle, msgs, transferMsgCount); + ... + AccessoryI2cRelease(msgs, transferMsgCount, i2cHandle); + return HDF_SUCCESS; +} +``` + +### Implementing the Accessory Operation Function Set + +The callbacks **AccessoryDeviceRegRead** and **AccessoryDeviceRegWrite** invokes **AccessoryI2cReadWrite** to read and write the control register values. + +```c +int32_t AccessoryDeviceRegRead(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) +{ + int32_t ret; + struct AudioAddrConfig regAttr; + ... + (void)codec; + regAttr.addr = (uint8_t)reg; + regAttr.value = 0; + ret = AccessoryI2cReadWrite(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("failed."); + return HDF_FAILURE; + } + *val = regAttr.value; + ... + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegWrite(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) +{ + int32_t ret; + struct AudioAddrConfig regAttr; + (void)codec; + regAttr.addr = (uint8_t)reg; + regAttr.value = (uint16_t)value; + ret = AccessoryI2cReadWrite(®Attr, 0); + ... + return HDF_SUCCESS; +} +``` + +**Tfa9879DaiStartup** performs startup settings. The code snippet is as follows: + +```c +int32_t Tfa9879DaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + int ret; + (void)card; + (void)device; + // Set the working status of SmartPA. + ret = Tfa9879WorkStatusEnable(); + ... + return HDF_SUCCESS; +} + +``` + +**Tfa9879DaiHwParams** delivers playback parameters. The code snippet is as follows: + +```c +int32_t Tfa9879DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + int32_t ret; + uint16_t frequency, bitWidth; + struct DaiParamsVal daiParamsVal; + (void)card; + ... + // Set the sampling rate. + ret = AcessoryDeviceFrequencyParse(param->rate, &frequency); + ... + // Set the bit width. + ret = Tfa9879FormatParse(param->format, &bitWidth); + ... + daiParamsVal.frequencyVal = frequency; + daiParamsVal.formatVal = bitWidth; + daiParamsVal.channelVal = param->channels; // Set the audio channel. + ret = AccessoryDaiParamsUpdate(daiParamsVal); + ... + return HDF_SUCCESS; +} +``` + +### Registering and Binding Accessory to HDF + +This process depends on the driver implementation mode of the HDF. For details, see [HDF](https://gitee.com/openharmony/docs/blob/master/en/device-dev/driver/driver-hdf.md). + +Fill in the **g_tfa9879DriverEntry** structure. Ensure that the value of **moduleName** is the same as that in **device_info.hcs**. Implement the pointers to the **Bind**, **Init**, and **Release** functions. + +drivers/peripheral/audio/chipsets/tfa9879/accessory/src/tfa9879_accessory_adapter.c + +```c +static int32_t Tfa9879DriverBind(struct HdfDeviceObject *device) +{ + (void)device; + AUDIO_DRIVER_LOG_INFO("success!"); + return HDF_SUCCESS; +} + +static int32_t Tfa9879DriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + ... + // Obtain configuration data from .hcs files. + ret = AccessoryGetConfigInfo(device, &g_tfa9879Data); + ... + ret = ret = GetServiceName(device); + ... + ret = AudioRegisterAccessory(device, &g_tfa9879Data, &g_tfa9879DaiData); + .... + return HDF_SUCCESS; +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_tfa9879DriverEntry = { + .moduleVersion = 1, + .moduleName = "CODEC_TFA9879", + .Bind = Tfa9879DriverBind, + .Init = Tfa9879DriverInit, + .Release = NULL, +}; +HDF_INIT(g_tfa9879DriverEntry); +``` + +### Configuring HCS + +For details about the configuration process, see [Configuring HCS](#section4115) in **Codec Driver Development Example**. + + + +## Platform Driver Development Example +Code path: **drivers/peripheral/audio/chipsets/hi3516dv300/soc** + +In audio driver development, platform is configured to adapt to the DMA driver. The major steps for developing the platform driver are as follows: +1. Define and fill in a platform instance. +2. Implement callbacks for the platform instance. +3. Register and bind the platform instance to the HDF. +4. Configure the HCS and makefile. + +### Filling in Platform Data Structures + +Fill in the following structures for the platform module: + +- **g_platformData**: private configuration of the platform device, including the initialization and operation functions of the platform device. + +- **g_dmaDeviceOps**: DMA device operation function set, including the encapsulation of some common DMA APIs. + +```c +struct AudioDmaOps g_dmaDeviceOps = { + .DmaBufAlloc = Hi3516DmaBufAlloc, // Apply for memory for the DMA device. + .DmaBufFree = Hi3516DmaBufFree, // Releases the memory of the DMA device. + .DmaRequestChannel = Hi3516DmaRequestChannel, // Request a DMA channel. + .DmaConfigChannel = Hi3516DmaConfigChannel, // Configure the DMA channel. + .DmaPrep = Hi3516DmaPrep, // Prepare for DMA. + .DmaSubmit = Hi3516DmaSubmit, // Submit a DMA request. + .DmaPending = Hi3516DmaPending, // Pend DMA. + .DmaPause = Hi3516DmaPause, // Pause or stop DMA. + .DmaResume = Hi3516DmaResume, // Resume DMA. + .DmaPointer = Hi3516DmaPointer, // Obtain the current playing or recording position. +}; + +struct PlatformData g_platformData = { + .PlatformInit = AudioDmaDeviceInit, // Initialize the DMA device. + .ops = &g_dmaDeviceOps, +}; +``` + +### Initializing the dmaDevice Device + +**AudioDmaDeviceInit** initializes the device, including setting the Hi3516 AIAO module. + +```c +int32_t AudioDmaDeviceInit(const struct AudioCard *card, const struct PlatformDevice *platformDevice) +{ +... + AiaoHalSysInit(); + /* PIN MUX */ + AiaoSysPinMux(); + /* CLK reset */ + AiaoClockReset(); + /* aiao init */ + AiaoDeviceInit(chnId); +... + return HDF_SUCCESS; +} +``` + +### Implementing the DMA Operation Function Set + +The DMA device operation function set includes the encapsulation of DMA common APIs. If the common APIs cannot meet development requirements, you can implement new DMA callbacks. + +```c +int32_t Hi3516DmaBufAlloc(struct PlatformData *data, const enum AudioStreamType streamType); +int32_t Hi3516DmaBufFree(struct PlatformData *data, const enum AudioStreamType streamType); +int32_t Hi3516DmaRequestChannel(const struct PlatformData *data); +int32_t Hi3516DmaConfigChannel(const struct PlatformData *data); +int32_t Hi3516DmaPrep(const struct PlatformData *data); +int32_t Hi3516DmaSubmit(const struct PlatformData *data); +int32_t Hi3516DmaPending(struct PlatformData *data); +int32_t Hi3516DmaPause(struct PlatformData *data); +int32_t Hi3516DmaResume(const struct PlatformData *data); +int32_t Hi3516DmaPointer(struct PlatformData *data, uint32_t *pointer); +``` + +### Registering and Binding Platform to HDF + +This process depends on the driver implementation mode of the HDF. For details, see [HDF](https://gitee.com/openharmony/docs/blob/master/en/device-dev/driver/driver-hdf.md). + +- Fill in the **g_platformDriverEntry** structure. +- Ensure that the value of **moduleName** is the same as that in **device_info.hcs**. +- Implement the pointers to the **Bind**, **Init**, and **Release** functions. + +drivers/peripheral/audio/chipsets/hi3516dv300/soc/src/hi3516_dma_adapter.c + +```c +static int32_t Hi3516DmaDriverInit(struct HdfDeviceObject *device) +{ +... + OsalMutexInit(&g_platformData.renderBufInfo.buffMutex); + OsalMutexInit(&g_platformData.captureBufInfo.buffMutex); + g_platformData.platformInitFlag = false; + ret = AudioSocRegisterPlatform(device, &g_platformData); +... + return HDF_SUCCESS; +} + +static void Hi3516DmaDriverRelease(struct HdfDeviceObject *device) +{ + struct PlatformHost *platformHost = NULL; +... + platformHost = (struct PlatformHost *)device->service; +... + OsalMutexDestroy(&g_platformData.renderBufInfo.buffMutex); + OsalMutexDestroy(&g_platformData.captureBufInfo.buffMutex); + OsalMemFree(platformHost); +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_platformDriverEntry = { + .moduleVersion = 1, + .moduleName = "DMA_HI3516", + .Bind = Hi3516DmaDriverBind, + .Init = Hi3516DmaDriverInit, + .Release = Hi3516DmaDriverRelease, +}; +HDF_INIT(g_platformDriverEntry); +``` + +### Configuring HCS + +For details about the configuration process, see [Configuring HCS](#section4115) in **Codec Driver Development Example**. + + + +## DAI Driver Development Example +Code path: **drivers/peripheral/audio/chipsets/hi3516dv300/soc** + +The major steps for developing the DAI driver are as follows: +1. Define and fill in a DAI instance. +2. Implement callbacks for the DAI instance. +3. Register and bind the DAI instance to the HDF. +4. Configure the HCS and makefile. + +### Filling in DAI Data Structures + +Fill in the following structures for the DAI module: + +- **g_daiData**: private configuration of the DAI device, including the initialization of the DAI device, read/write of registers, and operation functions. + +- **g_daiDeviceOps**: DAI device operation function set, including setting DAI parameters and triggering and starting the DAI device. + +```c +struct AudioDaiOps g_daiDeviceOps = { + .HwParams = DaiHwParams, + .Trigger = DaiTrigger, + .Startup = DaiStartup, +}; + +struct DaiData g_daiData = { + .DaiInit = DaiDeviceInit, + .Read = AudioDeviceReadReg, + .Write = AudioDeviceWriteReg, + .ops = &g_daiDeviceOps, +}; +``` + +### Initializing the daiDevice Device + +**DaiDeviceInit** initializes DAI configuration and adds the information to the controller linked list. + +```c +int32_t DaiDeviceInit(struct AudioCard *audioCard, const struct DaiDevice *dai) +{ +... + struct DaiData *data = dai->devData; + struct AudioRegCfgData *regConfig = dai->devData->regConfig; +... + g_regCodecBase = OsalIoRemap(CODEC_REG_BASE, CODEC_MAX_REG_SIZE); +... + data->regVirtualAddr = (uintptr_t)g_regCodecBase; + DaiSetConfigInfo(data); + AudioAddControls(audioCard, data->controls, data->numControls); + I2c6PinInit(); +... + data->daiInitFlag = true; + return HDF_SUCCESS; +} +``` + +### Implementing the DAI Operation Function Set + +**AudioDeviceReadReg** and **AudioDeviceWriteReg** are not used on the Hi3516 and are reserved. + +**DaiHwParams** sets PCM stream information. + +```c +int32_t DaiHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + uint32_t bitWidth; + struct DaiDevice *device = card->rtd->cpuDai; +... + DaiCheckSampleRate(param->rate); + struct DaiData *data = DaiDataFromCard(card); + data->pcmInfo.channels = param->channels; +... + AudioFramatToBitWidth(param->format, &bitWidth); +... + data->pcmInfo.bitWidth = bitWidth; + data->pcmInfo.rate = param->rate; + data->pcmInfo.streamType = param->streamType; + data->regVirtualAddr = (uintptr_t)g_regDaiBase; +... + DaiParamsUpdate(device); + data->regVirtualAddr = (uintptr_t)g_regCodecBase; + return HDF_SUCCESS; +} +``` + +**DaiTrigger** is not used on the Hi3516 and is reserved. + +**DaiStartup** updates the register configuration and configures the I2S. + +```c +int32_t DaiStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + struct AudioMixerControl *regCfgItem = NULL; +... + regCfgItem = device->devData->regConfig->audioRegParams[AUDIO_DAI_STARTUP_PATAM_GROUP]->regCfgItem; + itemNum = device->devData->regConfig->audioRegParams[AUDIO_DAI_STARTUP_PATAM_GROUP]->itemNum; + + device->devData->regVirtualAddr = (uintptr_t)g_regDaiBase; + for (int i = 0; i < itemNum; i++) { + int ret = AudioUpdateDaiRegBits(device, ®CfgItem[i], regCfgItem[i].value); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set frequency fail."); + return HDF_FAILURE; + } + } + device->devData->regVirtualAddr = (uintptr_t)g_regCodecBase; + + if (I2sPinInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("I2sPinInit fail."); + } + + return HDF_SUCCESS; +} +``` + +### Registering and Binding DAI to HDF + +This process depends on the driver implementation mode of the HDF. For details, see [HDF](https://gitee.com/openharmony/docs/blob/master/en/device-dev/driver/driver-hdf.md). + +- Fill in the **g_daiDriverEntry** structure. +- Ensure that the value of **moduleName** is the same as that in **device_info.hcs**. +- Implement the pointers to the **Bind**, **Init**, and **Release** functions. + +drivers/peripheral/audio/chipsets/hi3516dv300/soc/src/hi3516_dai_adapter.c + +```c +static int32_t DaiDriverBind(struct HdfDeviceObject *device) +{ +... + struct DaiHost *daiHost = (struct DaiHost *)OsalMemCalloc(sizeof(*daiHost)); +... + daiHost->device = device; + device->service = &daiHost->service; + g_daiData.daiInitFlag = false; +... + return HDF_SUCCESS; +} + +static int32_t DaiDriverInit(struct HdfDeviceObject *device) +{ +... + DaiGetConfigInfo(device, &g_daiData); + DaiGetServiceName(device); +... + OsalMutexInit(&g_daiData.mutex); + AudioSocRegisterDai(device, &g_daiData); +... + return HDF_SUCCESS; +} + +static void DaiDriverRelease(struct HdfDeviceObject *device) +{ +... + OsalMutexDestroy(&g_daiData.mutex); +... + struct DaiHost *daiHost = (struct DaiHost *)device->service; +... + OsalMemFree(daiHost); +} + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_daiDriverEntry = { + .moduleVersion = 1, + .moduleName = "DAI_HI3516", + .Bind = DaiDriverBind, + .Init = DaiDriverInit, + .Release = DaiDriverRelease, +}; +HDF_INIT(g_daiDriverEntry); +``` + +### Configuring HCS + +For details about the configuration process, see [Configuring HCS](#section4115) in **Codec Driver Development Example**. + + + +## Adding Compilation Configuration to Makefile + +Add the newly added files to the **Makefile** file to link them to the kernel image. + +Standard system (Linux): **drivers/adapter/khdf/linux/model/audio/Makefile** + +```makefile +obj-$(CONFIG_DRIVERS_HDF_AUDIO_CODEC) += \ +$(KHDF_AUDIO_HI3516DV300_DIR)/../tfa9879/accessory/src/tfa9879_accessory_adapter.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/../tfa9879/accessory/src/tfa9879_accessory_impl.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_adapter.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_impl.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_ops.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/dsp/src/dsp_adapter.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dai_adapter.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dai_ops.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_aiao_impl.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dma_ops.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dma_adapter.o \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_adapter.o +``` + +Small system (LiteOS): **drivers/adapter/khdf/liteos/model/audio/Makefile** + +```makefile +LOCAL_SRCS += \ +$(KHDF_AUDIO_HI3516DV300_DIR)/../tfa9879/accessory/src/tfa9879_accessory_adapter.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/../tfa9879/accessory/src/tfa9879_accessory_impl.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_adapter.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_impl.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/codec/src/hi3516_codec_ops.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/dsp/src/dsp_adapter.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dai_adapter.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dai_ops.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_aiao_impl.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dma_ops.c \ +$(KHDF_AUDIO_HI3516DV300_DIR)/soc/src/hi3516_dma_adapter.c +``` + + + +## Source Code Structure and Directory + +The development example implements the functions in the header file of the driver interface. The following uses Hi3516 as an example to describe the directory structure. + +Path of the driver implementation sample code: **drivers/peripheral/audio/chipsets** + +``` +├── hi3516dv300 +│   ├── codec +│   │   ├── include +│   │   │   ├── hi3516_codec_impl.h +│   │   │   └── hi3516_codec_ops.h +│   │   ├── src +│ │ │ ├── hi3516_codec_adapter.c // Codec driver entry +│ │ │ ├── hi3516_codec_impl.c // Implement codec hardware operations +│ │ │ └── hi3516_codec_ops.c // Implement codec driver APIs +│   │   └── test +│   │   └── unittest +│   ├── dsp +│   │   └── include +│   │   └── dsp_ops.h +│   │   └── src +│ │ └── dsp_adapter.c // DSP driver entry +│   │   └── dsp_ops.c +│   └── soc +│   ├── include +│   │   ├── hi3516_aiao_impl.h +│   │   ├── hi3516_dai_ops.h +│   │   └── hi3516_dma_ops.h +│   ├── src +│   │   ├── hi3516_aiao_impl.c +│ │ ├── hi3516_dai_adapter.c // DAI driver entry +│   │   ├── hi3516_dai_ops.c +│ │ ├── hi3516_dma_adapter.c // DMA driver entry +│   │   └── hi3516_dma_ops.c +│   └── test +│   └── unittest +└── tfa9879 +    └── accessory +    ├── include +    │   └── tfa9879_accessory_impl.h +    └── src + ├── tfa9879_accessory_adapter.c // Accessory driver entry +    └── tfa9879_accessory_impl.c +``` + +HCS Files and Directory + +``` +Standard system: +vendor/hisilicon/Hi3516DV300/ +└── hdf_config + └── khdf + ├── audio + │   ├── audio_config.hcs + │   ├── codec_config.hcs + │   ├── dai_config.hcs + │   ├── dma_config.hcs + │   └── dsp_config.hcs + ├── device_info + │   └── device_info.hcs + └── hdf.hcs + +Small system: +vendor/hisilicon/hispark_taurus/ +├── config.json +└── hdf_config + ├── audio + │   ├── audio_config.hcs + │   ├── codec_config.hcs + │   ├── dai_config.hcs + │   ├── dma_config.hcs + │   └── dsp_config.hcs + ├── device_info + │   └── device_info.hcs + └── hdf.hcs +``` + + + +# Development Procedure and Example Using HAL +Code path: **drivers/peripheral/audio/hal** + +## Development Procedure + +![](figures/HAL_flowchart.png) + +1. Call **GetAudioManagerFuncs()** to obtain functions. + +2. Call **GetAllAdapters()** to obtain information about the supported audio adapters and call **LoadAdapter()** load the corresponding audio adapter. + +3. Create an audio player class by calling **CreateRender()** or create a recorder class and deliver audio attributes. + +4. Call the methods mounted to the created audio player class to call **render->control.Start()** and **render->RenderFrame()** to dispatch the start instruction and deliver audio data cyclically. + +5. During the playback, call **render->control.Pause()**, **render->control.Resume()** or **render->volume.SetVolume()** to control the audio player service, for example, pausing the playback, resume the playback, and adjusting the volume. + +6. After the audio player service is complete, stop the playback, destroy the audio player class, and unload the audio adapter. + + 1. render->control.Stop(); + + 2. adapter->DestroyRender(); + + 3. manager->UnloadAdapter(); + +## Development Example + +```c +#include +#include +#include "audio_types.h" +#include +#include "audio_manager.h" + + /* Open the dynamic link to the so library. */ +char *soPathHdi = "/system/lib/libhdi_audio.z.so"; +void *g_handle = dlopen(soPathHdi , 1); + +int32_t FrameStart(void *param) +{ +... + /* Send audio data cyclically.*/ + do { + readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize; + numRead = fread(frame, 1, readSize, g_file); + if (numRead > 0) { + ret = render->RenderFrame(render, frame, numRead, &replyBytes); + if (ret == HDF_ERR_INVALID_OBJECT) { + LOG_FUN_ERR("Render already stop!"); + break; + } + remainingDataSize -= numRead; + } + /* Pause the playback and wait.*/ + while (g_waitSleep) { + printf("music pause now.\n"); + pthread_cond_wait(&g_functionCond, &g_mutex); + printf("music resume now.\n"); + } + } while (!g_closeEnd && numRead > 0 && remainingDataSize > 0); +... +} + +static void *hal_main() +{ + /* Map and call the entry function.*/ + struct AudioManager *(*getAudioManager)() = + (struct AudioManager *(*)())(dlsym(g_handle, "GetAudioManagerFuncs")); + struct AudioManager *manager = getAudioManager(); + + /* Obtain the audio adapter list.*/ + struct AudioAdapterDescriptor *descs = NULL; + int32_t size = 0; + int32_t ret = manager->GetAllAdapters(manager, &descs, &size); + + /* Locate the audio adapter and port based on the specified audio adapter name and port description.*/ + enum AudioPortDirection port = PORT_OUT; // The port type OUT means to play the audio. + struct AudioPort renderPort; + char * adapterNameCase = "usb"; + int32_t index = SwitchAdapter(descs, adapterNameCase, port, &renderPort, size); + + /* Load the audio adapter based on the matched audio adapter information.*/ + struct AudioAdapter *adapter = NULL; + struct AudioAdapterDescriptor *desc = &descs[index]; // obtain the device based on the matched audio adapter information. + manager->LoadAdapter(manager, desc, &adapter); // Load the audio card and obtain the audio card instance. + + /* Create an audio player class.*/ + struct AudioRender *render; + struct AudioDeviceDescriptor devDesc; + struct AudioSampleAttributes attrs; + InitDevDesc(&devDesc, renderPort.portId); // Initialize device parameters. + WavHeadAnalysis(g_file, &attrs); // Parse the audio file to set attributes. + adapter->CreateRender(adapter, &devDesc, &attrs, &render); + + /* Deliver the number of the audio to be played.*/ + render->control.Start((AudioHandle)render); // Dispatch the start instruction and prepare for the action. + pthread_create(&g_tids, NULL, (void *)(&FrameStart), &g_str); // Start the thread to play the audio clip. + + /* Control instructions*/ + render->control.Pause((AudioHandle)render); // Pause the playback. + render->control.Resume((AudioHandle)render); // Resume the playback. + render->volume.SetVolume((AudioHandle)render, 0.5); // Set the volume. + + /* Stop playback and destroy the audio player class.*/ + render->control.Stop((AudioHandle)render); + adapter->DestroyRender(adapter, render); + /* Unload the audio adapter.*/ + manager->UnloadAdapter(manager, adapter); +} +``` + + + +# Summary + +This document provides all the key adaptations involved in the driver development based on the audio driver framework. It elaborates how to adapt the audio driver and use HDI APIs. You can easily develop your audio drivers based on the chip you use by referring to this document. diff --git a/en/device-dev/driver/driver-peripherals.md b/en/device-dev/driver/driver-peripherals.md index aee10257e6..4b65137ea6 100644 --- a/en/device-dev/driver/driver-peripherals.md +++ b/en/device-dev/driver/driver-peripherals.md @@ -2,10 +2,12 @@ - **[LCD](driver-peripherals-lcd-des.md)** -- **[TOUCHSCREEN](driver-peripherals-touch-des.md)** +- **[Touchscreen](driver-peripherals-touch-des.md)** - **[Sensor](driver-peripherals-sensor-des.md)** - **[WLAN](driver-peripherals-external-des.md)** +- **[Audio](driver-peripherals-audio-des.md)** + diff --git a/en/device-dev/driver/figures/ADM_control_flowchart.png b/en/device-dev/driver/figures/ADM_control_flowchart.png new file mode 100644 index 0000000000000000000000000000000000000000..00a26d1734c32a2c7c2ae76e2bc5c12ffbf55870 GIT binary patch literal 35853 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 miF#*`75@iz^4X=!@ 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 K&t;ucLK6Vh0UlZa literal 0 HcmV?d00001 diff --git a/en/device-dev/driver/figures/ADM_startup_flowchart.png b/en/device-dev/driver/figures/ADM_startup_flowchart.png new file mode 100644 index 0000000000000000000000000000000000000000..bc43d5f1d86a8de056b8ef52c8fdb8c08c3ff446 GIT binary patch literal 90137 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 literal 0 HcmV?d00001 diff --git a/en/device-dev/driver/figures/Audio_architecture.png b/en/device-dev/driver/figures/Audio_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..e6b4c9f2609f3475cdd6fd72ff7e294f7b675696 GIT binary patch literal 120 zcmeAS@N?(olHy`uVBq!ia0vp^j3CUx1|;Q0k92}K#X;^)4C~IxyaaMs(j9#r85lP9 zbN@+X1@buyJR*x382Ao@Fyrz36)8YLUQZXt5Q*^QAOHXVuV>)=&HR_u+4U4qg2B_( K&t;ucLK6Vh0UlZa literal 0 HcmV?d00001 diff --git a/en/device-dev/driver/figures/development_flowchart_1.png b/en/device-dev/driver/figures/development_flowchart_1.png new file mode 100644 index 0000000000000000000000000000000000000000..b47cf0d077853bc52f74c1a1da62d3c0d54f6e2b GIT binary patch literal 9698 zcmbVycR1T`+c%1I+PjFV8Z9M8#foaF+EiPjMv2u@ni{oYbr>;Pw5U{!+A~&Bvv#Xd zqjrr@u}6uK2+vo0KhN{K@Ar6*_c-1^WVpV$#<{NZ{Cv&`V?*sTC;3j&(9oRGxv6=J zhK7y^e0Dv~2)uT!@soi!T8~@W*Jz6I{0qPrdM6D74H_C;?5TZQ2H^XN$2Z{~G&D>t zM}M>(?z#3fG#8%gXlmT{v0i!aGVgF_uR|*5tj@z@4kYf8ki1N>&t zU;}kq$q6er$*hVg9|{~S9~@nRyP$%IPXpz|?zHnDq9E-_I`@%oz&j73TeB3Z_~)OF z!seK>M}s_atdjWXqrs@;<6OkQztE>gd;A$hh=#V+{27F>HxtJHP8acinXW&64YlU~ z18u#Pu}DBm7jG|*Aj%a+vl6W>etPyBpqGy(dWVB5W{a))4SmXwH&o86ozFn$qbS>V z{C8F>M{a$Zjnm6FHB`#-o0G%VbP58S$WF!+_9qVyo_fu8vZfTp{|q{$qPs_66V%nG zX0g8Ahrs{a$?STiQcP_@=LZqCQ=_%*%DsDz^yN|s=6%S>@S`gV z&WoEp>W#HCF)CcVxBGQ4K}40wWGdfbenD~m#QICcVb|!FCH|@e*4W(D+NI*Z3kFff zCb=%OCyaO_55|eGr=s2E^-YeZpXT1V+OnvGMa{z5i3v;Kv3plQOIQU(!Lz5gv!M)eE0Pj)5FU$xAke$Q`Syy9 zjo6@Z!gvycSSU1T`jky|wQP1bpq-sXTr6sN5WUHan!k=_Lwwm^4^yvzDi*W=5Ay-m zGzZw5DFW$sHxe)?1;Eg{j|`!mFkZ+3j6MWxFc}!tk8Z1hOK=fen!$rbgxICP^=IJj zL3wM%7m5uV(LdG#cRsb{1&c0Ln#F!XEAuov4r4 zh{?>wQusu4Tg}41)^yA=$1rygR67U(wdRn{5X|pXme#|{m89i)Q=9s1a z{aBmRSF7`VvYc;g=+NrW>TY~>;mm(d_a;;^(qquXB+{jwo?~jAA*z={Z2L?rq|Dvo z<&JZ#%w-Dp_1+X;`$1_B|FJ1K(JkBe@9mIo-TZ&W^i3BB1sie{n?OUwEor}qPi0;e z&ApBlze*Cc<);I$oNc0-GdplJR&!HyoAFgM%uK;l1YET4JRl9k;T9Yxy)4~Kg$||z zhnMU4tDN#%lK8M=8o3!V>>qnU&Tx(&nhZIS9w%={I|MNgGC$(j&pgBgOc!}qFr#XomfzRpS5h#l)sEz1<3N`mJy$UPQ#PvMWi-#PI zK42}^EnZ=Kc>^7(`BL$l;VUI6t-f=aD=aIfu3`2lz9ZfL+a^uAS2Zy%YON+XUM-2X z+{oJlL*6gLJ*qNcIO$}T80rjZn7}_(UlmJ+*Z&_=2=)_4ql`0{Cq71auwXe;+syyUIDnsEUBtCB^uDQ{_sU!v z=dwM~NJK@h{eBsNAM%56PFeI_x3d^KpJ|4at!@uGte(=dYq-QkTmrnr!WKthKD zv84M3)Z4>gl0+qVC%pRQ53$Acc|Elp2Lwa{IUy>{Y53CZVu0~;_Q+}xGL5Cnr&@U1 z34C1e%Di28mmYXUy6MBi!!q;NNiwYCGd{zyw{B@et$8T0BfA~|6me|l8{6;@K`^{N z(O*DvtkFyT`GQjVFPUAtpdl)MF7x7&5_ivu3?~*;^;*lYnbb3dl@X+5R8Q6V7ysnp z`Tju`Nqk3$i^gX1{TMGdg`S(1dM25{Ngun5s@n;E!A7pq+b8S;N3Au7!s9BzsP9!( zC9rPaCP+ImvTXPel9T||#_Ue%wuTwXGsf$)zl_gyz*)6A*i9+Gd<=OI_ULn>?t|Qh zRc~o4xYo(L$hPk# z-JzC%42mJr_sWIC__){k?;q;o5|&l(W6fic!`d<*iW-h&uqiM1?GD~{fDxxU2Myos z*$4Pe9at&h*{#Ev05u>%|cNWshYSn{|F;Z2QLPwm&g%6FKj3)zKgF zooBppW&+&vZ20oF-s(?R?dia7o(+spc(YvYKw{zPAp<9EZ^0&Yn2MTq^Q)>q){?a! zBg3uRj)_uYvYQa*ek@>ncKOsqhiadtShCIC8^hplE-Y9ruJbWQsP#yfhMwPQ{xF10 zO-W^|&P9{oKMXGD^(Eb=8B(_8Q<*phVXdu*-%C4_@TTy&s6OK=u4lw2EEEcVvJK>0 zp0s;s88nCLZR1M;r-Xq-ev6NFRBJ!$Yl!gk6Kp*?uoG&rOx>ly31+hO>Xy~j$e_6U$(b*IfXMxRD$=3;G}&@mO%DCy9JQJ5z>*t6*+c#qZfWq{&~&I1wM>uPj&<-|Ww? zS7m%WAcg#c0mywAhYYKjUC;gvptL_-^e6?Z1tUtdgoE&MjUG^R^v+0nG-Vw73D62~ z+*kj$!3{ry9G=%?!>aE-qAT0~x?d*y`Jf5v1_KG4C3n^_@;Am9 zjZLH2mNF-C2j=>^m}9Wh?~P$TC~?VtonOy{;c;cwrk|b5TImre9SAcy9@#dg*Ykk(34=p7uX)v8MO(8%luO8t z*O}hxx4IB712$5>0)5gLL~tzmByhwK{?2WwVE^vvKI4CU1^* z2X(!bG|6IalEe>0N;S6Gua=3B6dZ$azJ~%*jIf5yYe5#>FOp``64-MKaD+f~S@n(b zKj+M#HeZq&TO+{;Z5ufLDbAsj0dO!ihBQMm78S#5s2ba5>6n1sL`C%aB=a5@Z6L~8 z4<3K^B$R(>x-`~BzUEm5{}>@@%Q5~nm3t}A;n4=K)>rZbH+qxwS#@AvyP@M71FV)Y z!>HSxW$4U=HrAC2kxsUWDyqrD@t$`e%z>M1S;!H#+0@>i0g~$sATV+aF)({x5F`ha#9?;#u2SB&(d1t5WpCr^ zeBMOq9)}W%VqK}pZ zDzGscd}4L#%lpU)x+|sCIu0qx3oilPIxEkcf0c`V~CS}ln;>rigp8|bxE1hQzyvrS4LhkW72j;Ri+%m$y&goQo_rjO=e{)b9>EzOAJ03d4$m3+=Wk+PjZX1mrp6qMFXA6C~M9#FV1 zv;bPPO3sHK_QnR@rY@Q_T3DU|GNdgacorr|M0$k3w)*6K$0+c3e1S_zeHFP~vB8A8 zi9NI&U+EZVQ<}<|lIN_U5l*@GY4(^MKj$uuR|XWs$IaLqC0i7`!)My2)XRetKyOY5 z{Eo*K8p8Hw7vVjAcS#L9^(D%Wr<(4kyCL0bW$z#ZNk7bbG)ZWieZnF;cDEJjuM5rw z($e~h6RVqK+b-qg&oKNZ16NNfE~x@)vptn~=D8M!q4LSpwV=lJhd>Ra z65fM=6Mxya`7W4#G_Z>l26<%Jn3*e>auVm+QwZGoAM1We{rK2OU0Iy(%|u%O znP)b0iV*&X(10{hyDtKh1(ARa6yC|jIuld_^A%_LThdGXw=VWvt7xk^_{`lIbIHRuj)5cDXLw}FK}EUG6(IpWO#q8ZB?3!Le28uK*mt5J2Gs3+FA>V z{m|b0uyrTCP%2u(_UvYTml%bXhZ;*ow^H^W>e}#x&Dae3D(N7LyXa>`9^Z1_2$@RX z&~Vt{G&~*6Ueem7*(eN&sp@JdRnOw#O%Q5dY9m9RJAqVo_4fHxv~&mx^De*+YkBOWheENIsf=+7hC`B zSsTRXZl0elk`z>wJaV3L)&TxCc=(?D;G`zA1G4 z^5a&aZuL94P~@Ji*iV>O|?ZoiN5mC7BBiA|$gOeWoo= z7QsNH3wHEcm2r&$T%$p+Dzk>>8{f7;#bc4kpM#UIfMo=@K=Ajgu-gE>Q*`;$a#`ir zuS6RdJLeHj;Diu(xErGkGYM+DWDQZdFNrtcekGlQd7}F+Wl5$GwEsQ%myg*q~C#7bj zP3-GebFp>}b-M$(r(sPbwxO0J*C^tsdT!cmK@L?ef%#Q^+xDfMRdCaA^ z)a8Z~ixCmTvt##DP$AGT7T8RbTwk4K;>tw5|CQqOm*Be_q+$RME4ht9G?Z0_DIu7I zdpwyU-pWZ6>Ykhdq@y`@kpvpESf^?#6 z4QXFnE*sp=<4-#?o*5z<6zT`*C5zB=Geplg`MTaiZPkcpL9>!*ej$6$IP^Dq6u&g` zu|6aZnb`o*z90xtVY&Gc>`1NT>Q9ykB=R>#_WZ8zT5pjG>_l~_Oh714(+^1{LEr48 zW?ZC3Z1qc}6IU~_$7ZPtPPWT|aIs~3}6AH;LQc0k>=b=io z{L>0c>SrDoBk;(-g6QMFBQO1FSN_+9UawnU?vS@=QTe2(xiyxj$z zj$%NlLs`@0r*+>tTai1xZReTeU(ZNa7Qx7t3AZq}^n;(k65p3C5cbDCdfub19lR+C zaPUsjd`kkQcWP|gz7aB$7yBM7S(2@r`0a^R50`5hG)zeSaDUSYdt6vsyz`C2zJ~Jy z_w!l&TD+U*#=?+Tf3;rO)z`^4(~Y>NY38;24+!u4<-hY}`COE@10P>}Fn&|@*t_-& z#9iHAR>Pji7&-gN22{BdjmE*$Gv>>}-Eb24`P-vp^kZDCtjL;<>!q>S>6W@>LVrTy z^CjAbEhlSs;Is$JAdNBcp3&hGXQlDeEnOX`T?JOfw5VGd=>qL*Y#<#j_M)O#cm__L zKPc}JscV$+Naa~hkOYJM9F86(B4&h<3ILNe%AWJzGw$MLTYVGjtQoT~!yLLUSK&kD z7gBahD%Y9Q8xN^#IiZ&Dm(U?K^-NE&LwA_#M0vg0*J{C1v5S0{Rudtj6EmI}v#`SoLI3DSy3dH3C*zeb|w;KUa^bjj#c2^3Y z%>J$fV>+iXcg(XmnHz#Fean-R-~qpPatSi|X}7hiqU1RedUc@=-XU-We zw-}CmS;Ks!#X?PLA#DbcX{cyyn@Jh$BMDN_a!^`S7z7C^_Z}t8tFgrgu? z3PD!ipqXj1Q}_Pd9_}F;ZYa#Af!duK?G%(DINMD(h#p^Z4tV<@^dWZL8WCCrbA*gs zUS+j(Is9&z!c5MB1!M;>xvGe!whv2~au9ddC=kPaNS}-K=DWqC{OLYYtqMx4>yyz& z&d~bA%DS0vP4oAAxN+>*iMH31u{+5kPAis{rT>`SA62Bh>`A7L=k1yWiUXZ;GaEJ_d;R2LJG4qLv2 zG6$82#5fgdo(BZR(q}{NOU!RPAeErwrV9!29{AU8!j@;d4am-Tp$-MZs$`%v2G@?1 zH59)ezL6NHNie@^sTUv`z-YB--|95xq`xQ!B*#D+yiY7YHr@I9JTQ;sb&N-hyt|TE z=a0)CJVb#eu~a3CcG9ahiC^i1Lol}S>&e@k4$4)-(se^iJc`>PX)#so)4RIJQF1dG z_p@044hA8$KP#sGfI9hj%sdf_RknKKDCT>I&P9KdTd1Sv?a(*-wwe*cY;k;t{X>G~ z3mTL;7xO)ahK*9jbt0`zeylPFw-uSy_LDL!ZD^D+B4vdI3G>vyo}2*%$2)|3gen=M z_cC?}n08;#$hZsdCYuA_y)g$j4}tb1+~s}q8^elk+jwYv4Z!B6;Nx~ecTdE``u@Da z#X`ZwD?sibVO(OhP$z4b;&#j;L5{w4VBFo}yy;P;z=7U8&^#A%hGD2Sr0rXFR~Sf~ zX%H5s@co$eb%dFdah*0wwSSk1dp*dLj;aIkCT6GKldtJje zK-~*aA4iz@f72h-5qV^BMzx-LZLrU>9+%v8ib+NR)ctHfQ0OUw(3`*h`Rsx)UV>lT zM-D3n50# zI?~BTj!H5uX}sDD)WK}RN@yoCqdXV1H7QqjPxFMWI9pnFG;DDauXo5FQ8xdmAAN%| zg6TQJE6!mt?Cog}1j6qnn9Sxw#Viy97sqqJCztXboNgjs>j%ryU{C13Xoyq0*W_1v z`G5AK$h`c*fU;}6b)9o{CQB{g-pEblghQEO!U?GewCJndM_BR80B`l*EKvj8bMKYI z@!fT?K%pnXWtD_|&E`L#b_(oYfO~l<)aEi5@oY@nUIkEZAJyEBz~{NEwuYu^%_Y=c z!q6Fn6;GpZXX9GB#*9{dSk+WcLvm8=PH(IM8};ltypodq$yyr_0n`NW*$1IHq6l^uR4LZz+rgG!$FXe2fDU@tK`3 z9ec}$rGqKBiG<`jXoqHNSIo7yL(0v_YY+*(upPMA1nAvuA-%}s@ysY;SH1WPRp2EW z02YQ!e-}$&w`}2nfiqyZGoi@#gQ$>yu9oYStK(zvP0LQHf}uEbLfER+Hydd#_V5zh zjN$t(v`1@9sJ!7_4s6;tZLxfpTMjy`wgM|2%cs7VEyHYqE9$um+r)=1P|vxurg;H5 z|DxXjW^41C@I!%z32}L%p$*^tzl)1R&gTO6F3S(7GiXh&$Q}t34ljy7NwC-2IFVtb zFH+}p?fXaj!uShX_Wi9&)=24c2az&BzpsC74e<17?`9ZUnijPFB}!7X#ywIz_1QTV zqsmQ@6Cd74;F%++>ubgmCiBPJ#>E8|+*dXB59KY5+?< zl*K_ORm(7`eAmf5J0V^G_5EkR=T~d0-TGa4EtpFHGKywx1|F;oD6~(W6;lX>2YJE)^g}%rvRh$Dkeb0W28g(V_Gbxym_PMsD2)K@2TD zx}_|*u4|~yN-OH}C~7~_^T4d94w?*$@lo1ga$zKRsbRbk|9R9OlLq)RMdsC&T5S)T ztTw8Z!U==Qm#Zt`T0!KgDTT*(brJ0y*xAJrj5+2*^he_^ z>P6n#7r z>%Ex!{JV>eUDbY#^n~Ux-$LZD_wp%JMdP^r2~@>l^`Pu_ER_Lgy)~^o?KOxW{uiGq z$&NX1vZJ3I%|dkaKY|EPj)}j*(VC1q3Uj6vegmaN3BM6eSr2Pr+W>)Bf{xShfl!fN z!ByBtW&FopcwP~W$(+r6#A4}0kNyl3%*PYo z#UGwnl)1r3?gFsE?TD%&#dT90%iTi{f#~~yr)*j9;S$N10Hom zanH~;=cgFS(?Pz?}BQENg-Z{l~WCQ0S0(a*sK|l4^G3r~jlmRdqwzK6BDtX%OScD^3yE!i)(Z<-cf zV@Z5|X;Cx12q1S|^-$}A4w{r3kBd;<0npW5*Qry(OeM6%h@g&tIp1H@51`m!EKTOm zDt4*Pk%oMl4>;mj^5 zKcCuE9zh!1M4$wm$!JZI1u^jtCj(6qbH^V8P@oxQXYJz%-^v~UXz61ny@ssNr$>QY zzyNGWj|{{s5kL5ce9PXRQ*5jmt#mQ-qLPNB%bY$zeb%S+F>60RDGD?K!vLP?mtEvu zPa4!>{Nc$)`~!ZriotNo0K8LRYNYnV(M5iLlnrzx@I_5DV5%_JPteBgQI`TaJoNm} zQ?6CcvHs&T`S;vv9A2x9wY@&Cebj98El}lE^iM}qm6eMA{7t+{NiB7IjQdZQ%CjR- zR`dpwfU)2VY^ep{#CI+ zyAAx(h%)c*SpaG}>a)QE4MTFo_iF*fWiyjRD{r`08>iV(+l!HQ75u3Ch?g7iFu&iG zC8#35=2O3F&W7(~11WLmD%s X9Imu`xO+ff7LAUUp=R;5`=S2@zX4~h literal 0 HcmV?d00001 diff --git a/en/device-dev/driver/figures/development_flowchart_2.png b/en/device-dev/driver/figures/development_flowchart_2.png new file mode 100644 index 0000000000000000000000000000000000000000..bd820389e4e5f5e8ee39e3d5208513c20a64d494 GIT binary patch literal 9744 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