diff --git a/include/audio/audio_accessory_if.h b/include/audio/audio_accessory_if.h index a86532d2d329b26642f974bd2dbb2b48d2df6a4a..bd753a630a8c5155361e8212ee887a4797e2bea2 100755 --- a/include/audio/audio_accessory_if.h +++ b/include/audio/audio_accessory_if.h @@ -46,11 +46,9 @@ struct AccessoryData { int32_t (*Init)(struct AudioCard *, const struct AccessoryDevice *device); int32_t (*Read)(const struct AccessoryDevice *, uint32_t, uint32_t *); int32_t (*Write)(const struct AccessoryDevice *, uint32_t, uint32_t); - int32_t (*AiaoRead)(const struct AccessoryDevice *, uint32_t, uint32_t *); - int32_t (*AiaoWrite)(const struct AccessoryDevice *, uint32_t, uint32_t); - const struct AudioKcontrol *controls; int numControls; + struct AudioRegCfgData* regConfig; }; #ifdef __cplusplus diff --git a/include/audio/audio_codec_if.h b/include/audio/audio_codec_if.h index d0636abb4f266dd0f358612267a51dcc5a85ac79..d18d99da6b550ca97fa95d91b7aded7ccfa02ce2 100755 --- a/include/audio/audio_codec_if.h +++ b/include/audio/audio_codec_if.h @@ -26,11 +26,6 @@ extern "C" { #define AUDIODRV_CTL_ELEM_IFACE_PGA 5 /* PGA device */ #define AUDIODRV_CTL_ELEM_IFACE_AIAO 6 /* AIAO device */ -struct VirtualAddress { - unsigned long acodecVir; - unsigned long aiaoVir; -}; - struct CodecDevice { const char *devCodecName; struct CodecData *devData; @@ -44,16 +39,17 @@ struct CodecData { const char *drvCodecName; /* Codec driver callbacks */ int32_t (*Init)(struct AudioCard *, struct CodecDevice *); - int32_t (*Read)(const struct CodecDevice *, uint32_t, uint32_t *); - int32_t (*Write)(const struct CodecDevice *, uint32_t, uint32_t); - int32_t (*AiaoRead)(const struct CodecDevice *, uint32_t, uint32_t *); - int32_t (*AiaoWrite)(const struct CodecDevice *, uint32_t, uint32_t); - const struct AudioKcontrol *controls; + int32_t (*Read)(unsigned long, uint32_t, uint32_t *); + int32_t (*Write)(unsigned long, uint32_t, uint32_t); + struct AudioKcontrol *controls; int numControls; - const struct AudioSapmComponent *sapmComponents; + struct AudioSapmComponent *sapmComponents; int numSapmComponent; const struct AudioSapmRoute *sapmRoutes; int numSapmRoutes; + unsigned long virtualAddress; // IoRemap Address + struct AudioRegCfgData *regConfig; + struct AudioRegCfgGroupNode **regCfgGroup; }; /* Codec host is defined in codec driver */ @@ -75,6 +71,7 @@ enum AudioRegParams { INTERNALLY_CODEC_ENABLE, RENDER_CHANNEL_MODE, CAPTRUE_CHANNEL_MODE, + S_NORMAL_AP01_P_HIFI, }; enum SapmRegParams { diff --git a/include/audio/audio_dai_if.h b/include/audio/audio_dai_if.h index f6e756edf903ea7a95e21f1da0d58a64f11f7561..603e938a5d9a2bd3b623bc60ab84990b73fb6e4e 100755 --- a/include/audio/audio_dai_if.h +++ b/include/audio/audio_dai_if.h @@ -15,6 +15,10 @@ extern "C" { #endif #endif /* __cplusplus */ +#include "audio_host.h" +#include "audio_parse.h" +#include "audio_control.h" + struct DaiDevice { const char *devDaiName; struct DaiData *devData; @@ -24,16 +28,27 @@ struct DaiDevice { struct AudioDaiOps { int32_t (*Startup)(const struct AudioCard *, const struct DaiDevice *); - int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *, const struct DaiDevice *); + int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *); int32_t (*Trigger)(const struct AudioCard *, int, const struct DaiDevice *); }; struct DaiData { const char *drvDaiName; /* DAI driver callbacks */ - int32_t (*DaiInit)(const struct AudioCard *, const struct DaiDevice *); + int32_t (*DaiInit)(struct AudioCard *, const struct DaiDevice *); + int32_t (*Read)(unsigned long, uint32_t, uint32_t *); + int32_t (*Write)(unsigned long, uint32_t, uint32_t); /* ops */ const struct AudioDaiOps *ops; + /* DAI DMA data */ + struct PcmInfo pcmInfo; + struct AudioKcontrol *controls; + int numControls; + bool daiInitFlag; + uint32_t regDaiBase; + struct AudioRegCfgData *regConfig; + struct AudioRegCfgGroupNode **regCfgGroup; + struct OsalMutex mutex; }; /* Dai host is defined in dai driver */ @@ -41,7 +56,6 @@ struct DaiHost { struct IDeviceIoService service; struct HdfDeviceObject *device; void *priv; - bool daiInitFlag; }; #ifdef __cplusplus diff --git a/include/audio/audio_platform_if.h b/include/audio/audio_platform_if.h index c2cc766b839dbbe38d708e6049706371cd5ac015..586a57cd9825d27b954e9a2bfd9eedd9ef9213e7 100755 --- a/include/audio/audio_platform_if.h +++ b/include/audio/audio_platform_if.h @@ -44,6 +44,12 @@ extern "C" { #define GPIO_BASE_ADDR 0x120D0000 #define BASE_ADDR_REMAP_SIZE 0x10000 +enum PcmStatus { + PCM_STOP = 0, + PCM_PAUSE, + PCM_START, +}; + struct CircleBufInfo { uint32_t cirBufSize; uint32_t trafBufSize; @@ -54,48 +60,47 @@ struct CircleBufInfo { uint32_t *virtAddr; uint32_t wbufOffSet; uint32_t wptrOffSet; - uint32_t runStatus; + uint32_t rbufOffSet; + uint32_t rptrOffSet; + enum PcmStatus runStatus; uint32_t chnId; uint32_t enable; struct OsalMutex buffMutex; - uint64_t framesPosition; + uint32_t framesPosition; + uint32_t pointer; + uint32_t periodsMax; + uint32_t periodsMin; + uint32_t cirBufMax; + uint32_t curTrafSize; }; -struct PcmInfo { - /* The number of channels in a frame */ - uint32_t channels; - /* The number of frames per second */ - uint32_t rate; - uint32_t bitWidth; - uint32_t frameSize; - bool isBigEndian; - bool isSignedData; - uint32_t startThreshold; - uint32_t stopThreshold; - uint32_t silenceThreshold; - uint32_t totalStreamSize; +struct PlatformData { + const char *drvPlatformName; + /* platform driver callbacks */ + int32_t (*PlatformInit)(const struct AudioCard *, const struct PlatformDevice *); + /* platform stream ops */ + struct AudioDmaOps *ops; + struct CircleBufInfo renderBufInfo; + struct CircleBufInfo captureBufInfo; + struct PcmInfo pcmInfo; + bool platformInitFlag; + struct AudioMmapData mmapData; + uint32_t mmapLoopCount; + void *dmaPrv; }; -/* platform related definitions */ -struct AudioPlatformOps { - int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *); - int32_t (*RenderTrigger)(struct AudioCard *, int); - int32_t (*CaptureTrigger)(struct AudioCard *, int); - uint32_t (*Pointer)(struct AudioCard *); - int32_t (*Write)(const struct AudioCard *, struct AudioTxData *); - int32_t (*Read)(const struct AudioCard *, struct AudioRxData *); - int32_t (*MmapWrite)(const struct AudioCard *, const struct AudioTxMmapData *); - int32_t (*MmapRead)(const struct AudioCard *, const struct AudioRxMmapData *); - int32_t (*RenderPrepare)(const struct AudioCard *); - int32_t (*CapturePrepare)(const struct AudioCard *); - int32_t (*RenderStart)(struct AudioCard *); - int32_t (*CaptureStart)(struct AudioCard *); - int32_t (*RenderStop)(struct AudioCard *); - int32_t (*CaptureStop)(struct AudioCard *); - int32_t (*RenderPause)(struct AudioCard *); - int32_t (*CapturePause)(struct AudioCard *); - int32_t (*RenderResume)(struct AudioCard *); - int32_t (*CaptureResume)(struct AudioCard *); +/* dma related definitions */ +struct AudioDmaOps { + int32_t (*DmaBufAlloc)(struct PlatformData *, enum AudioStreamType); + int32_t (*DmaBufFree)(struct PlatformData *, enum AudioStreamType); + int32_t (*DmaRequestChannel)(struct PlatformData *); + int32_t (*DmaConfigChannel)(struct PlatformData *); + int32_t (*DmaPrep)(struct PlatformData *); + int32_t (*DmaSubmit)(struct PlatformData *); + int32_t (*DmaPending)(struct PlatformData *); + int32_t (*DmaPause)(struct PlatformData *); + int32_t (*DmaResume)(struct PlatformData *); + int32_t (*DmaPointer)(struct PlatformData *, uint32_t *); }; struct PlatformDevice { @@ -105,26 +110,11 @@ struct PlatformDevice { struct DListHead list; }; -struct PlatformData { - const char *drvPlatformName; - /* platform driver callbacks */ - int32_t (*PlatformInit)(const struct AudioCard *, const struct PlatformDevice *); - /* pcm creation and destruction */ - int32_t (*PcmNew)(struct PlatformDevice *); - void (*PcmFree)(struct PlatformDevice *); - /* platform stream ops */ - struct AudioPlatformOps *ops; -}; - /* Platform host is defined in platform driver */ struct PlatformHost { struct IDeviceIoService service; struct HdfDeviceObject *device; void *priv; - bool platformInitFlag; - struct CircleBufInfo renderBufInfo; - struct CircleBufInfo captureBufInfo; - struct PcmInfo pcmInfo; }; static inline struct PlatformHost *PlatformHostFromDevice(struct HdfDeviceObject *device) diff --git a/model/audio/common/include/audio_accessory_base.h b/model/audio/common/include/audio_accessory_base.h index ab0f94a06eb5bef64d733212169221c5fda576c7..e52b5b5b0f102d53fc30b6a83c64edb39f95d3fa 100755 --- a/model/audio/common/include/audio_accessory_base.h +++ b/model/audio/common/include/audio_accessory_base.h @@ -8,9 +8,12 @@ #ifndef AUDIO_ACCESSORY_BASE_H #define AUDIO_ACCESSORY_BASE_H - +#include "audio_core.h" #include "audio_host.h" +#include "audio_sapm.h" +#include "audio_parse.h" #include "audio_control.h" +#include "audio_platform_base.h" #ifdef __cplusplus #if __cplusplus @@ -48,17 +51,30 @@ enum I2sFrequencyRegVal { I2S_SAMPLE_FREQUENCY_REG_VAL_96000 = 0xB /* 96kHz sample_rate */ }; -enum I2sFormatRegVal { - I2S_SAMPLE_FORMAT_REG_VAL_MSB_24 = 0x2, /* MSB-justified data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_24 = 0x3, /* I2S data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_16 = 0x4, /* LSB-justified 16-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_18 = 0x5, /* LSB-justified 18-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_20 = 0x6, /* LSB-justified 20-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_24 = 0x7, /* LSB-justified 24-bit data */ +struct AccessoryTransferData { + uint16_t i2cDevAddr; + uint16_t i2cBusNumber; + uint32_t accessoryCfgCtrlCount; + struct AudioRegCfgGroupNode **accessoryRegCfgGroupNode; + struct AudioKcontrol *accessoryControls; +}; + +struct DaiParamsVal { + uint32_t frequencyVal; + uint32_t formatVal; + uint32_t channelVal; }; -int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth); -int32_t RateToFrequency(uint32_t rate, uint16_t *freq); +int32_t AccessoryI2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag); +int32_t AccessoryRegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue); +int32_t AccessoryRegBitsUpdate(struct AudioMixerControl regAttr); + +int32_t AcessoryDeviceFrequencyParse(uint32_t rate, uint16_t *freq); +int32_t AccessoryDaiParamsUpdate(struct DaiParamsVal daiParamsVal); +int32_t AccessoryDeviceCfgGet(struct AccessoryData *data, struct AccessoryTransferData *transferData); +int32_t AccessoryDeviceCtrlRegInit(void); +int32_t AccessoryDeviceRegRead(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *value); +int32_t AccessoryDeviceRegWrite(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/include/audio_codec_base.h b/model/audio/common/include/audio_codec_base.h index f4d5bf3b30c29715e1a8a722e4e83f3d166f6a5c..712a2b73ead88c176105a1f92b7e2f7007159f16 100755 --- a/model/audio/common/include/audio_codec_base.h +++ b/model/audio/common/include/audio_codec_base.h @@ -19,12 +19,16 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t CodecDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *value); -int32_t CodecDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value); -int32_t CodecAiaoDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *value); -int32_t CodecAiaoDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value); +int32_t CodecDeviceReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *value); +int32_t CodecDeviceWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value); int32_t CodecGetServiceName(const struct HdfDeviceObject *device, const char **drvCodecName); int32_t CodecGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName); +int32_t CodecGetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData); +int32_t CodecSetConfigInfo(struct CodecData *codeData, struct DaiData *daiData); +int32_t CodecSetCtlFunc(struct CodecData *codeData, void *aiaoGetCtrl, void *aiaoSetCtrl); + + +int32_t AccessoryGetConfigInfo(const struct HdfDeviceObject *device, struct AccessoryData *codecData); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/include/audio_dai_base.h b/model/audio/common/include/audio_dai_base.h new file mode 100644 index 0000000000000000000000000000000000000000..cf70a793c7b457b5615de7020caeb0961ca4f405 --- /dev/null +++ b/model/audio/common/include/audio_dai_base.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef AUDIO_DAI_BASE_H +#define AUDIO_DAI_BASE_H + +#include "audio_codec_if.h" +#include "audio_core.h" +#include "osal_io.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct DaiData *DaiDataFromCard(const struct AudioCard *card); +int32_t DaiGetConfigInfo(const struct HdfDeviceObject *device, struct DaiData *data); +int32_t DaiCheckSampleRate(unsigned int sampleRates); +int32_t DaiSetConfigInfo(struct DaiData *data); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif diff --git a/model/audio/common/include/audio_dma_base.h b/model/audio/common/include/audio_dma_base.h new file mode 100644 index 0000000000000000000000000000000000000000..8bd5013d83f9771b1b25341c312a9c53f615c8fb --- /dev/null +++ b/model/audio/common/include/audio_dma_base.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef AUDIO_DMA_BASE_H +#define AUDIO_DMA_BASE_H + +#include "audio_host.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t AudioDmaBufAlloc(struct PlatformData *data, enum AudioStreamType streamType); +int32_t AudioDmaBufFree(struct PlatformData *data, enum AudioStreamType streamType); +int32_t AudioDmaRequestChannel(struct PlatformData *data); +int32_t AudioDmaConfigChannel(struct PlatformData *data); +int32_t AudioDmaPrep(struct PlatformData *data); +int32_t AudioDmaSubmit(struct PlatformData *data); +int32_t AudioDmaPending(struct PlatformData *data); +int32_t AudioDmaPause(struct PlatformData *data); +int32_t AudioDmaResume(struct PlatformData *data); +int32_t AudioDmaPointer(struct PlatformData *data, uint32_t *pointer); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif diff --git a/model/audio/common/include/audio_driver_log.h b/model/audio/common/include/audio_driver_log.h new file mode 100644 index 0000000000000000000000000000000000000000..73ccacc24d6df9ef358c0f3082c239d311a82c08 --- /dev/null +++ b/model/audio/common/include/audio_driver_log.h @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef AUDIO_DRIVER_LOG_H +#define AUDIO_DRIVER_LOG_H +#include "hdf_log.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +// 1 is on; 0 is off +#define AUDIO_ADM_DEBUG_ON 0 +#define AUDIO_DRIVER_DEBUG_ON 0 +#define AUDIO_DEVICE_DEBUG_ON 0 + +// audio ADM log define +#ifdef __LITEOS__ +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_ADM_DEBUG_ON +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define ADM_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define ADM_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define ADM_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +// audio driver log define +#ifdef __LITEOS__ +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_DRIVER_DEBUG_ON +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define AUDIO_DRIVER_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DRIVER_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DRIVER_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +// audio device log define +#ifdef __LITEOS__ +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_DEVICE_DEBUG_ON +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define AUDIO_DEVICE_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DRIVER_LOG_H */ diff --git a/model/audio/common/include/audio_dsp_base.h b/model/audio/common/include/audio_dsp_base.h new file mode 100644 index 0000000000000000000000000000000000000000..535cffdd066af8be38753ced21fe080d49939f8e --- /dev/null +++ b/model/audio/common/include/audio_dsp_base.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef AUDIO_DSP_BASE_H +#define AUDIO_DSP_BASE_H + +#include "audio_host.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t DspGetServiceName(const struct HdfDeviceObject *device, const char **drvDspName); +int32_t DspGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName); +int32_t DspLinkDeviceInit(struct AudioCard *card, const struct DaiDevice *device); +int32_t DspDeviceInit(const struct DspDevice *device); +int32_t DspDeviceReadReg(const struct DspDevice *device, uint8_t *buf, uint32_t len); +int32_t DspDeviceWriteReg(const struct DspDevice *device, uint8_t *buf, uint32_t len); +int32_t DspLinkStartup(const struct AudioCard *card, const struct DaiDevice *device); +int32_t DspLinkHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param); +int32_t DspDecodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); +int32_t DspEncodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); +int32_t DspEqualizerActive(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DSP_BASE_H */ diff --git a/model/audio/common/include/audio_platform_base.h b/model/audio/common/include/audio_platform_base.h index 72a9608c00157409484e92cef17c85e62537003f..0a6215ccd359191ea042e555bb258bbecfb99e42 100755 --- a/model/audio/common/include/audio_platform_base.h +++ b/model/audio/common/include/audio_platform_base.h @@ -18,6 +18,10 @@ extern "C" { #endif #endif /* __cplusplus */ +#define MIN_PERIOD_SIZE 4096 +#define BITSTOBYTE 8 +#define MAX_BUFF_SIZE (64 * 1024) + enum DataBitWidth { DATA_BIT_WIDTH8 = 8, /* 8 bit witdth */ DATA_BIT_WIDTH16 = 16, /* 16 bit witdth */ @@ -27,9 +31,30 @@ enum DataBitWidth { DATA_BIT_WIDTH32 = 32, /* 32 bit witdth */ }; -struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card); -int32_t PlatformCreatePlatformHost(const struct AudioCard *card, struct PlatformHost **platformHost); +unsigned int SysReadl(unsigned long addr); +void SysWritel(unsigned long addr, unsigned int value); + +struct PlatformData *PlatformDataFromCard(const struct AudioCard *card); +uint32_t AudioBytesToFrames(uint32_t frameBits, uint32_t size); int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth); +int32_t AudioFramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth); +int32_t AudioSetPcmInfo(struct PlatformData *platformData, const struct AudioPcmHwParams *param); +int32_t AudioSetRenderBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param); +int32_t AudioSetCaptureBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param); +int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData); +int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData); +int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData); +int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData); +int32_t AudioRenderOpen(const struct AudioCard *card); +int32_t AudioCaptureOpen(const struct AudioCard *card); +int32_t AudioRenderClose(const struct AudioCard *card); +int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer); +int32_t AudioCaptureClose(const struct AudioCard *card); +int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param); +int32_t AudioRenderPrepare(const struct AudioCard *card); +int32_t AudioCapturePrepare(const struct AudioCard *card); +int32_t AudioRenderTrigger(struct AudioCard *card, int cmd); +int32_t AudioCaptureTrigger(struct AudioCard *card, int cmd); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/src/audio_accessory_base.c b/model/audio/common/src/audio_accessory_base.c index aa0773774ed745efbbd9d91b17b6caf8d00c5e6b..0c02a7366b9339a471224fbaf6873880fb9e4be3 100755 --- a/model/audio/common/src/audio_accessory_base.c +++ b/model/audio/common/src/audio_accessory_base.c @@ -7,32 +7,244 @@ */ #include "audio_accessory_base.h" -#include "audio_core.h" +#include "audio_driver_log.h" +#include "osal_time.h" +#include "i2c_if.h" -#define HDF_LOG_TAG audio_accessory_base +#define HDF_LOG_TAG "audio_accessory_base" -int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth) +#define COMM_SHIFT_8BIT (8) +#define COMM_MASK_FF (0xFF) +#define COMM_WAIT_TIMES (10) // ms + +#define I2C_REG_LEN (1) +#define I2C_REG_MSGLEN (3) +#define I2C_MSG_NUM (2) +#define I2C_MSG_BUF_SIZE (2) + +uint16_t g_i2cDevAddr, g_i2cBusNumber; +struct AudioRegCfgGroupNode **g_audioRegCfgGroupNode = NULL; +struct AudioKcontrol *g_audioControls = NULL; + +/* + * release I2C object public function + */ +static void AccessoryI2cRelease(struct I2cMsg *msgs, int16_t msgSize, DevHandle i2cHandle) { - if (bitWidth == NULL) { - AUDIO_DRIVER_LOG_ERR("input param is NULL"); + if (msgs != NULL) { + if (msgSize == 0 && msgs->buf != NULL) { + OsalMemFree(msgs->buf); + msgs->buf = NULL; + } else if (msgSize == 1 && msgs[0].buf != NULL) { + OsalMemFree(msgs[0].buf); + msgs[0].buf = NULL; + } else if (msgSize >= I2C_MSG_NUM) { + if (msgs[0].buf != NULL) { + msgs[0].buf = NULL; + } + if (msgs[1].buf != NULL) { + OsalMemFree(msgs[1].buf); + msgs[1].buf = NULL; + } + } + AUDIO_DRIVER_LOG_DEBUG("OsalMemFree msgBuf success.\n"); + } + // close i2c device + if (i2cHandle != NULL) { + I2cClose(i2cHandle); + i2cHandle = NULL; + AUDIO_DRIVER_LOG_DEBUG("I2cClose success.\n"); + } +} + +static int32_t AccessoryI2cMsgFill(const struct AudioAddrConfig *regAttr, uint16_t rwFlag, + uint8_t *regs, struct I2cMsg *msgs) +{ + uint8_t *msgBuf = NULL; + if (rwFlag != 0 && rwFlag != I2C_FLAG_READ) { + AUDIO_DRIVER_LOG_ERR("invalid rwFlag value: %d.", rwFlag); + return HDF_ERR_INVALID_PARAM; + } + regs[0] = regAttr->addr; + msgs[0].addr = g_i2cDevAddr; + msgs[0].flags = 0; + msgs[0].len = I2C_REG_MSGLEN; + AUDIO_DRIVER_LOG_DEBUG("msgs[0].addr=0x%02x, regs[0]=0x%02x.", msgs[0].addr, regs[0]); + if (rwFlag == 0) { // write + // S 11011A2A1 0 A ADDR A MS1 A LS1 A <....> P + msgBuf = OsalMemCalloc(I2C_REG_MSGLEN); + if (msgBuf == NULL) { + AUDIO_DRIVER_LOG_ERR("[write]: malloc buf failed!"); + return HDF_ERR_MALLOC_FAIL; + } + msgBuf[0] = regs[0]; + msgBuf[1] = (uint8_t)(regAttr->value >> COMM_SHIFT_8BIT); // High 8 bit + msgBuf[I2C_MSG_BUF_SIZE] = (uint8_t)(regAttr->value & COMM_MASK_FF); // Low 8 bit + msgs[0].buf = msgBuf; + AUDIO_DRIVER_LOG_DEBUG("msgBuf[1]=0x%02x.", msgBuf[1]); + AUDIO_DRIVER_LOG_DEBUG("msgBuf[2]=0x%02x.", msgBuf[I2C_MSG_BUF_SIZE]); + } else { + // S 11011A2A1 0 A ADDR A Sr 11011A2A1 1 A MS1 A LS1 A <....> NA P + msgBuf = OsalMemCalloc(I2C_MSG_NUM); + if (msgBuf == NULL) { + AUDIO_DRIVER_LOG_ERR("[read]: malloc buf failed!"); + return HDF_ERR_MALLOC_FAIL; + } + msgs[0].len = 1; + msgs[0].buf = regs; + msgs[1].addr = g_i2cDevAddr; + msgs[1].flags = I2C_FLAG_READ; + msgs[1].len = I2C_MSG_NUM; + msgs[1].buf = msgBuf; + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +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]; + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + if (regAttr == NULL || rwFlag < 0 || rwFlag > 1) { + AUDIO_DRIVER_LOG_ERR("invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + i2cHandle = I2cOpen(g_i2cBusNumber); + if (i2cHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("open i2cBus:%u failed! i2cHandle:%p", g_i2cBusNumber, i2cHandle); return HDF_FAILURE; } - // current set default format(standard) for 16/24 bit - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - case AUDIO_FORMAT_PCM_24_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - default: - AUDIO_DRIVER_LOG_ERR("format: %d is not support.", format); - return HDF_ERR_NOT_SUPPORT; + if (rwFlag == I2C_FLAG_READ) { + transferMsgCount = I2C_MSG_NUM; + } + ret = AccessoryI2cMsgFill(regAttr, rwFlag, regs, msgs); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cMsgFill failed!"); + I2cClose(i2cHandle); + return HDF_FAILURE; + } + ret = I2cTransfer(i2cHandle, msgs, transferMsgCount); + if (ret != transferMsgCount) { + AUDIO_DRIVER_LOG_ERR("I2cTransfer err:%d", ret); + AccessoryI2cRelease(msgs, transferMsgCount, i2cHandle); + return HDF_FAILURE; + } + if (rwFlag == I2C_FLAG_READ) { + regAttr->value = (msgs[1].buf[0] << COMM_SHIFT_8BIT) | msgs[1].buf[1]; // result value 16 bit + AUDIO_DRIVER_LOG_DEBUG("[read]: regAttr->regValue=0x%04x.\n", regAttr->value); + } + AccessoryI2cRelease(msgs, transferMsgCount, i2cHandle); + return HDF_SUCCESS; +} + +// Read contrl reg bits value +int32_t AccessoryRegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue) +{ + int32_t ret; + struct AudioAddrConfig regVal; + if (regAttr == NULL || regAttr->reg < 0) { + AUDIO_DRIVER_LOG_ERR("input invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + regVal.addr = regAttr->reg; + ret = AccessoryI2cReadWrite(®Val, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryRegBitsRead failed."); + return HDF_FAILURE; + } + *regValue = regVal.value; + regAttr->value = (regVal.value >> regAttr->shift) & regAttr->mask; + if (regAttr->value > regAttr->max || regAttr->value < regAttr->min) { + AUDIO_DRIVER_LOG_ERR("invalid bitsValue=0x%x", regAttr->value); + return HDF_FAILURE; + } + if (regAttr->invert) { + regAttr->value = regAttr->max - regAttr->value; + } + AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, currBitsValue=0x%x", + regAttr->reg, regVal.value,regAttr->value); + AUDIO_DRIVER_LOG_DEBUG("mask=0x%x, shift=%d, max=0x%x,min=0x%x, invert=%d", + regAttr->mask, regAttr->shift, regAttr->max, regAttr->min, regAttr->invert); + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +// Update contrl reg bits value +int32_t AccessoryRegBitsUpdate(struct AudioMixerControl regAttr) +{ + int32_t ret; + struct AudioAddrConfig regVal; + uint32_t newValue, newMask, value; + if (regAttr.reg < 0) { + AUDIO_DRIVER_LOG_ERR("input invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + if (regAttr.invert) { + regAttr.value = regAttr.max - regAttr.value; + } + newValue = regAttr.value << regAttr.shift; + newMask = regAttr.mask << regAttr.shift; + ret = AccessoryRegBitsRead(®Attr, &value); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("AccessoryRegBitsRead faileded, ret=%d.", ret); + return HDF_FAILURE; } + regVal.value = (value & ~newMask) | (newValue & newMask); + regVal.addr = regAttr.reg; + ret = AccessoryI2cReadWrite(®Val, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cReadWrite faileded."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, oldValue=0x%x, newValue=0x%x,", + regAttr.reg, regVal.value, regAttr.value, newValue); + AUDIO_DRIVER_LOG_DEBUG(" mask=0x%x, shift=%d, max=0x%x, min=0x%x, invert=%d", + newMask, regAttr.shift, regAttr.max, regAttr.min, regAttr.invert); + AUDIO_DRIVER_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t RateToFrequency(uint32_t rate, uint16_t *freq) +// update external codec I2S frequency +int32_t AccessoryDaiParamsUpdate(struct DaiParamsVal daiParamsVal) +{ + int32_t ret; + const int itemNum = 3; // current only 3 items(frequency, format, channel) + struct AudioMixerControl *regAttr = NULL; + ret = (g_audioRegCfgGroupNode == NULL || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] == NULL + || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL + || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->itemNum < itemNum); + if (ret) { + AUDIO_DRIVER_LOG_ERR("g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] is NULL."); + return HDF_FAILURE; + } + regAttr = g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem; + regAttr[0].value = daiParamsVal.frequencyVal; + ret = AccessoryRegBitsUpdate(regAttr[0]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set freq failed."); + return HDF_FAILURE; + } + regAttr[1].value = daiParamsVal.formatVal; + ret = AccessoryRegBitsUpdate(regAttr[1]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set format failed."); + return HDF_FAILURE; + } + regAttr[itemNum - 1].value = daiParamsVal.channelVal; + ret = AccessoryRegBitsUpdate(regAttr[itemNum - 1]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set channel failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AcessoryDeviceFrequencyParse(uint32_t rate, uint16_t *freq) { if (freq == NULL) { AUDIO_DRIVER_LOG_ERR("input param is NULL"); @@ -79,5 +291,111 @@ int32_t RateToFrequency(uint32_t rate, uint16_t *freq) AUDIO_DRIVER_LOG_ERR("rate: %d is not support.", rate); return HDF_ERR_NOT_SUPPORT; } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceCfgGet(struct AccessoryData *accessoryData, + struct AccessoryTransferData *accessoryTransferData) +{ + int32_t ret, index; + struct AudioControlConfig *ctlcfgItem = NULL; + uint32_t audioCfgCtrlCount; + ret = (accessoryData == NULL || accessoryData->regConfig == NULL || accessoryTransferData == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + g_i2cDevAddr = accessoryTransferData->i2cDevAddr; + g_i2cBusNumber = accessoryTransferData->i2cBusNumber; + g_audioRegCfgGroupNode = accessoryData->regConfig->audioRegParams; + ret = (g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP] == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP] == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("parsing params is NULL."); + return HDF_FAILURE; + } + ctlcfgItem = g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + audioCfgCtrlCount = g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->itemNum; + g_audioControls = (struct AudioKcontrol *)OsalMemCalloc(audioCfgCtrlCount * sizeof(struct AudioKcontrol)); + accessoryTransferData->accessoryRegCfgGroupNode = g_audioRegCfgGroupNode; + accessoryTransferData->accessoryCfgCtrlCount = audioCfgCtrlCount; + accessoryTransferData->accessoryControls = g_audioControls; + for (index = 0; index < audioCfgCtrlCount; index++) { + g_audioControls[index].iface = ctlcfgItem[index].iface; + g_audioControls[index].name = g_audioControlsList[ctlcfgItem[index].arrayIndex]; + g_audioControls[index].Info = AudioInfoCtrlOps; + g_audioControls[index].privateValue = + (unsigned long)&g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem[index]; + g_audioControls[index].Get = AudioAccessoryGetCtrlOps; + g_audioControls[index].Set = AudioAccessorySetCtrlOps; + } + return HDF_SUCCESS; +} + +/* + * init control reg to default value + */ +int32_t AccessoryDeviceCtrlRegInit(void) +{ + int32_t ret, i; + // Set codec control register(00h-14h) default value + ret = (g_audioRegCfgGroupNode == NULL || g_audioRegCfgGroupNode[AUDIO_INIT_GROUP] == NULL + || g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("g_audioRegCfgGroupNode[AUDIO_INIT_GROUP] is NULL."); + return HDF_FAILURE; + } + struct AudioAddrConfig *initCfg = g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem; + for (i = 0; i < g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->itemNum; i++) { + AUDIO_DRIVER_LOG_DEBUG("i=%d, Addr = [0x%2x]", i, initCfg[i].addr); + ret = AccessoryI2cReadWrite(&initCfg[i], 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cReadWrite(write) err, regAttr.regAddr: 0x%x.\n", + initCfg[i].addr); + return HDF_FAILURE; + } + OsalMSleep(COMM_WAIT_TIMES); + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegRead(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) +{ + int32_t ret; + struct AudioAddrConfig regAttr; + if (val == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + (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; + AUDIO_DRIVER_LOG_DEBUG("success"); + 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); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success"); return HDF_SUCCESS; } diff --git a/model/audio/common/src/audio_codec_base.c b/model/audio/common/src/audio_codec_base.c index 0bef4037f82ace8998698a41b0fea4699b07c93e..40626ab282e7e601212d8492df9ae5c3796bc222 100755 --- a/model/audio/common/src/audio_codec_base.c +++ b/model/audio/common/src/audio_codec_base.c @@ -7,99 +7,26 @@ */ #include "audio_codec_base.h" +#include "audio_parse.h" +#include "audio_driver_log.h" +#include "audio_sapm.h" #define HDF_LOG_TAG audio_codec_base -int32_t CodecDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t CodecDeviceReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *val) { - unsigned long acodecVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); - - if ((codec == NULL) || (codec->device == NULL) || (val == NULL)) { - AUDIO_DRIVER_LOG_ERR("input param codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - acodecVir = virtualAdd->acodecVir; - *val = OSAL_READL((void *)(volatile uintptr_t)(acodecVir + reg)); - - AUDIO_DRIVER_LOG_DEBUG("success"); - return HDF_SUCCESS; -} - -int32_t CodecDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value) -{ - unsigned long acodecVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); - - if ((codec == NULL) || (codec->device == NULL)) { - AUDIO_DRIVER_LOG_ERR("param codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - acodecVir = virtualAdd->acodecVir; - OSAL_WRITEL(value, (void *)(volatile uintptr_t)(acodecVir + reg)); - - AUDIO_DRIVER_LOG_DEBUG("success"); - return HDF_SUCCESS; -} - -int32_t CodecAiaoDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) -{ - unsigned long aiaoVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); - - if ((codec == NULL) || (codec->device == NULL) || (val == NULL)) { - AUDIO_DRIVER_LOG_ERR("codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; + if (val == NULL) { + AUDIO_DRIVER_LOG_ERR("param val is null."); + return HDF_FAILURE; } - aiaoVir = virtualAdd->aiaoVir; - *val = OSAL_READL((void *)(volatile uintptr_t)(aiaoVir + reg)); - - AUDIO_DRIVER_LOG_DEBUG("success"); + *val = OSAL_READL((void *)((uintptr_t)(virtualAddress + reg))); return HDF_SUCCESS; } -int32_t CodecAiaoDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value) +int32_t CodecDeviceWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value) { - unsigned long aiaoVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); - - if ((codec == NULL) || (codec->device == NULL)) { - AUDIO_DRIVER_LOG_ERR("codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - aiaoVir = virtualAdd->aiaoVir; - OSAL_WRITEL(value, (void *)(volatile uintptr_t)(aiaoVir + reg)); - - AUDIO_DRIVER_LOG_DEBUG("success"); + OSAL_WRITEL(value, (void *)((uintptr_t)(virtualAddress + reg))); return HDF_SUCCESS; } @@ -164,3 +91,210 @@ int32_t CodecGetDaiName(const struct HdfDeviceObject *device, const char **drvDa return HDF_SUCCESS; } + +int32_t CodecGetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData) +{ + if (device == NULL || codecData == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } + + if (codecData->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; + } + + codecData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(codecData->regConfig))); + if (codecData->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; + } + + if (CodecGetRegConfig(device, codecData->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("CodecGetRegConfig fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t SapmCtrlToSapmComp(struct AudioSapmComponent *sapmComponents, + struct AudioSapmCtrlConfig *sapmCompItem, uint16_t index) +{ + if (sapmComponents == NULL || sapmCompItem == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + sapmComponents[index].componentName = + g_audioSapmCompNameList[sapmCompItem[index].compNameIndex]; + sapmComponents[index].reg = sapmCompItem[index].reg; + sapmComponents[index].sapmType = sapmCompItem[index].sapmType; + sapmComponents[index].mask = sapmCompItem[index].mask; + sapmComponents[index].shift = sapmCompItem[index].shift; + sapmComponents[index].invert = sapmCompItem[index].invert; + sapmComponents[index].kcontrolsNum = sapmCompItem[index].kcontrolsNum; + + return HDF_SUCCESS; +} + +static int32_t CodecSetSapmConfigInfo(struct CodecData *codeData,struct AudioRegCfgGroupNode ** regCfgGroup) +{ + uint16_t index; + + if (codeData == NULL || regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + struct AudioSapmCtrlConfig *sapmCompItem = regCfgGroup[AUDIO_SAPM_COMP_GROUP]->sapmCompItem; + struct AudioControlConfig *sapmCtrlItem = regCfgGroup[AUDIO_SAPM_CFG_GROUP]->ctrlCfgItem; + struct AudioMixerControl *ctlSapmRegCfgItem = regCfgGroup[AUDIO_CTRL_SAPM_PATAM_GROUP]->regCfgItem; + + if (sapmCompItem == NULL || sapmCtrlItem == NULL || ctlSapmRegCfgItem == NULL) { + AUDIO_DRIVER_LOG_ERR("sapmCompItem, sapmCtrlItem, ctlSapmRegCfgItem is NULL."); + return HDF_FAILURE; + } + + struct AudioKcontrol *audioSapmControls = (struct AudioKcontrol *)OsalMemCalloc + (regCfgGroup[AUDIO_SAPM_CFG_GROUP]->itemNum * sizeof(struct AudioKcontrol)); + if (audioSapmControls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + for (index = 0; index < regCfgGroup[AUDIO_SAPM_CFG_GROUP]->itemNum; index++) { + audioSapmControls[index].iface = sapmCtrlItem[index].iface; + audioSapmControls[index].name = g_audioSapmCfgNameList[sapmCtrlItem[index].arrayIndex]; + audioSapmControls[index].privateValue = (unsigned long)&ctlSapmRegCfgItem[index]; + audioSapmControls[index].Info = AudioInfoCtrlOps; + audioSapmControls[index].Get = AudioCodecSapmGetCtrlOps; + audioSapmControls[index].Set = AudioCodecSapmSetCtrlOps; + } + + codeData->numSapmComponent = regCfgGroup[AUDIO_SAPM_COMP_GROUP]->itemNum; + codeData->sapmComponents = (struct AudioSapmComponent *) + OsalMemCalloc(codeData->numSapmComponent * sizeof(struct AudioSapmComponent)); + if (codeData->sapmComponents == NULL) { + OsalMemFree(audioSapmControls); + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numSapmComponent; index++) { + if (SapmCtrlToSapmComp(codeData->sapmComponents ,sapmCompItem, index)) { + OsalMemFree(audioSapmControls); + return HDF_FAILURE; + } + + if (sapmCompItem[index].kcontrolsNum) { + codeData->sapmComponents[index].kcontrolNews = + &audioSapmControls[sapmCompItem[index].kcontrolNews - 1]; + } + } + + return HDF_SUCCESS; +} + +int32_t CodecSetConfigInfo(struct CodecData *codeData, struct DaiData *daiData) +{ + uint16_t index; + + if (codeData == NULL || daiData == NULL || codeData->regConfig == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + struct AudioIdInfo *audioIdInfo = &(codeData->regConfig->audioIdInfo); + struct AudioRegCfgGroupNode **regCfgGroup = codeData->regConfig->audioRegParams; + daiData->regCfgGroup = regCfgGroup; + codeData->regCfgGroup = regCfgGroup; + if (audioIdInfo == NULL || regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_ERR("audioIdInfo or regCfgGroup is NULL."); + return HDF_FAILURE; + } + + struct AudioControlConfig *compItem = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + struct AudioMixerControl *ctlRegCfgItem = regCfgGroup[AUDIO_CTRL_PATAM_GROUP]->regCfgItem; + if (compItem == NULL || ctlRegCfgItem == NULL) { + AUDIO_DRIVER_LOG_ERR("compItem or ctlRegCfgItem is NULL."); + return HDF_FAILURE; + } + + codeData->numControls = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->itemNum; + codeData->controls = + (struct AudioKcontrol *)OsalMemCalloc(codeData->numControls * sizeof(struct AudioKcontrol)); + if (codeData->controls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numControls; index++) { + codeData->controls[index].iface = compItem[index].iface; + codeData->controls[index].name = g_audioControlsList[compItem[index].arrayIndex]; + codeData->controls[index].Info = AudioInfoCtrlOps; + codeData->controls[index].privateValue = (unsigned long)&ctlRegCfgItem[index]; + if (compItem[index].enable) { + codeData->controls[index].Get = AudioCodecGetCtrlOps; + codeData->controls[index].Set = AudioCodecSetCtrlOps; + } + } + + codeData->virtualAddress = (uintptr_t)OsalIoRemap(audioIdInfo->chipIdRegister, audioIdInfo->chipIdSize); + + if (CodecSetSapmConfigInfo(codeData, regCfgGroup) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecSetCtlFunc(struct CodecData *codeData, void *aiaoGetCtrl, void *aiaoSetCtrl) +{ + uint32_t index = 0; + if (codeData == NULL || codeData->regConfig == NULL || + aiaoGetCtrl == NULL || aiaoSetCtrl == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + struct AudioRegCfgGroupNode **regCfgGroup = codeData->regConfig->audioRegParams; + struct AudioControlConfig *compItem = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + if (regCfgGroup == NULL || compItem == NULL) { + AUDIO_DRIVER_LOG_ERR("regCfgGroup or compItem is NULL."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numControls; index++) { + if (!compItem[index].enable) { + codeData->controls[index].Get = aiaoGetCtrl; + codeData->controls[index].Set = aiaoSetCtrl; + } + } + + return HDF_SUCCESS; +} + +int32_t AccessoryGetConfigInfo(const struct HdfDeviceObject *device, struct AccessoryData *codecData) +{ + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } + + if (codecData->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; + } + + codecData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(codecData->regConfig))); + if (codecData->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; + } + + if (CodecGetRegConfig(device, codecData->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("CodecGetRegConfig fail!"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} diff --git a/model/audio/common/src/audio_dai_base.c b/model/audio/common/src/audio_dai_base.c new file mode 100644 index 0000000000000000000000000000000000000000..bdface250859e930613dcb82ec2eb72af9c7a588 --- /dev/null +++ b/model/audio/common/src/audio_dai_base.c @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "audio_host.h" +#include "audio_core.h" +#include "audio_parse.h" +#include "audio_driver_log.h" +#include "audio_dai_if.h" +#include "osal_io.h" + +struct DaiData *DaiDataFromCard(const struct AudioCard *card) +{ + if (card == NULL || card->rtd == NULL || card->rtd->cpuDai == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null."); + return NULL; + } + return card->rtd->cpuDai->devData; +} + + +int32_t DaiGetConfigInfo(const struct HdfDeviceObject *device, struct DaiData *data) +{ + if (device == NULL || data == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } + + if (data->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; + } + + data->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(data->regConfig))); + if (data->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; + } + + if (CodecGetRegConfig(device, data->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("dai GetRegConfig fail!"); + OsalMemFree(data->regConfig); + data->regConfig = NULL; + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t DaiCheckSampleRate(unsigned int sampleRates) +{ + bool check = (sampleRates == AUDIO_SAMPLE_RATE_8000 || sampleRates == AUDIO_SAMPLE_RATE_12000 || + sampleRates == AUDIO_SAMPLE_RATE_11025 || sampleRates == AUDIO_SAMPLE_RATE_16000 || + sampleRates == AUDIO_SAMPLE_RATE_22050 || sampleRates == AUDIO_SAMPLE_RATE_24000 || + sampleRates == AUDIO_SAMPLE_RATE_32000 || sampleRates == AUDIO_SAMPLE_RATE_44100 || + sampleRates == AUDIO_SAMPLE_RATE_48000 || sampleRates == AUDIO_SAMPLE_RATE_64000 || + sampleRates == AUDIO_SAMPLE_RATE_96000); + if (check) { + return HDF_SUCCESS; + } else { + AUDIO_DRIVER_LOG_ERR("FramatToSampleRate fail: Invalid sampling rate: %d.", sampleRates); + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t DaiSetConfigInfo(struct DaiData *data) +{ + uint16_t index; + struct AudioRegCfgGroupNode **regCfgGroup = NULL; + struct AudioMixerControl *patRegCfgItemTmp = NULL; + struct AudioControlConfig *item = NULL; + + if (data == NULL || data->regConfig == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + regCfgGroup = data->regConfig->audioRegParams; + if (regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_DEBUG("regCfgGroup is null."); + return HDF_SUCCESS; + } + + patRegCfgItemTmp = regCfgGroup[AUDIO_CTRL_PATAM_GROUP]->regCfgItem; + item = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + + if (patRegCfgItemTmp == NULL || item == NULL) { + AUDIO_DRIVER_LOG_ERR("patRegCfgItemTmp or item is NULL."); + return HDF_FAILURE; + } + + data->numControls = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->itemNum; + data->controls = (struct AudioKcontrol *)OsalMemCalloc(data->numControls * sizeof(struct AudioKcontrol)); + if (data->controls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < data->numControls; index++) { + data->controls[index].iface = item[index].iface; + data->controls[index].name = g_audioControlsList[item[index].arrayIndex]; + data->controls[index].Info = AudioInfoCtrlOps; + data->controls[index].privateValue = (unsigned long)&patRegCfgItemTmp[index]; + data->controls[index].Get = AudioCpuDaiGetCtrlOps; + data->controls[index].Set = AudioCpuDaiSetCtrlOps; + } + + return HDF_SUCCESS; +} + diff --git a/model/audio/common/src/audio_dma_base.c b/model/audio/common/src/audio_dma_base.c new file mode 100644 index 0000000000000000000000000000000000000000..c0a06174e0dd27eaf29e3774e779e84caf21e07e --- /dev/null +++ b/model/audio/common/src/audio_dma_base.c @@ -0,0 +1,83 @@ +#include "audio_platform_if.h" + +int32_t AudioDmaBufAlloc(struct PlatformData *data, enum AudioStreamType streamType) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaBufAlloc != NULL) { + return data->ops->DmaBufAlloc(data, streamType); + } + return HDF_FAILURE; +} + +int32_t AudioDmaBufFree(struct PlatformData *data, enum AudioStreamType streamType) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaBufFree != NULL) { + return data->ops->DmaBufFree(data, streamType); + } + return HDF_FAILURE; +} + +int32_t AudioDmaRequestChannel(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaConfigChannel != NULL) { + return data->ops->DmaRequestChannel(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaConfigChannel(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaConfigChannel != NULL) { + return data->ops->DmaConfigChannel(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPrep(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPrep != NULL) { + return data->ops->DmaPrep(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaSubmit(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaSubmit != NULL) { + return data->ops->DmaSubmit(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPending(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPending != NULL) { + return data->ops->DmaPending(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPause(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPause != NULL) { + return data->ops->DmaPause(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaResume(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaResume != NULL) { + return data->ops->DmaResume(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPointer(struct PlatformData *data, uint32_t *pointer) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPointer != NULL) { + return data->ops->DmaPointer(data, pointer); + } + return HDF_FAILURE; +} + + diff --git a/model/audio/common/src/audio_dsp_base.c b/model/audio/common/src/audio_dsp_base.c new file mode 100644 index 0000000000000000000000000000000000000000..fb472fa87f2fef65b3c1ebe8d9bbe93a6e534f51 --- /dev/null +++ b/model/audio/common/src/audio_dsp_base.c @@ -0,0 +1,383 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "audio_accessory_base.h" +#include "audio_dsp_if.h" +#include "osal_io.h" +#include "spi_if.h" +#include "audio_driver_log.h" + +#define DEFAULT_SPEED 2000000 +#define BITS_PER_WORD_EIGHT 8 +#define DSP_CS_NUM 1 +#define DSP_SPI_BUS_NUM 1 + +enum DspI2sFormatRegVal { + I2S_SAMPLE_FORMAT_REG_VAL_MSB_24 = 0x2, /* MSB-justified data up to 24 bits */ + I2S_SAMPLE_FORMAT_REG_VAL_24 = 0x3, /* I2S data up to 24 bits */ + I2S_SAMPLE_FORMAT_REG_VAL_LSB_16 = 0x4, /* LSB-justified 16-bit data */ + I2S_SAMPLE_FORMAT_REG_VAL_LSB_18 = 0x5, /* LSB-justified 18-bit data */ + I2S_SAMPLE_FORMAT_REG_VAL_LSB_20 = 0x6, /* LSB-justified 20-bit data */ + I2S_SAMPLE_FORMAT_REG_VAL_LSB_24 = 0x7, /* LSB-justified 24-bit data */ +}; + +struct SpiDevInfo g_devInfo = { + .busNum = DSP_SPI_BUS_NUM, + .csNum = DSP_CS_NUM, +}; + +int32_t DspLinkStartup(const struct AudioCard *card, const struct DaiDevice *device) +{ + (void)card; + (void)device; + return HDF_SUCCESS; +} + +static int32_t DspCfgI2sFrequency(uint32_t rate, uint16_t *frequency) +{ + switch (rate) { + case I2S_SAMPLE_FREQUENCY_8000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_8000; + break; + case I2S_SAMPLE_FREQUENCY_11025: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_11025; + break; + case I2S_SAMPLE_FREQUENCY_12000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_12000; + break; + case I2S_SAMPLE_FREQUENCY_16000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_16000; + break; + case I2S_SAMPLE_FREQUENCY_22050: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_22050; + break; + case I2S_SAMPLE_FREQUENCY_24000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_24000; + break; + case I2S_SAMPLE_FREQUENCY_32000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_32000; + break; + case I2S_SAMPLE_FREQUENCY_44100: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_44100; + break; + case I2S_SAMPLE_FREQUENCY_48000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_48000; + break; + case I2S_SAMPLE_FREQUENCY_64000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_64000; + break; + case I2S_SAMPLE_FREQUENCY_88200: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_88200; + break; + case I2S_SAMPLE_FREQUENCY_96000: + *frequency = I2S_SAMPLE_FREQUENCY_REG_VAL_96000; + break; + default: + AUDIO_DRIVER_LOG_ERR("rate: %d is not support.", rate); + return HDF_ERR_NOT_SUPPORT; + } + return HDF_SUCCESS; +} + +static int32_t DspSetI2sBitWidth(enum AudioFormat format, uint16_t *bitWidth) +{ + switch (format) { + case AUDIO_FORMAT_PCM_8_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; + break; + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not support.", format); + return HDF_ERR_NOT_SUPPORT; + } + return HDF_SUCCESS; +} + +static int DspSetI2sFrequency(uint16_t frequencyVal) +{ + return HDF_SUCCESS; +} + +static int DspSetI2sFormat(uint16_t formatVal) +{ + return HDF_SUCCESS; +} + +int32_t DspLinkHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + int ret; + uint16_t frequency, bitWidth; + (void)card; + + AUDIO_DRIVER_LOG_DEBUG("entry."); + if (param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is nullptr."); + return HDF_ERR_INVALID_PARAM; + } + ret = DspCfgI2sFrequency(param->rate, &frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("RateToFrequency fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = DspSetI2sBitWidth(param->format, &bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("FormatToBitWidth fail."); + return HDF_ERR_NOT_SUPPORT; + } + ret = DspSetI2sFrequency(frequency); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("SetDspI2sFs fail."); + return HDF_FAILURE; + } + ret = DspSetI2sFormat(bitWidth); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("SetDspI2sFormat fail."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("DspLinkHwParams: channels = %d, rate = %d, periodSize = %d, \ + periodCount = %d, format = %d, cardServiceName = %s \n", + param->channels, param->rate, param->periodSize, + param->periodCount, (uint32_t)param->format, param->cardServiceName); + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int DspPowerEnable(void) +{ + return HDF_SUCCESS; +} + +static int DspGpioPinInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2cPinInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2sInit(void) +{ + return HDF_SUCCESS; +} + +static int DspI2cInit(void) +{ + return HDF_SUCCESS; +} + +/* not init dsp gpio */ +static int DspSpiPinInit(void) +{ + return HDF_FAILURE; +} + +int32_t DspDeviceInit(const struct DspDevice *device) +{ + DevHandle devHandle; + struct SpiCfg devCfg = { + .maxSpeedHz = DEFAULT_SPEED, + .mode = SPI_CLK_POLARITY, + .transferMode = SPI_DMA_TRANSFER, + .bitsPerWord = BITS_PER_WORD_EIGHT, + }; + + if (DspPowerEnable() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspPowerEnable: return Error!"); + return HDF_FAILURE; + } + + if (DspGpioPinInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspGpioPinInit: return Error!"); + return HDF_FAILURE; + } + + if (DspI2cPinInit() != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspI2cPinInit: return Error!"); + return HDF_FAILURE; + } + + if (DspSpiPinInit() == HDF_SUCCESS) { + devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + if (SpiSetCfg(devHandle, &devCfg) != HDF_SUCCESS) { + SpiClose(devHandle); + AUDIO_DRIVER_LOG_ERR("DspDeviceCfg: spi failed!"); + return HDF_FAILURE; + } + SpiClose(devHandle); + } else { + AUDIO_DRIVER_LOG_ERR("Dsp Gpio Pin: not init!"); + } + + if (DspI2cInit() != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (DspI2sInit() != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t DspDeviceReadReg(const struct DspDevice *device, uint8_t *buf, uint32_t len) +{ + int32_t ret; + + DevHandle devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + ret = SpiRead(devHandle, buf, len); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspDeviceRead: spi failed!"); + SpiClose(devHandle); + return HDF_FAILURE; + } + + SpiClose(devHandle); + + return HDF_SUCCESS; +} + +int32_t DspDeviceWriteReg(const struct DspDevice *device, uint8_t *buf, uint32_t len) +{ + int32_t ret; + + DevHandle devHandle = SpiOpen(&g_devInfo); + if (devHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("DspDeviceOpen: Spi failed!"); + return HDF_FAILURE; + } + + ret = SpiWrite(devHandle, buf, len); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DspDeviceRead: spi failed!"); + SpiClose(devHandle); + return HDF_FAILURE; + } + + SpiClose(devHandle); + + return HDF_SUCCESS; +} + +int32_t DspLinkDeviceInit(struct AudioCard *card, const struct DaiDevice *device) +{ + if (device == NULL || device->devDaiName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is nullptr."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("dsp Link device name: %s\n", device->devDaiName); + (void)card; + return HDF_SUCCESS; +} + +int32_t DspGetServiceName(const struct HdfDeviceObject *device, const char **drvDspName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("deivce property is NULL."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("from resource get drsops failed!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", drvDspName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read DspServiceName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +int32_t DspGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is null pointer."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("drs node is null pointer."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("drs ops fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "dspDaiName", drvDaiName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read dspDaiName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + + +int32_t DspDecodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("decode run!!!"); + return HDF_SUCCESS; +} + +int32_t DspEncodeAudioStream(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("encode run!!!"); + return HDF_SUCCESS; +} + + +int32_t DspEqualizerActive(const struct AudioCard *card, const uint8_t *buf, const struct DspDevice *device) +{ + (void)card; + (void)buf; + (void)device; + AUDIO_DRIVER_LOG_DEBUG("equalizer run!!!"); + return HDF_SUCCESS; +} diff --git a/model/audio/common/src/audio_platform_base.c b/model/audio/common/src/audio_platform_base.c index 6163fdf726ece8183831b40826f9cae7f8cf4491..ea0e242f291fa816b53c316a20540af383e785b7 100755 --- a/model/audio/common/src/audio_platform_base.c +++ b/model/audio/common/src/audio_platform_base.c @@ -7,10 +7,33 @@ */ #include "audio_platform_base.h" -#include "audio_core.h" +#include "osal_time.h" +#include "osal_uaccess.h" +#include "audio_driver_log.h" +#include "audio_dma_base.h" +#include "audio_sapm.h" +#include "audio_stream_dispatch.h" #define HDF_LOG_TAG audio_platform_base -struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card) +const int MAX_PERIOD_SIZE = 1024 * 16; +const int MAX_PERIOD_COUNT = 32; +const int MIN_PERIOD_COUNT = 4; +const int RENDER_TRAF_BUF_SIZE = 1024; +const int MIN_BUFF_SIZE = 16 * 1024; +const int TIME_OUT_CONST = 50; +const int SLEEP_TIME = 5; + +unsigned int SysReadl(unsigned long addr) +{ + return *(volatile unsigned int *)(addr); +} + +void SysWritel(unsigned long addr, unsigned int value) +{ + *(volatile unsigned int *)(addr) = value; +} + +struct PlatformData *PlatformDataFromCard(const struct AudioCard *card) { if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL) { AUDIO_DRIVER_LOG_ERR("param is null."); @@ -19,25 +42,17 @@ struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card) return card->rtd->platform->devData; } -int32_t PlatformCreatePlatformHost(const struct AudioCard *card, struct PlatformHost **platformHost) +uint32_t AudioBytesToFrames(uint32_t frameBits, uint32_t size) { - if (platformHost == NULL) { - AUDIO_DRIVER_LOG_ERR("input param platformHost is invalid."); - return HDF_ERR_INVALID_PARAM; - } - if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL) { - AUDIO_DRIVER_LOG_ERR("input para is NULL."); - return HDF_FAILURE; - } - - *platformHost = PlatformHostFromDevice(card->rtd->platform->device); - if (*platformHost == NULL) { - AUDIO_DRIVER_LOG_ERR("PlatformHostFromDevice faile."); - return HDF_FAILURE; + if (size == 0) { + AUDIO_DRIVER_LOG_ERR("size is null."); + return 0; + } else { + return (frameBits / size); } - return HDF_SUCCESS; } + int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth) { if (srcData == NULL) { @@ -76,3 +91,1053 @@ int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitW } return HDF_SUCCESS; } + +int32_t AudioFramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth) +{ + if (bitWidth == NULL) { + AUDIO_DRIVER_LOG_ERR("bitWidth is null."); + return HDF_FAILURE; + } + switch (format) { + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = DATA_BIT_WIDTH16; + break; + + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = DATA_BIT_WIDTH24; + break; + + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not define.", format); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioSetPcmInfo(struct PlatformData *platformData, const struct AudioPcmHwParams *param) +{ + if (platformData == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + platformData->pcmInfo.rate = param->rate; + platformData->pcmInfo.frameSize = param->channels * platformData->pcmInfo.bitWidth / BITSTOBYTE; + platformData->pcmInfo.channels = param->channels; + + platformData->renderBufInfo.chnId = 0; + platformData->captureBufInfo.chnId = 0; + + platformData->pcmInfo.isBigEndian = param->isBigEndian; + platformData->pcmInfo.isSignedData = param->isSignedData; + + platformData->pcmInfo.startThreshold = param->startThreshold; + platformData->pcmInfo.stopThreshold = param->stopThreshold; + platformData->pcmInfo.silenceThreshold = param->silenceThreshold; + + platformData->pcmInfo.interleaved = 1; + platformData->pcmInfo.channels = param->channels; + platformData->pcmInfo.streamType = param->streamType; + + return HDF_SUCCESS; +} + +int32_t AudioSetRenderBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param) +{ + uint32_t size; + + if (data == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + data->renderBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid."); + return HDF_FAILURE; + } + data->renderBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid."); + return HDF_FAILURE; + } + data->renderBufInfo.periodCount = param->periodCount; + + data->renderBufInfo.trafBufSize = RENDER_TRAF_BUF_SIZE; + + size = data->renderBufInfo.periodCount * data->renderBufInfo.periodSize; + if (size < MIN_BUFF_SIZE || size > MAX_BUFF_SIZE) { + AUDIO_DRIVER_LOG_ERR("buffSize is invalid."); + return HDF_FAILURE; + } + + data->renderBufInfo.cirBufSize = size; + return HDF_SUCCESS; +} + +int32_t AudioSetCaptureBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param) +{ + if (data == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + + data->captureBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid %d.", param->periodSize); + return HDF_FAILURE; + } + data->captureBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid %d.", param->periodCount); + return HDF_FAILURE; + } + data->captureBufInfo.periodCount = param->periodCount; + + if (param->silenceThreshold < MIN_PERIOD_SIZE || param->silenceThreshold > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("silenceThreshold is invalid %d.", param->silenceThreshold); + return HDF_FAILURE; + } + data->captureBufInfo.trafBufSize = param->silenceThreshold; + data->captureBufInfo.cirBufSize = param->periodSize * param->periodCount; + if (data->captureBufInfo.cirBufSize > data->captureBufInfo.cirBufMax) { + AUDIO_DRIVER_LOG_ERR("cirBufSize is invalid %d.", data->captureBufInfo.cirBufSize); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioWriteProcBigEndian(const struct PlatformData *data, struct AudioTxData *txData) +{ + uint64_t buffSize; + + if (data == NULL || txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + buffSize = txData->frames * data->pcmInfo.frameSize; + if (data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(txData->buf, buffSize, data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +static enum CriBuffStatus AudioDmaBuffStatus(const struct AudioCard *card) +{ + uint32_t dataAvailable; + uint32_t residual; + uint32_t pointer; + struct PlatformData *data = NULL; + uint32_t wptr; + uint32_t rptr; + + data = PlatformDataFromCard(card); + if (data == NULL || data->ops == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (AudioPcmPointer(card, &pointer) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get Pointer failed."); + return ENUM_CIR_BUFF_FULL; + } + + if (data->pcmInfo.streamType == AUDIO_RENDER_STREAM) { + data->renderBufInfo.pointer = pointer; + rptr = data->renderBufInfo.pointer * data->pcmInfo.frameSize; + dataAvailable = (data->renderBufInfo.wbufOffSet - rptr) % data->renderBufInfo.cirBufSize; + residual = data->renderBufInfo.cirBufSize - dataAvailable; + if ((residual > data->renderBufInfo.trafBufSize)) { + return ENUM_CIR_BUFF_NORMAL; + } + return ENUM_CIR_BUFF_FULL; + } else if (data->pcmInfo.streamType == AUDIO_CAPTURE_STREAM) { + rptr = data->captureBufInfo.rptrOffSet; + wptr = pointer * data->pcmInfo.frameSize; + data->captureBufInfo.pointer = pointer; + + if (wptr >= rptr) { + // [S ... R ... W ... E] + dataAvailable = wptr - rptr; + if (dataAvailable < data->captureBufInfo.trafBufSize) { + AUDIO_DRIVER_LOG_DEBUG("empty rptr: %d wptr: %d trafBufSize: %d ", rptr, + wptr, data->captureBufInfo.trafBufSize); + return ENUM_CIR_BUFF_EMPTY; + } + } + AUDIO_DRIVER_LOG_DEBUG("rptr: %d wptr: %d trafBufSize: %d ", rptr, wptr, data->captureBufInfo.trafBufSize); + return ENUM_CIR_BUFF_NORMAL; + } else { + AUDIO_DRIVER_LOG_ERR("streamType is invalead."); + return ENUM_CIR_BUFF_FULL; + } +} + +int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData) +{ + struct PlatformData *data = NULL; + enum CriBuffStatus status; + uint32_t wPtr; + int ret; + + if (card == NULL || txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL."); + return HDF_FAILURE; + } + + // 1. Computed buffer size + data->renderBufInfo.trafBufSize = txData->frames * data->pcmInfo.frameSize; + + // 2. Big Small Exchange + if (data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(txData->buf, data->renderBufInfo.trafBufSize, + data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + // 3. Buffer state checking + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + txData->status = ENUM_CIR_BUFF_FULL; + return HDF_SUCCESS; + } + + // 4. write buffer + if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) { + AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big."); + return HDF_FAILURE; + } + wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize; + + if (data->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("render buffer is null."); + return HDF_FAILURE; + } + ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, + data->renderBufInfo.trafBufSize, txData->buf, data->renderBufInfo.trafBufSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + txData->status = ENUM_CIR_BUFF_NORMAL; + data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize; + data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize; + + return HDF_SUCCESS; +} + +static int32_t PcmReadData(struct PlatformData *data, struct AudioRxData *rxData) +{ + uint32_t wptr; + uint32_t rptr; + uint32_t validDataSize; + + if (data == NULL || rxData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet; + wptr = data->captureBufInfo.pointer * data->pcmInfo.frameSize; + rptr = data->captureBufInfo.rptrOffSet; + data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize; + if (rptr > wptr) { + validDataSize = data->captureBufInfo.cirBufSize - rptr; + if (validDataSize < data->captureBufInfo.trafBufSize) { + data->captureBufInfo.curTrafSize = validDataSize; + } + } + + // 3. Big Small Exchange + if (!data->pcmInfo.isBigEndian) { + if (rxData->buf == NULL || + AudioDataBigEndianChange(rxData->buf, data->captureBufInfo.curTrafSize, + data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + + rxData->frames = data->captureBufInfo.curTrafSize / data->pcmInfo.frameSize; + rxData->bufSize = data->captureBufInfo.curTrafSize; + rxData->status = ENUM_CIR_BUFF_NORMAL; + + return HDF_SUCCESS; +} + +int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData) +{ + struct PlatformData *data = NULL; + enum CriBuffStatus status; + + if (card == NULL || rxData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL."); + return HDF_FAILURE; + } + if (data->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("capture buffer is null."); + return HDF_FAILURE; + } + + // 1. Buffer state checking + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + rxData->status = ENUM_CIR_BUFF_EMPTY; + rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet; + rxData->frames = 0; + rxData->bufSize = 0; + AUDIO_DRIVER_LOG_DEBUG("buff is empty."); + return HDF_SUCCESS; + } + + // 2. read buffer + if (PcmReadData(data, rxData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Pcm Read Data fail."); + return HDF_FAILURE; + } + + // 4. update rptr + data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize; + if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) { + data->captureBufInfo.rptrOffSet = 0; + } + return HDF_SUCCESS; +} + +static int32_t MmapWriteData(struct PlatformData *data, char *tmpBuf) +{ + uint32_t wPtr; + int ret; + + if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) { + AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + + wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize; + ret = CopyFromUser(tmpBuf, (char *)data->mmapData.memoryAddress + data->mmapData.offset, + data->renderBufInfo.trafBufSize); + if (ret != EOK) { + AUDIO_DRIVER_LOG_ERR("CopyFromUser failed."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + + ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, data->renderBufInfo.trafBufSize, + tmpBuf, data->renderBufInfo.trafBufSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + + data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize; + data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize; + data->renderBufInfo.framesPosition += data->renderBufInfo.trafBufSize / data->pcmInfo.frameSize; + data->mmapData.offset += data->renderBufInfo.trafBufSize; + data->mmapLoopCount++; + return HDF_SUCCESS; +} + +static int32_t AudioMmapWriteTransfer(const struct AudioCard *card) +{ + struct PlatformData *data = NULL; + enum CriBuffStatus status; + uint32_t timeout = 0; + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + if (data->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("render buffer is null."); + return HDF_FAILURE; + } + + uint32_t totalSize = data->mmapData.totalBufferFrames * data->pcmInfo.frameSize; + uint32_t lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); + uint32_t loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + data->mmapLoopCount = 0; + char *tmpBuf = OsalMemCalloc(MIN_PERIOD_SIZE); + + while (data->mmapLoopCount < loopTimes && data->renderBufInfo.runStatus != PCM_STOP) { + if (data->renderBufInfo.runStatus == PCM_PAUSE) { + OsalMSleep(5); + continue; + } + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + OsalMSleep(SLEEP_TIME); + AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL."); + timeout++; + if (timeout >= TIME_OUT_CONST) { + AUDIO_DRIVER_LOG_ERR("timeout failed."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + continue; + } + timeout = 0; + data->renderBufInfo.trafBufSize = (data->mmapLoopCount < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; + + if (MmapWriteData(data, tmpBuf) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("MmapWriteData fail."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + } + + if (data->mmapLoopCount > loopTimes) { + data->renderBufInfo.runStatus = PCM_STOP; + } + + OsalMemFree(tmpBuf); + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData) +{ + int32_t ret; + struct PlatformData *data = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (txMmapData == NULL || txMmapData->memoryAddress == NULL || txMmapData->transferFrameSize <= 0 || + txMmapData->totalBufferFrames <= 0) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + data->mmapData.offset = txMmapData->offset; + data->mmapData.memoryAddress = txMmapData->memoryAddress; + data->mmapData.totalBufferFrames = txMmapData->totalBufferFrames; + data->mmapData.transferFrameSize = txMmapData->transferFrameSize; + data->mmapLoopCount = 0; + + AUDIO_DRIVER_LOG_DEBUG("*******offset=0x%x memoryAddress=0x%x totalBufferFrames=0x%x transferFrameSize=0x%x ", + data->mmapData.offset, data->mmapData.memoryAddress, data->mmapData.totalBufferFrames, + data->mmapData.transferFrameSize); + + ret = AudioMmapWriteTransfer(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioMmapTransfer fail."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("render mmap write success."); + return HDF_SUCCESS; +} + +static int32_t MmapReadData(struct PlatformData *data, const struct AudioMmapData *rxMmapData, uint32_t offset) +{ + uint32_t wPtr; + uint32_t rPtr; + uint32_t validDataSize; + + if (data == NULL || rxMmapData == NULL) { + AUDIO_DRIVER_LOG_ERR("data is null."); + return HDF_FAILURE; + } + + rPtr = data->captureBufInfo.rptrOffSet; + wPtr = data->captureBufInfo.pointer * data->pcmInfo.frameSize; + if (rPtr > wPtr) { + validDataSize = data->captureBufInfo.cirBufSize - rPtr; + if (validDataSize < data->captureBufInfo.trafBufSize) { + data->captureBufInfo.curTrafSize = validDataSize; + } + } + if (!data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange((char *)(data->captureBufInfo.virtAddr) + rPtr, + data->captureBufInfo.curTrafSize, data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + + if (CopyToUser((char *)rxMmapData->memoryAddress + offset, + (char *)(data->captureBufInfo.virtAddr) + rPtr, data->captureBufInfo.curTrafSize) != 0) { + AUDIO_DRIVER_LOG_ERR("CopyToUser failed."); + return HDF_FAILURE; + } + + // 4. update rptr + data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize; + if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) { + data->captureBufInfo.rptrOffSet = 0; + } + data->captureBufInfo.framesPosition += data->captureBufInfo.curTrafSize / data->pcmInfo.frameSize; + + return HDF_SUCCESS; +} + +int32_t AudioMmapReadTransfer(const struct AudioCard *card, const struct AudioMmapData *rxMmapData) +{ + uint32_t offset = 0; + enum CriBuffStatus status; + uint32_t timeout = 0; + struct PlatformData *data = NULL; + + if (!card || !rxMmapData || !rxMmapData->memoryAddress || rxMmapData->totalBufferFrames <= 0) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + uint32_t frameSize = data->pcmInfo.frameSize; + uint32_t totalSize = rxMmapData->totalBufferFrames * frameSize; + data->captureBufInfo.pointer = 0; + data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize; + if (data->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("capture buffer is null."); + return HDF_FAILURE; + } + + do { + if (data->captureBufInfo.runStatus == PCM_PAUSE) { + OsalMSleep(5); + continue; + } + + // 1. get buffer status + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + OsalMSleep(SLEEP_TIME); + AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL."); + timeout++; + if (timeout >= TIME_OUT_CONST) { + AUDIO_DRIVER_LOG_ERR("timeout failed."); + return HDF_FAILURE; + } + continue; + } + timeout = 0; + + // 2. read data + if (MmapReadData(data, rxMmapData, offset) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("MmapReadData fail."); + return HDF_FAILURE; + } + + offset += data->captureBufInfo.curTrafSize; + + } while (offset < totalSize && data->captureBufInfo.runStatus != 0); + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData) +{ + int32_t ret; + struct PlatformData *data = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + ret = (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL + || rxMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + ret = AudioMmapReadTransfer(card, rxMmapData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("AudioMmapReadTransfer fail."); + return HDF_ERR_INVALID_PARAM; + } + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t AudioRenderBuffInit(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + if (platformData->renderBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + + platformData->renderBufInfo.cirBufMax = MAX_BUFF_SIZE; + platformData->renderBufInfo.phyAddr = 0; + + ret = AudioDmaBufAlloc(platformData, AUDIO_RENDER_STREAM); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + if (platformData->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); + return HDF_FAILURE; + } + + (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufMax, + 0, platformData->renderBufInfo.cirBufMax); + + return HDF_SUCCESS; +} + +static int32_t AudioRenderBuffFree(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + ret = AudioDmaBufFree(platformData, AUDIO_RENDER_STREAM); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + platformData->renderBufInfo.virtAddr = NULL; + platformData->renderBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +static int32_t AudioCaptureBuffInit(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + if (platformData->captureBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + + platformData->captureBufInfo.cirBufMax = MAX_BUFF_SIZE; + platformData->captureBufInfo.phyAddr = 0; + + ret = AudioDmaBufAlloc(platformData, AUDIO_CAPTURE_STREAM); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); + return HDF_FAILURE; + } + + (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufMax, 0, + platformData->captureBufInfo.cirBufMax); + + return HDF_SUCCESS; +} + +static int32_t AudioCaptureBuffFree(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + ret = AudioDmaBufFree(platformData, AUDIO_CAPTURE_STREAM); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + platformData->captureBufInfo.virtAddr = NULL; + platformData->captureBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +int32_t AudioRenderOpen(const struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (data->renderBufInfo.virtAddr == NULL) { + if (AudioRenderBuffInit(data) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t AudioRenderClose(const struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + return AudioRenderBuffFree(data); +} + +int32_t AudioCaptureOpen(const struct AudioCard *card) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr == NULL) { + if (AudioCaptureBuffInit(platformData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureClose(const struct AudioCard *card) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + return AudioCaptureBuffFree(platformData); +} + +int32_t AudioRenderTrigger(struct AudioCard *card, int cmd) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + switch (cmd) { + case AUDIO_DRV_PCM_IOCTRL_RENDER_START: + if (AudioDmaSubmit(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + + if (AudioDmaPending(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_START; + break; + case AUDIO_DRV_PCM_IOCTRL_RENDER_STOP: + if (AudioDmaPause(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_STOP; + break; + case AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE: + if (AudioDmaPause(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_PAUSE; + break; + case AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME: + if (AudioDmaResume(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampPowerUp(card) != HDF_SUCCESS) { + return HDF_FAILURE; + } + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_START; + break; + default: + AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureTrigger(struct AudioCard *card, int cmd) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + switch (cmd) { + case AUDIO_DRV_PCM_IOCTRL_CAPTURE_START: + if (AudioDmaSubmit(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + if (AudioDmaPending(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_START; + break; + case AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP: + if (AudioDmaPause(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) { + return HDF_FAILURE; + } + data->captureBufInfo.runStatus = PCM_STOP; + break; + case AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE: + if (AudioDmaPause(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_PAUSE; + break; + case AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME: + if (AudioDmaResume(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampPowerUp(card) != HDF_SUCCESS) { + return HDF_FAILURE; + } + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + data->captureBufInfo.runStatus = PCM_START; + break; + default: + AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + const int chnlCntMin = 1; + const int chnlCntMax = 2; + + if (card == NULL || param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + if (param->channels < chnlCntMin || param->channels > chnlCntMax) { + AUDIO_DRIVER_LOG_ERR("channels param is invalid."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("platformData is null."); + return HDF_FAILURE; + } + + if (AudioDmaRequestChannel(platformData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail."); + return HDF_FAILURE; + } + + if (AudioFramatToBitWidth(param->format, &platformData->pcmInfo.bitWidth) != HDF_SUCCESS) { + return HDF_FAILURE; + } + if (AudioSetPcmInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (param->streamType == AUDIO_RENDER_STREAM) { + if (AudioSetRenderBufInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } else if (param->streamType == AUDIO_CAPTURE_STREAM) { + if (AudioSetCaptureBufInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } else { + AUDIO_DRIVER_LOG_ERR("param streamType is invalid."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioRenderPrepare(const struct AudioCard *card) +{ + int ret; + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->renderBufInfo.virtAddr != NULL) { + (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufSize, 0, + platformData->renderBufInfo.cirBufSize); + } + platformData->renderBufInfo.wbufOffSet = 0; + platformData->renderBufInfo.wptrOffSet = 0; + platformData->pcmInfo.totalStreamSize = 0; + platformData->renderBufInfo.framesPosition = 0; + platformData->renderBufInfo.pointer = 0; + + ret = AudioDmaConfigChannel(platformData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioCapturePrepare(const struct AudioCard *card) +{ + int ret; + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr != NULL) { + (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufSize, 0, + platformData->captureBufInfo.cirBufSize); + } + platformData->captureBufInfo.rbufOffSet = 0; + platformData->captureBufInfo.rptrOffSet = 0; + platformData->captureBufInfo.chnId = 0; + platformData->pcmInfo.totalStreamSize = 0; + platformData->captureBufInfo.framesPosition = 0; + platformData->captureBufInfo.pointer = 0; + + ret = AudioDmaConfigChannel(platformData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer) +{ + int ret; + if (card == NULL || pointer == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + ret = AudioDmaPointer(data, pointer); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Pointer fail."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + + diff --git a/model/audio/core/include/audio_control.h b/model/audio/core/include/audio_control.h index 76ec94c6aca6bd558f1abf6b50ceb94bbb939ca4..fe418c87e032389fafe9dfe1f3a818152cff29fb 100755 --- a/model/audio/core/include/audio_control.h +++ b/model/audio/core/include/audio_control.h @@ -52,6 +52,7 @@ struct AudioMixerControl { uint32_t shift; uint32_t rshift; /* right sound channel reg shift */ uint32_t invert; + uint32_t value; }; struct AudioKcontrol { diff --git a/model/audio/core/include/audio_core.h b/model/audio/core/include/audio_core.h index 32a2f860c47c93070e8dc952ddf5c2456deb9650..762e56be16d44a194aa2456a471c3d735f38ae7b 100755 --- a/model/audio/core/include/audio_core.h +++ b/model/audio/core/include/audio_core.h @@ -29,27 +29,6 @@ extern "C" { #define AUDIO_DAI_LINK_COMPLETE 1 #define AUDIO_DAI_LINK_UNCOMPLETE 0 -#ifdef __LITEOS__ -#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ - } while (0) -#else -#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ - HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) -#endif - -#define AUDIO_DRIVER_LOG_ERR(fmt, arg...) do { \ - HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define AUDIO_DRIVER_LOG_INFO(fmt, arg...) do { \ - HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define AUDIO_DRIVER_LOG_WARNING(fmt, arg...) do { \ - HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - enum AudioDeviceType { AUDIO_DAI_DEVICE, AUDIO_DSP_DEVICE, @@ -78,35 +57,39 @@ int32_t AudioUpdateCodecRegBits(struct CodecDevice *codec, const struct AudioMixerControl *mixerControl, uint32_t value); int32_t AudioUpdateAccessoryRegBits(struct AccessoryDevice *accessory, const struct AudioMixerControl *mixerControl, uint32_t value); -int32_t AudioUpdateCodecAiaoRegBits(struct CodecDevice *codec, const struct AudioMixerControl *mixerControl, - uint32_t value); -int32_t AudioUpdateAccessoryAiaoRegBits(struct AccessoryDevice *accessory, - const struct AudioMixerControl *mixerControl, uint32_t value); +int32_t AudioUpdateDaiRegBits(const struct DaiDevice *dai, struct AudioMixerControl *mixerControl, uint32_t value); struct CodecDevice *AudioKcontrolGetCodec(const struct AudioKcontrol *kcontrol); struct AccessoryDevice *AudioKcontrolGetAccessory(const struct AudioKcontrol *kcontrol); +struct DaiDevice *AudioKcontrolGetCpuDai(const struct AudioKcontrol *kcontrol); int32_t AudioAddControls(struct AudioCard *audioCard, const struct AudioKcontrol *controls, int32_t controlMaxNum); struct AudioKcontrol *AudioAddControl(const struct AudioCard *audioCard, const struct AudioKcontrol *ctl); +int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t rcurValue); +int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t curValue); +int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t *value); +int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, + struct AudioMixerControl *mixerCtrl, uint32_t *rvalue, bool *updateRReg); +int32_t AudioDaiReadReg(const struct DaiDevice *dai, uint32_t reg, uint32_t *val); +int32_t AudioDaiWriteReg(const struct DaiDevice *dai, uint32_t reg, uint32_t val); + int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val); int32_t AudioCodecWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val); int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val); int32_t AudioAccessoryWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val); -int32_t AudioCodecAiaoReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val); -int32_t AudioCodecAiaoWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val); -int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val); -int32_t AudioAccessoryAiaoWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val); int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo); int32_t AudioCodecGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); int32_t AudioCodecSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); int32_t AudioAccessoryGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); int32_t AudioAccessorySetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); -int32_t AudioCodecAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); -int32_t AudioCodecAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); -int32_t AudioAccessoryAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); -int32_t AudioAccessoryAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData, struct DaiData *DaiData); +int32_t AudioCpuDaiSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); +int32_t AudioCpuDaiGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); + #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/core/include/audio_host.h b/model/audio/core/include/audio_host.h index e49c6b0e5770285e9085915c69d2280e0131c429..b4d1aa276ce236d1ee8ed04a7a8185b7ca41acb8 100755 --- a/model/audio/core/include/audio_host.h +++ b/model/audio/core/include/audio_host.h @@ -24,27 +24,6 @@ extern "C" { #endif #endif /* __cplusplus */ -#ifdef __LITEOS__ -#define ADM_LOG_DEBUG(fmt, arg...) do { \ - } while (0) -#else -#define ADM_LOG_DEBUG(fmt, arg...) do { \ - HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) -#endif - -#define ADM_LOG_ERR(fmt, arg...) do { \ - HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define ADM_LOG_INFO(fmt, arg...) do { \ - HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define ADM_LOG_WARNING(fmt, arg...) do { \ - HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - #define BUFF_SIZE_MAX 64 #define AUDIO_LIST_HEAD_INIT(name) { &(name), &(name) } @@ -68,6 +47,30 @@ enum AudioFormat { AUDIO_FORMAT_G726 = 0x2000003u, /**< audio G726 */ }; +typedef enum { + AUDIO_SAMPLE_RATE_8000 = 8000, /* 8kHz sample_rate */ + AUDIO_SAMPLE_RATE_12000 = 12000, /* 12kHz sample_rate */ + AUDIO_SAMPLE_RATE_11025 = 11025, /* 11.025kHz sample_rate */ + AUDIO_SAMPLE_RATE_16000 = 16000, /* 16kHz sample_rate */ + AUDIO_SAMPLE_RATE_22050 = 22050, /* 22.050kHz sample_rate */ + AUDIO_SAMPLE_RATE_24000 = 24000, /* 24kHz sample_rate */ + AUDIO_SAMPLE_RATE_32000 = 32000, /* 32kHz sample_rate */ + AUDIO_SAMPLE_RATE_44100 = 44100, /* 44.1kHz sample_rate */ + AUDIO_SAMPLE_RATE_48000 = 48000, /* 48kHz sample_rate */ + AUDIO_SAMPLE_RATE_64000 = 64000, /* 64kHz sample_rate */ + AUDIO_SAMPLE_RATE_96000 = 96000, /* 96kHz sample_rate */ + AUDIO_SAMPLE_RATE_BUTT, +} AudioSampleRate; + +enum AuidoBitWidth { + BIT_WIDTH8 = 8, /* 8 bit witdth */ + BIT_WIDTH16 = 16, /* 16 bit witdth */ + BIT_WIDTH18 = 18, /* 18 bit witdth */ + BIT_WIDTH20 = 20, /* 20 bit witdth */ + BIT_WIDTH24 = 24, /* 24 bit witdth */ + BIT_WIDTH32 = 32, /* 32 bit witdth */ +}; + struct AudioConfigData { const char *cardServiceName; const char *codecName; @@ -80,6 +83,12 @@ struct AudioConfigData { const char *dspDaiName; }; +enum AudioSapmTurnStandbyMode { + AUDIO_SAPM_TURN_STANDBY_LATER = 0, + AUDIO_SAPM_TURN_STANDBY_NOW, + AUDIO_SAPM_TURN_STANDBY_BUTT, +}; + struct AudioCard { struct AudioRuntimeDeivces *rtd; struct AudioConfigData configData; @@ -95,6 +104,7 @@ struct AudioCard { struct DListHead components; /* all components for this card */ struct DListHead paths; /* all paths for this card */ struct DListHead sapmDirty; /* all dirty for this card */ + enum AudioSapmTurnStandbyMode standbyMode; bool sapmSleepState; bool sapmStandbyState; bool sapmMonitorState; @@ -111,6 +121,23 @@ enum AudioStreamType { AUDIO_RENDER_STREAM, }; +struct PcmInfo { + enum AudioStreamType streamType; + /* The number of channels in a frame */ + uint32_t channels; + /* The number of frames per second */ + uint32_t rate; + uint32_t bitWidth; + uint32_t frameSize; + bool isBigEndian; + bool isSignedData; + uint32_t startThreshold; + uint32_t stopThreshold; + uint32_t silenceThreshold; + uint32_t totalStreamSize; + uint32_t interleaved; +}; + struct AudioPcmHwParams { /* The stream type in a frame */ enum AudioStreamType streamType; @@ -153,16 +180,7 @@ struct AudioRxData { unsigned long frames; /* frames number */ }; -struct AudioTxMmapData { - void *memoryAddress; /**< Pointer to the mmap buffer */ - int32_t memoryFd; /**< File descriptor of the mmap buffer */ - int32_t totalBufferFrames; /**< Total size of the mmap buffer (unit: frame )*/ - int32_t transferFrameSize; /**< Transfer size (unit: frame) */ - int32_t isShareable; /**< Whether the mmap buffer can be shared among processes */ - uint32_t offset; -}; - -struct AudioRxMmapData { +struct AudioMmapData { void *memoryAddress; /**< Pointer to the mmap buffer */ int32_t memoryFd; /**< File descriptor of the mmap buffer */ int32_t totalBufferFrames; /**< Total size of the mmap buffer (unit: frame )*/ diff --git a/model/audio/core/include/audio_parse.h b/model/audio/core/include/audio_parse.h index 9ded34ee9e85c0ed6ebd22d760a2f9c27a9e6a9a..cd7c96f0613acf21d3fcb10ceee6c7e95b3c51d8 100755 --- a/model/audio/core/include/audio_parse.h +++ b/model/audio/core/include/audio_parse.h @@ -10,6 +10,7 @@ #define AUDIO_PARSE_H #include "audio_host.h" +#include "audio_control.h" #ifdef __cplusplus #if __cplusplus @@ -17,8 +18,83 @@ extern "C" { #endif #endif /* __cplusplus */ +#define AUDIO_CONFIG_MAX_ITEM 100 + +static const char *g_audioControlsList[] = { + "Main Playback Volume", "Main Capture Volume", + "Playback Mute", "Capture Mute", "Mic Left Gain", + "Mic Right Gain", "External Codec Enable", + "Internally Codec Enable", "Render Channel Mode", "Captrue Channel Mode" +}; + +static char *g_audioSapmCompNameList[] = { + "ADCL", "ADCR", "DACL", "DACR", "LPGA", "RPGA", "SPKL", "SPKR", "MIC" +}; + +static char *g_audioSapmCfgNameList[] = { + "LPGA MIC Switch", "RPGA MIC Switch", "Dacl enable", "Dacr enable" +}; + +enum AudioRegOpsType { + AUDIO_RSET_GROUP = 0, + AUDIO_INIT_GROUP, + AUDIO_CTRL_PATAM_GROUP, + AUDIO_CTRL_SAPM_PATAM_GROUP, + AUDIO_DAI_STARTUP_PATAM_GROUP, + AUDIO_DAI_PATAM_GROUP, + AUDIO_CTRL_CFG_GROUP, + AUDIO_SAPM_COMP_GROUP, + AUDIO_SAPM_CFG_GROUP, + AUDIO_GROUP_MAX +}; + +struct AudioIdInfo { + const char *chipName; + uint32_t chipIdRegister; + uint32_t chipIdSize; +}; + +struct AudioControlConfig { + uint8_t arrayIndex; + uint8_t iface; + uint8_t enable; +}; + +struct AudioAddrConfig { + uint32_t addr; + uint32_t value; +}; + +struct AudioSapmCtrlConfig { + uint8_t sapmType; + uint8_t compNameIndex; + uint8_t reg; + uint8_t mask; + uint8_t shift; + uint8_t invert; + uint8_t kcontrolNews; + uint8_t kcontrolsNum; +}; + + +struct AudioRegCfgGroupNode { + uint8_t itemNum; + enum AudioRegOpsType groupIndex; + struct AudioAddrConfig *addrCfgItem; + struct AudioMixerControl *regCfgItem; + struct AudioControlConfig *ctrlCfgItem; + struct AudioSapmCtrlConfig *sapmCompItem; +}; + +struct AudioRegCfgData { + struct AudioIdInfo audioIdInfo; + struct AudioRegCfgGroupNode *audioRegParams[AUDIO_GROUP_MAX]; +}; + int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioConfigData *configData); +int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData); + #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/core/src/audio_core.c b/model/audio/core/src/audio_core.c index f61a7341588dcbd4639bd5ea6a54dcd431e7201e..fa6c5f00f4192554c00ee49ebbb837a06cd17dc8 100755 --- a/model/audio/core/src/audio_core.c +++ b/model/audio/core/src/audio_core.c @@ -7,6 +7,8 @@ */ #include "audio_core.h" +#include "osal_io.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_core @@ -16,27 +18,27 @@ AUDIO_LIST_HEAD(codecController); AUDIO_LIST_HEAD(dspController); AUDIO_LIST_HEAD(accessoryController); -int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *data) +int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *platformData) { - struct PlatformDevice *platform = NULL; + struct PlatformDevice *platformDevice = NULL; - if ((device == NULL) || (data == NULL)) { - ADM_LOG_ERR("Input params check error: device=%p, data=%p.", device, data); + if ((device == NULL) || (platformData == NULL)) { + ADM_LOG_ERR("Input params check error: device=%p, platformData=%p.", device, platformData); return HDF_ERR_INVALID_OBJECT; } - platform = (struct PlatformDevice *)OsalMemCalloc(sizeof(*platform)); - if (platform == NULL) { - ADM_LOG_ERR("Malloc platform device fail!"); + platformDevice = (struct PlatformDevice *)OsalMemCalloc(sizeof(*platformDevice)); + if (platformDevice == NULL) { + ADM_LOG_ERR("Malloc platformDevice device fail!"); return HDF_ERR_MALLOC_FAIL; } - platform->devPlatformName = data->drvPlatformName; - platform->devData = data; - platform->device = device; - DListInsertHead(&platform->list, &platformController); - ADM_LOG_INFO("Register [%s] success.", platform->devPlatformName); + platformDevice->devPlatformName = platformData->drvPlatformName; + platformDevice->devData = platformData; + platformDevice->device = device; + DListInsertHead(&platformDevice->list, &platformController); + ADM_LOG_INFO("Register [%s] success.", platformDevice->devPlatformName); return HDF_SUCCESS; } @@ -121,6 +123,7 @@ int32_t AudioRegisterCodec(struct HdfDeviceObject *device, struct CodecData *cod ret = AudioSocDeviceRegister(device, (void *)daiData, AUDIO_DAI_DEVICE); if (ret != HDF_SUCCESS) { + OsalIoUnmap((void *)((uintptr_t)(void*)&(codec->devData->virtualAddress))); OsalMemFree(codec); ADM_LOG_ERR("Register dai device fail ret=%d", ret); return HDF_ERR_IO; @@ -453,78 +456,50 @@ int32_t AudioUpdateAccessoryRegBits(struct AccessoryDevice *accessory, return HDF_SUCCESS; } -int32_t AudioUpdateCodecAiaoRegBits(struct CodecDevice *codec, - const struct AudioMixerControl *mixerControl, uint32_t value) +int32_t AudioUpdateDaiRegBits(const struct DaiDevice *dai, struct AudioMixerControl *mixerControl, uint32_t value) { int32_t ret; uint32_t curValue = 0; uint32_t mixerControlMask; - ADM_LOG_DEBUG("Entry to update AIAO codec reg bits."); + struct DaiData *data = NULL; - if (codec == NULL || mixerControl == NULL) { - ADM_LOG_ERR("Invalid AIAO codec param."); + if (dai == NULL || dai->devData == NULL || mixerControl == NULL) { + ADM_LOG_ERR("Invalid accessory param."); return HDF_ERR_INVALID_OBJECT; } + data = dai->devData; - value = value << mixerControl->shift; - mixerControlMask = mixerControl->mask << mixerControl->shift; - - OsalMutexLock(&codec->mutex); - ret = AudioCodecAiaoReadReg(codec, mixerControl->reg, &curValue); - if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&codec->mutex); - ADM_LOG_ERR("Read AIAO codec reg fail ret=%d.", ret); + if (value > mixerControl->max || value < mixerControl->min) { + ADM_LOG_ERR("value is invalued=%d.", value); return HDF_FAILURE; } - curValue = (curValue & ~mixerControlMask) | (value & mixerControlMask); - ret = AudioCodecAiaoWriteReg(codec, mixerControl->reg, curValue); - if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&codec->mutex); - ADM_LOG_ERR("Write AIAO codec reg fail ret=%d", ret); - return HDF_FAILURE; - } - OsalMutexUnlock(&codec->mutex); - - ADM_LOG_DEBUG("Update AIAO codec reg bits successful."); - return HDF_SUCCESS; -} - -int32_t AudioUpdateAccessoryAiaoRegBits(struct AccessoryDevice *accessory, - const struct AudioMixerControl *mixerControl, uint32_t value) -{ - int32_t ret; - uint32_t curValue = 0; - uint32_t mixerControlMask; - ADM_LOG_DEBUG("Entry to update AIAO accessory reg bits."); - - if (accessory == NULL || mixerControl == NULL) { - ADM_LOG_ERR("Invalid AIAO accessory param."); - return HDF_ERR_INVALID_OBJECT; - } - value = value << mixerControl->shift; mixerControlMask = mixerControl->mask << mixerControl->shift; - OsalMutexLock(&accessory->mutex); - ret = AudioAccessoryAiaoReadReg(accessory, mixerControl->reg, &curValue); + OsalMutexLock(&data->mutex); + ret = AudioDaiReadReg(dai, mixerControl->reg, &curValue); if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&accessory->mutex); - ADM_LOG_ERR("Read AIAO accessory reg fail ret=%d.", ret); + OsalMutexUnlock(&data->mutex); + ADM_LOG_ERR("Read reg fail ret=%d.", ret); return HDF_FAILURE; } + curValue = (curValue & ~mixerControlMask) | (value & mixerControlMask); - ret = AudioAccessoryAiaoWriteReg(accessory, mixerControl->reg, curValue); + + ADM_LOG_DEBUG("reg: 0x%x curValue: 0x%x.", mixerControl->reg, curValue); + ret = AudioDaiWriteReg(dai, mixerControl->reg, curValue); if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&accessory->mutex); - ADM_LOG_ERR("Write AIAO accessory reg fail ret=%d", ret); + OsalMutexUnlock(&data->mutex); + ADM_LOG_ERR("Write reg fail ret=%d", ret); return HDF_FAILURE; } - OsalMutexUnlock(&accessory->mutex); + OsalMutexUnlock(&data->mutex); - ADM_LOG_DEBUG("Update AIAO accessory reg bits successful."); + ADM_LOG_DEBUG("Success."); return HDF_SUCCESS; } + struct CodecDevice *AudioKcontrolGetCodec(const struct AudioKcontrol *kcontrol) { struct AudioCard *audioCard = NULL; @@ -559,6 +534,23 @@ struct AccessoryDevice *AudioKcontrolGetAccessory(const struct AudioKcontrol *kc return audioCard->rtd->accessory; } +struct DaiDevice *AudioKcontrolGetCpuDai(const struct AudioKcontrol *kcontrol) +{ + struct AudioCard *audioCard = NULL; + if (kcontrol == NULL || kcontrol->pri == NULL) { + ADM_LOG_ERR("Input param kcontrol is NULL."); + return NULL; + } + + audioCard = (struct AudioCard *)((volatile uintptr_t)(kcontrol->pri)); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("Get codec or rtd fail."); + return NULL; + } + + return audioCard->rtd->cpuDai; +} + struct AudioKcontrol *AudioAddControl(const struct AudioCard *audioCard, const struct AudioKcontrol *ctrl) { struct AudioKcontrol *control = NULL; @@ -608,61 +600,67 @@ int32_t AudioAddControls(struct AudioCard *audioCard, const struct AudioKcontrol return HDF_SUCCESS; } -int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t AudioDaiReadReg(const struct DaiDevice *dai, uint32_t reg, uint32_t *val) { int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->Read == NULL || val == NULL) { - ADM_LOG_ERR("Input param codec is NULL."); + unsigned long virtualAddress; + if (dai == NULL || dai->devData == NULL || dai->devData->Read == NULL || val == NULL) { + ADM_LOG_ERR("Input param is NULL."); return HDF_FAILURE; } - ret = codec->devData->Read(codec, reg, val); + virtualAddress = dai->devData->regDaiBase; + ret = dai->devData->Read(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Codec device read fail."); + ADM_LOG_ERR("dai device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) +int32_t AudioDaiWriteReg(const struct DaiDevice *dai, uint32_t reg, uint32_t val) { int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->Read == NULL || val == NULL) { - ADM_LOG_ERR("Input param accessory is NULL."); + unsigned long virtualAddress; + if (dai == NULL || dai->devData == NULL || dai->devData->Write == NULL) { + ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = accessory->devData->Read(accessory, reg, val); + virtualAddress = dai->devData->regDaiBase; + ret = dai->devData->Write(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Accessory device read fail."); + ADM_LOG_ERR("dai device write fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCodecAiaoReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) { int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->AiaoRead == NULL || val == NULL) { + unsigned long virtualAddress; + if (codec == NULL || codec->devData == NULL || codec->devData->Read == NULL || val == NULL) { ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = codec->devData->AiaoRead(codec, reg, val); + virtualAddress = codec->devData->virtualAddress; + ret = codec->devData->Read(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Device read fail."); + ADM_LOG_ERR("Codec device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) +int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) { int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->AiaoRead == NULL || val == NULL) { + if (accessory == NULL || accessory->devData == NULL || accessory->devData->Read == NULL || val == NULL) { ADM_LOG_ERR("Input param accessory is NULL."); return HDF_FAILURE; } - ret = accessory->devData->AiaoRead(accessory, reg, val); + ret = accessory->devData->Read(accessory, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Device read fail."); + ADM_LOG_ERR("Accessory device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; @@ -671,11 +669,13 @@ int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint3 int32_t AudioCodecWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val) { int32_t ret; + unsigned long virtualAddress; if (codec == NULL || codec->devData == NULL || codec->devData->Write == NULL) { ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = codec->devData->Write(codec, reg, val); + virtualAddress = codec->devData->virtualAddress; + ret = codec->devData->Write(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("Codec device write fail."); return HDF_FAILURE; @@ -698,36 +698,6 @@ int32_t AudioAccessoryWriteReg(const struct AccessoryDevice *accessory, uint32_t return HDF_SUCCESS; } -int32_t AudioCodecAiaoWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val) -{ - int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->AiaoWrite == NULL) { - ADM_LOG_ERR("Input param codec aiao is NULL."); - return HDF_FAILURE; - } - ret = codec->devData->AiaoWrite(codec, reg, val); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Codec aiao device write fail."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioAccessoryAiaoWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val) -{ - int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->AiaoWrite == NULL) { - ADM_LOG_ERR("Input param accessory aiao is NULL."); - return HDF_FAILURE; - } - ret = accessory->devData->AiaoWrite(accessory, reg, val); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Accessory aiao device write fail."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo) { struct AudioMixerControl *mixerCtrl = NULL; @@ -750,7 +720,7 @@ int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlE return HDF_SUCCESS; } -static int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, +int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t rcurValue) { if (elemValue == NULL || mixerCtrl == NULL) { @@ -777,7 +747,7 @@ static int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, return HDF_SUCCESS; } -static int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, +int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t curValue) { if (elemValue == NULL || mixerCtrl == NULL) { @@ -859,71 +829,7 @@ int32_t AudioAccessoryGetCtrlOps(const struct AudioKcontrol *kcontrol, struct Au return HDF_SUCCESS; } -int32_t AudioCodecAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) -{ - uint32_t curValue = 0; - uint32_t rcurValue = 0; - struct CodecDevice *codec = NULL; - struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { - ADM_LOG_ERR("CODECAIAO input param is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - codec = AudioKcontrolGetCodec(kcontrol); - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (mixerCtrl == NULL || codec == NULL) { - ADM_LOG_ERR("mixerCtrl and codec is NULL."); - return HDF_FAILURE; - } - if (AudioCodecAiaoReadReg(codec, mixerCtrl->reg, &curValue) != HDF_SUCCESS || - AudioCodecAiaoReadReg(codec, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Read Reg fail."); - return HDF_FAILURE; - } - if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || - AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio CODECAIAO get kcontrol reg and rreg fail."); - return HDF_FAILURE; - } - - ADM_LOG_DEBUG("Get CODECAIAO ctrl switch successful."); - return HDF_SUCCESS; -} - -int32_t AudioAccessoryAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) -{ - uint32_t curValue = 0; - uint32_t rcurValue = 0; - struct AccessoryDevice *accessory = NULL; - struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { - ADM_LOG_ERR("ACCESSORYCAIAO input param is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - accessory = AudioKcontrolGetAccessory(kcontrol); - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (mixerCtrl == NULL || accessory == NULL) { - ADM_LOG_ERR("mixerCtrl and accessory is NULL."); - return HDF_FAILURE; - } - if (AudioAccessoryAiaoReadReg(accessory, mixerCtrl->reg, &curValue) != HDF_SUCCESS || - AudioAccessoryAiaoReadReg(accessory, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Read Reg fail."); - return HDF_FAILURE; - } - if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || - AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio ACCESSORYCAIAO get kcontrol reg and rreg fail."); - return HDF_FAILURE; - } - - ADM_LOG_DEBUG("Get ACCESSORYCAIAO ctrl switch successful."); - return HDF_SUCCESS; -} - -static int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, +int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t *value) { if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL || @@ -944,7 +850,7 @@ static int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const st return HDF_SUCCESS; } -static int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, +int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, struct AudioMixerControl *mixerCtrl, uint32_t *rvalue, bool *updateRReg) { uint32_t rshift; @@ -1054,79 +960,74 @@ int32_t AudioAccessorySetCtrlOps(const struct AudioKcontrol *kcontrol, const str return HDF_SUCCESS; } -int32_t AudioCodecAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) +int32_t AudioCpuDaiSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) { uint32_t value; uint32_t rvalue; bool updateRReg = false; - struct CodecDevice *codec = NULL; + struct DaiDevice *dai = NULL; struct AudioMixerControl *mixerCtrl = NULL; if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) { - ADM_LOG_ERR("Audio codec aiao input param is NULL."); + ADM_LOG_ERR("Audio input param is NULL."); return HDF_ERR_INVALID_OBJECT; } mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsReg fail."); - return HDF_FAILURE; + ADM_LOG_ERR("AudioSetCtrlOpsReg is fail."); + return HDF_ERR_INVALID_OBJECT; } - - codec = AudioKcontrolGetCodec(kcontrol); - if (AudioUpdateCodecAiaoRegBits(codec, mixerCtrl, value) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio codec aiao stereo update reg bits fail."); + dai = AudioKcontrolGetCpuDai(kcontrol); + if (dai == NULL) { + ADM_LOG_ERR("AudioKcontrolGetCodec is fail."); + return HDF_ERR_INVALID_OBJECT; + } + if (AudioUpdateDaiRegBits(dai, mixerCtrl, value) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec stereo update reg bits fail."); return HDF_FAILURE; } if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsRReg fail."); - return HDF_FAILURE; + ADM_LOG_ERR("AudioSetCtrlOpsRReg is fail."); + return HDF_ERR_INVALID_OBJECT; } + if (updateRReg) { - if (AudioUpdateCodecAiaoRegBits(codec, mixerCtrl, rvalue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio codec aiao stereo update reg bits fail."); + if (AudioUpdateDaiRegBits(dai, mixerCtrl, rvalue) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec stereo update reg bits fail."); return HDF_FAILURE; } } - return HDF_SUCCESS; } -int32_t AudioAccessoryAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) +int32_t AudioCpuDaiGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) { - uint32_t value; - uint32_t rvalue; - bool updateRReg = false; - struct AccessoryDevice *accessory = NULL; + uint32_t curValue = 0; + uint32_t rcurValue = 0; struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) { - ADM_LOG_ERR("Audio accessory aiao input param is NULL."); + struct DaiDevice *dai = NULL; + if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { + ADM_LOG_ERR("Audio input param is NULL."); return HDF_ERR_INVALID_OBJECT; } - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsReg fail."); + dai = AudioKcontrolGetCpuDai(kcontrol); + if (mixerCtrl == NULL || dai == NULL) { + ADM_LOG_ERR("mixerCtrl and codec is NULL."); return HDF_FAILURE; } - - accessory = AudioKcontrolGetAccessory(kcontrol); - if (AudioUpdateAccessoryAiaoRegBits(accessory, mixerCtrl, value) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio accessory aiao stereo update reg bits fail."); + if (AudioDaiReadReg(dai, mixerCtrl->reg, &curValue) != HDF_SUCCESS || + AudioDaiReadReg(dai, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { + ADM_LOG_ERR("Read Reg fail."); return HDF_FAILURE; } - - if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsRReg fail."); + if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || + AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec get kcontrol reg and rreg fail."); return HDF_FAILURE; } - if (updateRReg) { - if (AudioUpdateAccessoryAiaoRegBits(accessory, mixerCtrl, rvalue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio accessory aiao stereo update reg bits fail."); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; } + diff --git a/model/audio/core/src/audio_host.c b/model/audio/core/src/audio_host.c index 574cbdf1e60d62caa88e2519cbc4378cefd94bbb..22f5235cfcd4da234af67881ac3feaa382da73ae 100755 --- a/model/audio/core/src/audio_host.c +++ b/model/audio/core/src/audio_host.c @@ -11,6 +11,7 @@ #include "audio_core.h" #include "audio_parse.h" #include "audio_sapm.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_host @@ -164,7 +165,7 @@ static int32_t AudioDspDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioCodecDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioCodecDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *codecDai = NULL; @@ -194,7 +195,7 @@ static int32_t AudioCodecDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioAccessoryDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioAccessoryDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *accessoryDai = NULL; @@ -224,7 +225,7 @@ static int32_t AudioAccessoryDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioCpuDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioCpuDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *cpuDai = NULL; @@ -254,7 +255,7 @@ static int32_t AudioCpuDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioDspDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioDspDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *dspDai = NULL; @@ -295,22 +296,18 @@ static int32_t AudioInitDaiLink(struct AudioCard *audioCard) if (AudioPlatformDevInit(audioCard) || AudioCpuDaiDevInit(audioCard)) { ADM_LOG_ERR("Platform and CpuDai init fail."); - return HDF_ERR_IO; } if ((AudioCodecDevInit(audioCard) || AudioCodecDaiDevInit(audioCard))) { - ADM_LOG_ERR("codec init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("codec Device init fail."); } if (AudioAccessoryDevInit(audioCard) || AudioAccessoryDaiDevInit(audioCard)) { - ADM_LOG_ERR("Accessory init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("Accessory Device init fail."); } if (AudioDspDevInit(audioCard) || AudioDspDaiDevInit(audioCard)) { - ADM_LOG_ERR("Dsp Dai init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("Dsp Device init fail."); } ADM_LOG_DEBUG("success."); @@ -387,6 +384,8 @@ static int32_t AudioDriverInit(struct HdfDeviceObject *device) return HDF_ERR_IO; } + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; + /* Bind specific codec、platform and dai device */ ret = AudioBindDaiLink(audioCard, &(audioCard->configData)); if (ret != HDF_SUCCESS) { diff --git a/model/audio/core/src/audio_parse.c b/model/audio/core/src/audio_parse.c index b483b3c0b3fc1f329fb2caab4ed23212e8f8ce82..751b9af2bb80e9cd80a62a193a42e45cfb9374f4 100755 --- a/model/audio/core/src/audio_parse.c +++ b/model/audio/core/src/audio_parse.c @@ -7,9 +7,61 @@ */ #include "audio_parse.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_parse +enum AudioRegCfgIndex { + AUDIO_REG_CFG_REG_INDEX = 0, + AUDIO_REG_CFG_RREG_INDEX, + AUDIO_REG_CFG_SHIFT_INDEX, + AUDIO_REG_CFG_RSHIFT_INDEX, + AUDIO_REG_CFG_MIN_INDEX, + AUDIO_REG_CFG_MAX_INDEX, + AUDIO_REG_CFG_MASK_INDEX, + AUDIO_REG_CFG_INVERT_INDEX, + AUDIO_REG_CFG_VALUE_INDEX, + AUDIO_REG_CFG_INDEX_MAX +}; + +enum AudioAddrCfgIndex { + AUDIO_ADDR_CFG_REG_INDEX = 0, + AUDIO_ADDR_CFG_VALUE_INDEX, + AUDIO_ADDR_CFG_INDEX_MAX +}; + +enum AudioCrtlCfgIndex { + AUDIO_CTRL_CFG_INDEX_INDEX = 0, + AUDIO_CTRL_CFG_IFACE_INDEX, + AUDIO_CTRL_CFG_ENABLE_INDEX, + AUDIO_CTRL_CFG_INDEX_MAX +}; + +enum AudioSapmComponentIndex { + AUDIO_SAPM_COMP_INDEX_TYPE = 0, + AUDIO_SAPM_COMP_INDEX_NAME, + AUDIO_SAPM_COMP_INDEX_REG, + AUDIO_SAPM_COMP_INDEX_MASK, + AUDIO_SAPM_COMP_INDEX_SHIFT, + AUDIO_SAPM_COMP_INDEX_INVERT, + AUDIO_SAPM_COMP_INDEX_KCTL, + AUDIO_SAPM_COMP_INDEX_KCTLNUM, + AUDIO_SAPM_COMP_INDEX_MAX +}; + + +static char *g_audioRegGroupName[AUDIO_GROUP_MAX] = { + "resetSeqConfig", + "initSeqConfig", + "ctrlParamsSeqConfig", + "ctrlSapmParamsSeqConfig", + "daiStartupSeqConfig", + "daiParamsSeqConfig", + "controlsConfig", + "sapmComponent", + "sapmConfig" +}; + int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioConfigData *configData) { const struct DeviceResourceNode *node = NULL; @@ -58,3 +110,382 @@ int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioCo return HDF_SUCCESS; } + +static uint32_t GetAudioRegGroupNameIndex(const char *name) +{ + uint32_t index; + + if (name == NULL) { + return AUDIO_GROUP_MAX; + } + + for (index = 0; index < AUDIO_GROUP_MAX; ++index) { + if ((g_audioRegGroupName[index] != NULL) && (strcmp(name, g_audioRegGroupName[index]) == 0)) { + break; + } + } + + return index; +} + +static uint32_t* GetRegArray(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group, uint32_t indexMax) +{ + int32_t ret; + + if (group == NULL || parser == NULL || regNode == NULL || indexMax == 0) { + ADM_LOG_ERR("Input para check error"); + return NULL; + } + + int32_t index = group->groupIndex; + if (index >= AUDIO_GROUP_MAX) { + ADM_LOG_ERR("Input indexMax=%d error", index); + return NULL; + } + + int32_t num = parser->GetElemNum(regNode, g_audioRegGroupName[index]); + if (num <= 0 || num > AUDIO_CONFIG_MAX_ITEM) { + ADM_LOG_ERR("parser %s element num failed", g_audioRegGroupName[index]); + return NULL; + } + + group->itemNum = (num + 1) / indexMax; + + uint32_t *buf = (uint32_t *)OsalMemCalloc(sizeof(uint32_t) * num); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return NULL; + } + + ret = parser->GetUint32Array(regNode, g_audioRegGroupName[index], buf, num, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser %s reg array failed", g_audioRegGroupName[index]); + OsalMemFree(buf); + return NULL; + } + return buf; +} + +static int32_t ParseAudioRegItem(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (group == NULL || parser == NULL || regNode == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + int32_t *buf = GetRegArray(parser, regNode, group, AUDIO_REG_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->regCfgItem = + (struct AudioMixerControl*)OsalMemCalloc(group->itemNum * sizeof(*(group->regCfgItem))); + if (group->regCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio reg config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_REG_CFG_INDEX_MAX * index; + + group->regCfgItem[index].reg = buf[step + AUDIO_REG_CFG_REG_INDEX]; + group->regCfgItem[index].rreg = buf[step + AUDIO_REG_CFG_RREG_INDEX]; + group->regCfgItem[index].shift = buf[step + AUDIO_REG_CFG_SHIFT_INDEX]; + group->regCfgItem[index].rshift = buf[step + AUDIO_REG_CFG_RSHIFT_INDEX]; + group->regCfgItem[index].min = buf[step + AUDIO_REG_CFG_MIN_INDEX]; + group->regCfgItem[index].max = buf[step + AUDIO_REG_CFG_MAX_INDEX]; + group->regCfgItem[index].mask = buf[step + AUDIO_REG_CFG_MASK_INDEX]; + group->regCfgItem[index].invert = buf[step + AUDIO_REG_CFG_INVERT_INDEX]; + group->regCfgItem[index].value = buf[step + AUDIO_REG_CFG_VALUE_INDEX]; + } + OsalMemFree(buf); + + return HDF_SUCCESS; +} + +static int32_t ParseAudioSapmItem(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (group == NULL || parser == NULL || regNode == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_SAPM_COMP_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->sapmCompItem = + (struct AudioSapmCtrlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->sapmCompItem))); + if (group->sapmCompItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio reg config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_SAPM_COMP_INDEX_MAX * index; + group->sapmCompItem[index].sapmType = buf[step + AUDIO_SAPM_COMP_INDEX_TYPE]; + group->sapmCompItem[index].compNameIndex = buf[step + AUDIO_SAPM_COMP_INDEX_NAME]; + group->sapmCompItem[index].reg = buf[step + AUDIO_SAPM_COMP_INDEX_REG]; + group->sapmCompItem[index].mask = buf[step + AUDIO_SAPM_COMP_INDEX_MASK]; + group->sapmCompItem[index].shift = buf[step + AUDIO_SAPM_COMP_INDEX_SHIFT]; + group->sapmCompItem[index].invert = buf[step + AUDIO_SAPM_COMP_INDEX_INVERT]; + group->sapmCompItem[index].kcontrolNews = buf[step + AUDIO_SAPM_COMP_INDEX_KCTL]; + group->sapmCompItem[index].kcontrolsNum = buf[step + AUDIO_SAPM_COMP_INDEX_KCTLNUM]; + } + + OsalMemFree(buf); + return HDF_SUCCESS; +} + + +static int32_t ParseAudioCtrlItem(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (parser == NULL || regNode == NULL || group == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_CTRL_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->ctrlCfgItem = + (struct AudioControlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->ctrlCfgItem))); + if (group->ctrlCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio ctrl config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_CTRL_CFG_INDEX_MAX * index; + + group->ctrlCfgItem[index].arrayIndex = buf[step + AUDIO_CTRL_CFG_INDEX_INDEX]; + group->ctrlCfgItem[index].iface = buf[step + AUDIO_CTRL_CFG_IFACE_INDEX]; + group->ctrlCfgItem[index].enable = buf[step + AUDIO_CTRL_CFG_ENABLE_INDEX]; + } + OsalMemFree(buf); + return HDF_SUCCESS; +} + +static int32_t ParseAudioAddrItem(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index = group->groupIndex; + + if (parser == NULL || regNode == NULL || g_audioRegGroupName[index] == NULL || group == NULL) { + ADM_LOG_ERR("Input para check error: groupName=%p", g_audioRegGroupName[index]); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_ADDR_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->addrCfgItem = (struct AudioAddrConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->addrCfgItem))); + if (group->addrCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio addr config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_ADDR_CFG_INDEX_MAX * index; + + group->addrCfgItem[index].addr = buf[step + AUDIO_ADDR_CFG_REG_INDEX]; + group->addrCfgItem[index].value = buf[step + AUDIO_ADDR_CFG_VALUE_INDEX]; + } + OsalMemFree(buf); + return HDF_SUCCESS; +} + +static int32_t ParseAudioRegGroup(struct DeviceResourceIface *parser, + const struct DeviceResourceNode *regCfgNode, struct AudioRegCfgGroupNode** groupNode, uint32_t index) +{ + int32_t ret = HDF_FAILURE; + struct AudioRegCfgGroupNode *group = NULL; + + if (parser == NULL || regCfgNode == NULL || groupNode == NULL) { + ADM_LOG_ERR("Input para check error: parser=%p, regCfgNode=%p, groupNode=%p.", + parser, regCfgNode, groupNode); + return HDF_FAILURE; + } + + group = *groupNode; + if (group != NULL) { + if (group->regCfgItem != NULL) { + OsalMemFree(group->regCfgItem); + } + + if (group->ctrlCfgItem != NULL) { + OsalMemFree(group->ctrlCfgItem); + } + OsalMemFree(group); + } + + group = (struct AudioRegCfgGroupNode*)OsalMemCalloc(sizeof(*group)); + if (group == NULL) { + ADM_LOG_ERR("malloc audio reg config group failed"); + return HDF_ERR_MALLOC_FAIL; + } + *groupNode = group; + (*groupNode)->groupIndex = index; + + switch(index){ + case AUDIO_CTRL_CFG_GROUP: + case AUDIO_SAPM_CFG_GROUP: + ret = ParseAudioCtrlItem(parser, regCfgNode, group); + break; + case AUDIO_RSET_GROUP: + case AUDIO_INIT_GROUP: + ret = ParseAudioAddrItem(parser, regCfgNode, group); + break; + case AUDIO_DAI_PATAM_GROUP: + case AUDIO_CTRL_PATAM_GROUP: + case AUDIO_CTRL_SAPM_PATAM_GROUP: + case AUDIO_DAI_STARTUP_PATAM_GROUP: + ret = ParseAudioRegItem(parser, regCfgNode, group); + break; + case AUDIO_SAPM_COMP_GROUP: + ret = ParseAudioSapmItem(parser, regCfgNode, group); + break; + default: + ADM_LOG_ERR("parse audio config index = %d not found!", index); + return HDF_FAILURE; + } + + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parse audio config item failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static void ReleaseAudioAllRegConfig(struct AudioRegCfgData *config) +{ + int32_t index; + + if (config == NULL) { + return; + } + + for (index = 0; index < AUDIO_GROUP_MAX; ++index) { + if (config->audioRegParams[index] != NULL) { + if (config->audioRegParams[index]->regCfgItem != NULL) { + OsalMemFree(config->audioRegParams[index]->regCfgItem); + config->audioRegParams[index]->regCfgItem = NULL; + } + OsalMemFree(config->audioRegParams[index]); + config->audioRegParams[index] = NULL; + } + } +} + +static int32_t ParseAudioAttr(struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode, + struct AudioIdInfo *config) +{ + int32_t ret; + ret = parser->GetString(attrNode, "chipName", &config->chipName, NULL); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipName reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + + ret = parser->GetUint32(attrNode, "chipIdRegister", &config->chipIdRegister, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipIdRegister reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + + ret = parser->GetUint32(attrNode, "chipIdSize", &config->chipIdSize, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipIdSize reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + return ret; +} + +int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData) +{ + uint16_t index; + const struct DeviceResourceNode *root = NULL; + const struct DeviceResourceNode *regCfgNode = NULL; + const struct DeviceResourceAttr *regAttr = NULL; + const struct DeviceResourceNode *idNode = NULL; + struct DeviceResourceIface *drsOps = NULL; + + ADM_LOG_DEBUG("Entry."); + + if (device == NULL || configData == NULL) { + ADM_LOG_ERR("Input para check error: device=%p, configData=%p.", device, configData); + return HDF_FAILURE; + } + + root = device->property; + if (root == NULL) { + ADM_LOG_ERR("drs node is NULL."); + return HDF_FAILURE; + } + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + ADM_LOG_ERR("AudioFillConfigData: invalid drs ops fail!"); + return HDF_FAILURE; + } + + idNode = drsOps->GetChildNode(root, "idInfo"); + if (idNode != NULL) { + if (ParseAudioAttr(drsOps, idNode, &configData->audioIdInfo) != HDF_SUCCESS) { + ADM_LOG_ERR("audio reg node attr is null"); + return HDF_FAILURE; + } + } + + regCfgNode = drsOps->GetChildNode(root, "regConfig"); + if (regCfgNode == NULL) { + ADM_LOG_ERR("CodecGetRegConfig: Read audioRegConfig fail!"); + return HDF_FAILURE; + } + + DEV_RES_NODE_FOR_EACH_ATTR(regCfgNode, regAttr) { + if (regAttr == NULL || regAttr->name == NULL) { + ADM_LOG_ERR("audio reg node attr is null"); + return HDF_FAILURE; + } + + index = GetAudioRegGroupNameIndex(regAttr->name); + if (index >= AUDIO_GROUP_MAX) { + continue; + } + + if (ParseAudioRegGroup(drsOps, regCfgNode, &configData->audioRegParams[index], index) != HDF_SUCCESS) { + ADM_LOG_ERR("parse audio register group failed"); + ReleaseAudioAllRegConfig(configData); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} diff --git a/model/audio/core/test/unittest/common/audio_common_test.h b/model/audio/core/test/unittest/common/audio_common_test.h index 74f213f15efc9be3adc311d3a2d6dc6d6d4f48c3..99441c5b440744803c938d4fc4c215dd7a367313 100755 --- a/model/audio/core/test/unittest/common/audio_common_test.h +++ b/model/audio/core/test/unittest/common/audio_common_test.h @@ -27,29 +27,19 @@ enum { TESTBINDDAILINK, TESTUPDATECODECREGBITS, TESTUPDATEACCESSORYREGBITS, - TESTUPDATECODECAIAOREGBITS, - TESTUPDATEACCESSORYAIAOREGBITS, TESTKCONTROLGETCODEC, TESTKCONTROLGETACCESSORY, TESTADDCONTROL, TESTADDCONTROLS, TESTCODECREADREG, TESTACCESSORYREADREG, - TESTCODECAIAOREADREG, - TESTACCESSORYAIAOREADREG, TESTCODECWRITEREG, TESTACCESSORYWRITEREG, - TESTCODECAIAOWRITEREG, - TESTACCESSORYAIAOWRITEREG, TESTINFOCTRLOPS, TESTCODECGETCTRLOPS, TESTACCESSORYGETCTRLOPS, - TESTCODECAIAOGETCTRLOPS, - TESTACCESSORYAIAOGETCTRLOPS, TESTCODECSETCTRLOPS, TESTACCESSORYSETCTRLOPS, - TESTCODECAIAOSETCTRLOPS, - TESTACCESSORYAIAOSETCTRLOPS, TESTNEWCOMPONENT, TESTADDROUTES, diff --git a/model/audio/core/test/unittest/common/audio_core_test.cpp b/model/audio/core/test/unittest/common/audio_core_test.cpp index 85410707775ad9acd1eb931b3cc318d1b9ef4dd0..6d653820a22dc9056f6664f4700d7eff6b0bb13d 100755 --- a/model/audio/core/test/unittest/common/audio_core_test.cpp +++ b/model/audio/core/test/unittest/common/audio_core_test.cpp @@ -92,18 +92,6 @@ HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateAccessoryRegBits, TestSize.Level1) EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateCodecAiaoRegBits, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATECODECAIAOREGBITS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateAccessoryAiaoRegBits, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATEACCESSORYAIAOREGBITS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - HWTEST_F(AudioCoreTest, AudioCoreTest_KcontrolGetCodec, TestSize.Level1) { struct HdfTestMsg msg = {g_testAudioType, TESTKCONTROLGETCODEC, -1}; @@ -140,18 +128,6 @@ HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryReadReg, TestSize.Level1) EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoReadReg, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOREADREG, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoReadReg, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOREADREG, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - HWTEST_F(AudioCoreTest, AudioCoreTest_CodecWriteReg, TestSize.Level1) { struct HdfTestMsg msg = {g_testAudioType, TESTCODECWRITEREG, -1}; @@ -164,18 +140,6 @@ HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryWriteReg, TestSize.Level1) EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoWriteReg, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOWRITEREG, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoWriteReg, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOWRITEREG, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - HWTEST_F(AudioCoreTest, AudioCoreTest_InfoCtrlOps, TestSize.Level1) { struct HdfTestMsg msg = {g_testAudioType, TESTINFOCTRLOPS, -1}; @@ -194,18 +158,6 @@ HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryGetCtrlOps, TestSize.Level1) EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoGetCtrlOps, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOGETCTRLOPS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoGetCtrlOps, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOGETCTRLOPS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - HWTEST_F(AudioCoreTest, AudioCoreTest_CodecSetCtrlOps, TestSize.Level1) { struct HdfTestMsg msg = {g_testAudioType, TESTCODECSETCTRLOPS, -1}; @@ -217,16 +169,4 @@ HWTEST_F(AudioCoreTest, AudioCoreTest_AccessorySetCtrlOps, TestSize.Level1) struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYSETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } - -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoSetCtrlOps, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOSETCTRLOPS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} - -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoSetCtrlOps, TestSize.Level1) -{ - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOSETCTRLOPS, -1}; - EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); -} } diff --git a/model/audio/dispatch/include/audio_stream_dispatch.h b/model/audio/dispatch/include/audio_stream_dispatch.h index b1d4c75298ce9c17b8c283327d1a278eab08c955..3e9a2c65468c3b9dd8f123475ffaf7274f1d67cd 100755 --- a/model/audio/dispatch/include/audio_stream_dispatch.h +++ b/model/audio/dispatch/include/audio_stream_dispatch.h @@ -41,9 +41,10 @@ enum StreamDispMethodCmd { AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, - AUDIO_DRV_PCM_IOCTRL_DSP_DECODE, - AUDIO_DRV_PCM_IOCTRL_DSP_ENCODE, - AUDIO_DRV_PCM_IOCTRL_DSP_EQUALIZER, + AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, + AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, + AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, AUDIO_DRV_PCM_IOCTRL_BUTT, }; diff --git a/model/audio/dispatch/src/audio_control_dispatch.c b/model/audio/dispatch/src/audio_control_dispatch.c index 082e66a35ae88f92ddd44a396ea079d8ba27ce12..3f8d5fa99ed2af03c35d2e9554cb3b4b60d6fffd 100755 --- a/model/audio/dispatch/src/audio_control_dispatch.c +++ b/model/audio/dispatch/src/audio_control_dispatch.c @@ -8,6 +8,7 @@ #include "audio_control_dispatch.h" #include "audio_control.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_control_dispatch @@ -126,7 +127,6 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc struct AudioCtrlElemValue elemValue; struct AudioCtrlElemId id; int32_t result; - ADM_LOG_DEBUG("entry."); if ((client == NULL) || (reqData == NULL) || (rspData == NULL)) { ADM_LOG_ERR("Input ElemRead params check error: client=%p, reqData=%p, rspData=%p.", client, reqData, rspData); @@ -148,6 +148,7 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc ADM_LOG_ERR("ElemRead request itemName failed!"); return HDF_FAILURE; } + ADM_LOG_DEBUG("itemName: %s cardServiceName: %s iface: %d ", id.itemName, id.cardServiceName, id.iface); kctrl = AudioGetKctrlInstance(&id); if (kctrl == NULL || kctrl->Get == NULL) { @@ -170,7 +171,6 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc ADM_LOG_ERR("Write response data value[1]=%d failed!", elemValue.value[1]); return HDF_FAILURE; } - ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } @@ -180,7 +180,6 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, struct AudioKcontrol *kctrl = NULL; struct AudioCtrlElemValue elemValue; int32_t result; - ADM_LOG_DEBUG("entry."); if ((client == NULL) || (reqData == NULL)) { ADM_LOG_ERR("Input params check error: client=%p, reqData=%p.", client, reqData); @@ -209,6 +208,10 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, return HDF_FAILURE; } + ADM_LOG_DEBUG("itemName: %s cardServiceName: %s iface: %d value: %d ", elemValue.id.itemName, + elemValue.id.cardServiceName, + elemValue.id.iface, elemValue.value[0]); + kctrl = AudioGetKctrlInstance(&elemValue.id); if (kctrl == NULL || kctrl->Set == NULL) { ADM_LOG_ERR("Find kctrl or Set fail!"); @@ -220,7 +223,6 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, ADM_LOG_ERR("Get control value fail result=%d", result); return HDF_FAILURE; } - ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } diff --git a/model/audio/dispatch/src/audio_stream_dispatch.c b/model/audio/dispatch/src/audio_stream_dispatch.c index ecbf5af3d4db54d8077f5b66632f6761a172aadc..db6375b5e477cace8170896012ecdd54c313782d 100755 --- a/model/audio/dispatch/src/audio_stream_dispatch.c +++ b/model/audio/dispatch/src/audio_stream_dispatch.c @@ -7,6 +7,8 @@ */ #include "audio_stream_dispatch.h" +#include "audio_platform_base.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_stream_dispatch @@ -33,7 +35,7 @@ int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPc * If not, skip the if statement and execute in sequence. */ if (cpuDai->devData->ops->HwParams != NULL) { - int ret = cpuDai->devData->ops->HwParams(audioCard, params, cpuDai); + int ret = cpuDai->devData->ops->HwParams(audioCard, params); if (ret < 0) { ADM_LOG_ERR("cpuDai hardware params fail ret=%d", ret); return HDF_ERR_IO; @@ -68,7 +70,7 @@ int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct Audio * If not, skip the if statement and execute in sequence. */ if (codecDai->devData->ops->HwParams != NULL) { - int ret = codecDai->devData->ops->HwParams(audioCard, params, codecDai); + int ret = codecDai->devData->ops->HwParams(audioCard, params); if (ret < 0) { ADM_LOG_ERR("codecDai hardware params fail ret=%d", ret); return HDF_ERR_IO; @@ -91,21 +93,13 @@ int32_t HwPlatfromDispatch(const struct AudioCard *audioCard, const struct Audio return HDF_FAILURE; } - struct PlatformDevice *platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL) { - ADM_LOG_ERR("platform param is NULL."); - return HDF_FAILURE; - } - /* If there are HwParams function, it will be executed directly. * If not, skip the if statement and execute in sequence. */ - if (platform->devData->ops->HwParams != NULL) { - int ret = platform->devData->ops->HwParams(audioCard, params); - if (ret < 0) { - ADM_LOG_ERR("platform hardware params fail ret=%d", ret); - return HDF_ERR_IO; - } + int ret = AudioHwParams(audioCard, params); + if (ret < 0) { + ADM_LOG_ERR("platform hardware params fail ret=%d", ret); + return HDF_ERR_IO; } return HDF_SUCCESS; @@ -119,12 +113,69 @@ int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPc } /* Traverse through each driver method; Enter if you have, if not, exectue in order */ - if (HwCodecDaiDispatch(audioCard, params) || - HwCpuDaiDispatch(audioCard, params) || - HwPlatfromDispatch(audioCard, params)) { - ADM_LOG_ERR("hardware params fail."); + if (HwCodecDaiDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("codec dai hardware params fail."); + return HDF_FAILURE; + } + + if (HwCpuDaiDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("cpu dai hardware params fail."); + return HDF_FAILURE; + } + + if (HwPlatfromDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("platform dai hardware params fail."); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t AudioDaiDeviceStartup(struct AudioCard *audioCard) +{ + struct DaiDevice *cpuDai = NULL; + struct DaiDevice *codecDai = NULL; + struct DaiDevice *accessoryDai = NULL; + int ret; + + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); return HDF_FAILURE; } + cpuDai = audioCard->rtd->cpuDai; + if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL && + cpuDai->devData->ops->Startup != NULL) { + ret = cpuDai->devData->ops->Startup(audioCard, cpuDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("cpuDai Startup fail."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("cpu dai startup is null."); + } + + codecDai = audioCard->rtd->codecDai; + if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL && + codecDai->devData->ops->Startup != NULL) { + ret = codecDai->devData->ops->Startup(audioCard, codecDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("codecDai Startup fail."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("codec dai startup is null."); + } + + accessoryDai = audioCard->rtd->accessoryDai; + if (accessoryDai != NULL && accessoryDai->devData != NULL && accessoryDai->devData->ops != NULL && + accessoryDai->devData->ops->Startup != NULL) { + ret = accessoryDai->devData->ops->Startup(audioCard, accessoryDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("accessoryDai Startup fail."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("accessory dai startup is null."); + } return HDF_SUCCESS; } @@ -205,10 +256,8 @@ int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBu struct HdfSBuf *reply) { struct AudioPcmHwParams params; - struct StreamHost *streamHost = NULL; struct AudioCard *audioCard = NULL; - char *cardName = NULL; - int ret = HDF_SUCCESS; + int ret; ADM_LOG_DEBUG("entry."); if ((client == NULL || client->device == NULL) || (data == NULL)) { @@ -217,31 +266,14 @@ int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBu } (void)reply; - streamHost = StreamHostFromDevice(client->device); - if (streamHost == NULL) { - ADM_LOG_ERR("renderHost is NULL"); - return HDF_FAILURE; - } - - cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); - if (cardName == NULL) { - ADM_LOG_ERR("malloc cardServiceName fail!"); - return HDF_FAILURE; - } - streamHost->priv = cardName; - (void)memset_s(¶ms, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + ret = HwParamsDataAnalysis(data, ¶ms); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("hwparams data analysis failed ret=%d", ret); return HDF_FAILURE; } - if (memcpy_s(cardName, BUFF_SIZE_MAX, params.cardServiceName, BUFF_SIZE_MAX) != EOK) { - ADM_LOG_ERR("memcpy cardName failed."); - return HDF_FAILURE; - } - audioCard = GetCardInstance(params.cardServiceName); if (audioCard == NULL) { ADM_LOG_ERR("get card instance fail."); @@ -292,8 +324,6 @@ static struct AudioCard *StreamHostGetCardInstance(const struct HdfDeviceIoClien int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -307,25 +337,81 @@ int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct (void)reply; audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("CapturePrepare get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CapturePrepare == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = AudioCapturePrepare(audioCard); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform CapturePrepare fail ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t StreamHostCaptureOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + char *cardName = NULL; + const char *carNameTemp = NULL; + struct StreamHost *streamHost = NULL; + struct AudioCard *audioCard = NULL; + + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("StreamHostCaptureOpen input param is NULL."); return HDF_FAILURE; } - ret = platform->devData->ops->CapturePrepare(audioCard); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform CapturePrepare fail ret=%d", ret); + (void)reply; + + cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); + if (cardName == NULL) { + ADM_LOG_ERR("malloc cardServiceName fail!"); + return HDF_FAILURE; + } + + streamHost = StreamHostFromDevice(client->device); + if (streamHost == NULL) { + OsalMemFree(cardName); + ADM_LOG_ERR("renderHost is NULL"); + return HDF_FAILURE; + } + + if (!(carNameTemp = HdfSbufReadString(data))) { + OsalMemFree(cardName); + ADM_LOG_ERR("read request cardServiceName failed!"); + return HDF_FAILURE; + } + + if (strncpy_s(cardName, BUFF_SIZE_MAX - 1, carNameTemp, strlen(carNameTemp) + 1) != EOK) { + ADM_LOG_ERR("memcpy cardName failed."); + OsalMemFree(cardName); + return HDF_FAILURE; + } + ADM_LOG_DEBUG("card name: %s.", cardName); + streamHost->priv = cardName; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL) { + ADM_LOG_ERR("StreamHostCaptureOpen get card instance or rtd fail."); + return HDF_FAILURE; + } + + if (AudioCaptureOpen(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("platform CaptureOpen fail"); return HDF_ERR_IO; } + if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("Dai Device Startup fail."); + return HDF_FAILURE; + } + ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } @@ -333,8 +419,6 @@ int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -352,16 +436,8 @@ int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct H ADM_LOG_ERR("RenderPrepare get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderPrepare == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - - ret = platform->devData->ops->RenderPrepare(audioCard); + ret = AudioRenderPrepare(audioCard); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform RenderPrepare fail ret=%d", ret); return HDF_ERR_IO; @@ -371,51 +447,101 @@ int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct H return HDF_SUCCESS; } -static int32_t StreamTransferWrite(const struct AudioCard *audioCard, struct AudioTxData *transfer) +int32_t StreamHostRenderOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) { - struct PlatformDevice *platform = NULL; - int32_t ret = HDF_SUCCESS; + char *cardName = NULL; + const char *carNameTemp = NULL; + struct StreamHost *streamHost = NULL; + struct AudioCard *audioCard = NULL; - if (audioCard == NULL || audioCard->rtd == NULL || transfer == NULL) { - ADM_LOG_ERR("input param is NULL."); + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("StreamHostRenderOpen input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->Write == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); + (void)reply; + + cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); + if (cardName == NULL) { + ADM_LOG_ERR("malloc cardServiceName fail!"); return HDF_FAILURE; } - ret = platform->devData->ops->Write(audioCard, transfer); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform write fail ret=%d", ret); + streamHost = StreamHostFromDevice(client->device); + if (streamHost == NULL) { + ADM_LOG_ERR("renderHost is NULL"); + OsalMemFree(cardName); + return HDF_FAILURE; + } + + if (!(carNameTemp = HdfSbufReadString(data))) { + ADM_LOG_ERR("read request cardServiceName failed!"); + OsalMemFree(cardName); return HDF_FAILURE; } + if (strncpy_s(cardName, BUFF_SIZE_MAX - 1, carNameTemp, strlen(carNameTemp) + 1) != EOK) { + ADM_LOG_ERR("memcpy cardName failed."); + OsalMemFree(cardName); + return HDF_FAILURE; + } + + ADM_LOG_DEBUG("card name: %s.", cardName); + + streamHost->priv = cardName; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("StreamHostRenderOpen get card instance or rtd fail."); + return HDF_FAILURE; + } + + if (AudioRenderOpen(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("platform RenderOpen fail."); + return HDF_FAILURE; + } + + if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("Dai Device Startup fail."); + return HDF_FAILURE; + } + + ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, const struct AudioTxMmapData *txMmapData) +static int32_t StreamTransferWrite(const struct AudioCard *audioCard, struct AudioTxData *transfer) { - struct PlatformDevice *platform = NULL; - int32_t ret = HDF_SUCCESS; - ADM_LOG_DEBUG("entry."); + int32_t ret; - if (audioCard == NULL || audioCard->rtd == NULL || txMmapData == NULL) { + if (audioCard == NULL || transfer == NULL) { ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->Write == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); + ret = AudioPcmWrite(audioCard, transfer); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("pcm write fail ret=%d", ret); return HDF_FAILURE; } - ret = platform->devData->ops->MmapWrite(audioCard, txMmapData); + return HDF_SUCCESS; +} + +static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, const struct AudioMmapData *txMmapData) +{ + int32_t ret; + ADM_LOG_DEBUG("entry."); + + if (audioCard == NULL || txMmapData == NULL) { + ADM_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + ret = AudioPcmMmapWrite(audioCard, txMmapData); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform write fail ret=%d", ret); return HDF_FAILURE; @@ -425,25 +551,17 @@ static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, const return HDF_SUCCESS; } -static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, const struct AudioRxMmapData *rxMmapData) +static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, const struct AudioMmapData *rxMmapData) { - struct PlatformDevice *platform = NULL; - int32_t ret = HDF_SUCCESS; + int32_t ret; ADM_LOG_DEBUG("entry."); - if (audioCard == NULL || audioCard->rtd == NULL || rxMmapData == NULL) { + if (audioCard == NULL || rxMmapData == NULL) { ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->MmapRead == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); - return HDF_FAILURE; - } - - ret = platform->devData->ops->MmapRead(audioCard, rxMmapData); + ret = AudioPcmMmapRead(audioCard, rxMmapData); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform read fail ret=%d", ret); return HDF_FAILURE; @@ -497,8 +615,6 @@ int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf * int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; struct AudioRxData rxData; int ret = HDF_SUCCESS; @@ -511,22 +627,14 @@ int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *d (void)data; audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || - platform->devData->ops == NULL || platform->devData->ops->Read == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - - ret = platform->devData->ops->Read(audioCard, &rxData); + ret = AudioPcmRead(audioCard, &rxData); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform read fail ret=%d", ret); + ADM_LOG_ERR("pcm read fail ret=%d", ret); return HDF_FAILURE; } @@ -551,7 +659,7 @@ int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *d int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioTxMmapData txMmapData; + struct AudioMmapData txMmapData; struct AudioCard *audioCard = NULL; uint64_t mAddress = 0; ADM_LOG_DEBUG("entry."); @@ -603,16 +711,16 @@ int32_t StreamHostMmapPositionWrite(const struct HdfDeviceIoClient *client, stru return HDF_FAILURE; } audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->platform == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("audioCard instance is NULL."); return HDF_FAILURE; } - struct PlatformHost *platformHost = PlatformHostFromDevice(audioCard->rtd->platform->device); - if (platformHost == NULL) { + struct PlatformData *platformData = PlatformDataFromCard(audioCard); + if (platformData == NULL) { ADM_LOG_ERR("platformHost instance is NULL."); return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, platformHost->renderBufInfo.framesPosition)) { + if (!HdfSbufWriteUint64(reply, platformData->renderBufInfo.framesPosition)) { ADM_LOG_ERR("render mmap write position fail!"); return HDF_FAILURE; } @@ -624,7 +732,7 @@ int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBu { uint64_t mAddress = 0; struct AudioCard *audioCard = NULL; - struct AudioRxMmapData rxMmapData; + struct AudioMmapData rxMmapData; ADM_LOG_DEBUG("entry."); if (client == NULL || reply == NULL) { ADM_LOG_ERR("input param is NULL."); @@ -674,16 +782,16 @@ int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client, struc return HDF_FAILURE; } audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->platform == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("audioCard is NULL."); return HDF_FAILURE; } - struct PlatformHost *platformHost = PlatformHostFromDevice(audioCard->rtd->platform->device); - if (platformHost == NULL) { + struct PlatformData *platformData = PlatformDataFromCard(audioCard); + if (platformData == NULL) { ADM_LOG_ERR("platformHost is NULL."); return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, platformHost->captureBufInfo.framesPosition)) { + if (!HdfSbufWriteUint64(reply, platformData->captureBufInfo.framesPosition)) { ADM_LOG_ERR("render mmap write position fail!"); return HDF_FAILURE; } @@ -694,7 +802,8 @@ int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client, struc int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; + struct DaiDevice *cpuDai = NULL; + struct DaiDevice *codecDai = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -713,15 +822,21 @@ int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client, struct Hdf return HDF_FAILURE; } rtd = audioCard->rtd; + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderStart == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; + cpuDai = rtd->cpuDai; + if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL && + cpuDai->devData->ops->Trigger != NULL) { + cpuDai->devData->ops->Trigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_START, cpuDai); + } + + codecDai = rtd->codecDai; + if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL && + codecDai->devData->ops->Trigger != NULL) { + codecDai->devData->ops->Trigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_START, codecDai); } - ret = platform->devData->ops->RenderStart(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_START); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform render start fail ret=%d", ret); return HDF_ERR_IO; @@ -733,8 +848,6 @@ int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client, struct Hdf int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -752,16 +865,9 @@ int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, struct Hd ADM_LOG_ERR("CaptureStart get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureStart == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; - ret = platform->devData->ops->CaptureStart(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform capture start fail ret=%d", ret); return HDF_ERR_IO; @@ -774,8 +880,6 @@ int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, struct Hd int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -785,7 +889,6 @@ int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfS return HDF_FAILURE; } - (void)data; (void)reply; audioCard = StreamHostGetCardInstance(client); @@ -793,16 +896,13 @@ int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfS ADM_LOG_ERR("RenderStop get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderStop == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) { + ADM_LOG_ERR("read request streamType failed!"); return HDF_FAILURE; } - ret = platform->devData->ops->RenderStop(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform render stop fail ret=%d", ret); return HDF_ERR_IO; @@ -812,10 +912,40 @@ int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfS return HDF_SUCCESS; } +int32_t StreamHostRenderClose(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + struct AudioCard *audioCard = NULL; + int ret; + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("RenderClose input param is NULL."); + return HDF_FAILURE; + } + + (void)data; + (void)reply; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("RenderStop get card instance or rtd fail."); + return HDF_FAILURE; + } + + ret = AudioRenderClose(audioCard); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform RenderClose fail ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + + int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -825,7 +955,6 @@ int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct Hdf return HDF_FAILURE; } - (void)data; (void)reply; audioCard = StreamHostGetCardInstance(client); @@ -833,16 +962,13 @@ int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct Hdf ADM_LOG_ERR("CaptureStop get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureStop == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) { + ADM_LOG_ERR("read request streamType failed!"); return HDF_FAILURE; } - ret = platform->devData->ops->CaptureStop(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform capture stop fail ret=%d", ret); return HDF_ERR_IO; @@ -852,10 +978,39 @@ int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct Hdf return HDF_SUCCESS; } +int32_t StreamHostCaptureClose(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct AudioCard *audioCard = NULL; + int ret; + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("CaptureClose input param is NULL."); + return HDF_FAILURE; + } + + (void)data; + (void)reply; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("CaptureStop get card instance or rtd fail."); + return HDF_FAILURE; + } + + ret = AudioCaptureClose(audioCard); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform capture close fail ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + + int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -873,16 +1028,8 @@ int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct Hdf ADM_LOG_ERR("RenderPause get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderPause == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - ret = platform->devData->ops->RenderPause(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform render pause fail ret=%d", ret); return HDF_ERR_IO; @@ -895,8 +1042,6 @@ int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct Hdf int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -914,16 +1059,8 @@ int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct Hd ADM_LOG_ERR("CapturePause get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CapturePause == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - ret = platform->devData->ops->CapturePause(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform captur pause fail ret=%d", ret); return HDF_ERR_IO; @@ -936,10 +1073,8 @@ int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct Hd int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret = HDF_SUCCESS; + int ret; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -955,16 +1090,8 @@ int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct Hd ADM_LOG_ERR("RenderResume get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderResume == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - ret = platform->devData->ops->RenderResume(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform RenderResume fail ret=%d", ret); return HDF_ERR_IO; @@ -977,8 +1104,6 @@ int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct Hd int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); @@ -996,16 +1121,8 @@ int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct H ADM_LOG_ERR("CaptureResume get card instance or rtd fail."); return HDF_FAILURE; } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureResume == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - ret = platform->devData->ops->CaptureResume(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("platform CaptureResume fail ret=%d", ret); return HDF_ERR_IO; @@ -1136,10 +1253,14 @@ static struct StreamDispCmdHandleList g_streamDispCmdHandle[] = { {AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, StreamHostHwParams}, {AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, StreamHostRenderPrepare}, {AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, StreamHostCapturePrepare}, + {AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, StreamHostRenderOpen}, + {AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, StreamHostRenderClose}, {AUDIO_DRV_PCM_IOCTRL_WRITE, StreamHostWrite}, {AUDIO_DRV_PCM_IOCTRL_READ, StreamHostRead}, {AUDIO_DRV_PCM_IOCTRL_RENDER_START, StreamHostRenderStart}, {AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, StreamHostRenderStop}, + {AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, StreamHostCaptureOpen}, + {AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, StreamHostCaptureClose}, {AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, StreamHostCaptureStart}, {AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, StreamHostCaptureStop}, {AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, StreamHostRenderPause}, @@ -1150,9 +1271,6 @@ static struct StreamDispCmdHandleList g_streamDispCmdHandle[] = { {AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, StreamHostMmapRead}, {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, StreamHostMmapPositionWrite}, {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, StreamHostMmapPositionRead}, - {AUDIO_DRV_PCM_IOCTRL_DSP_DECODE, StreamHostDspDecode}, - {AUDIO_DRV_PCM_IOCTRL_DSP_ENCODE, StreamHostDspEncode}, - {AUDIO_DRV_PCM_IOCTRL_DSP_EQUALIZER, StreamHostDspEqualizer}, }; int32_t StreamDispatch(struct HdfDeviceIoClient *client, int cmdId, diff --git a/model/audio/sapm/include/audio_sapm.h b/model/audio/sapm/include/audio_sapm.h index 0eaa935cbdd0e776d4d93294158cb72dc3ac1578..7d39f43e9974bd4f7a5a3818ebfe51690051a784 100755 --- a/model/audio/sapm/include/audio_sapm.h +++ b/model/audio/sapm/include/audio_sapm.h @@ -39,6 +39,7 @@ enum AudioSapmType { AUDIO_SAPM_INPUT = 0, /* input pin */ AUDIO_SAPM_OUTPUT, /* output pin */ AUDIO_SAPM_MUX, /* selects 1 analog signal from many inputs */ + AUDIO_SAPM_DEMUX, /* connects the input to one of multiple outputs */ AUDIO_SAPM_VIRT_MUX, /* virtual version of snd_soc_dapm_mux */ AUDIO_SAPM_VALUE_MUX, /* selects 1 analog signal from many inputs */ AUDIO_SAPM_MIXER, /* mixes several analog signals together */ @@ -57,8 +58,12 @@ enum AudioSapmType { AUDIO_SAPM_PRE, /* machine specific pre component - exec first */ AUDIO_SAPM_POST, /* machine specific post component - exec last */ AUDIO_SAPM_SUPPLY, /* power/clock supply */ + AUDIO_SAPM_REGULATOR_SUPPLY, /* external regulator */ + AUDIO_SAPM_CLOCK_SUPPLY, /* external clock */ AUDIO_SAPM_AIF_IN, /* audio interface input */ AUDIO_SAPM_AIF_OUT, /* audio interface output */ + AUDIO_SAPM_SIGGEN, /* signal generator */ + AUDIO_SAPM_SINK, }; /* component has no PM register bit */ diff --git a/model/audio/sapm/src/audio_sapm.c b/model/audio/sapm/src/audio_sapm.c index 496d087a439410a793d5cc6d0d3b3d9de9f29d18..a0d26e327afc9519188febbdbbf6c7cc9547554e 100755 --- a/model/audio/sapm/src/audio_sapm.c +++ b/model/audio/sapm/src/audio_sapm.c @@ -10,6 +10,7 @@ #include "osal_io.h" #include "osal_time.h" #include "osal_timer.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_sapm @@ -152,6 +153,21 @@ static int32_t AudioSapmGenericCheckPower(const struct AudioSapmComponent *sapmC return SAPM_POWER_UP; } +static int32_t AudioSapmAdcPowerClock(struct AudioSapmComponent *sapmComponent) +{ + (void)sapmComponent; + ADM_LOG_INFO("Adc standby mode entry!"); + return HDF_SUCCESS; +} + +static int32_t AudioSapmDdcPowerClock(struct AudioSapmComponent *sapmComponent) +{ + (void)sapmComponent; + ADM_LOG_INFO("Ddc standby mode entry!"); + return HDF_SUCCESS; +} + + static int32_t AudioSapmAdcCheckPower(const struct AudioSapmComponent *sapmComponent) { int32_t input; @@ -239,11 +255,56 @@ static void AudioSampCheckPowerCallback(struct AudioSapmComponent *sapmComponent return; } +static void AudioSampPowerClockCallback(struct AudioSapmComponent *sapmComponent) +{ + if (sapmComponent == NULL) { + ADM_LOG_ERR("input param cpt is NULL."); + return; + } + + switch (sapmComponent->sapmType) { + case AUDIO_SAPM_ANALOG_SWITCH: + case AUDIO_SAPM_MIXER: + case AUDIO_SAPM_MIXER_NAMED_CTRL: + sapmComponent->PowerClockOp = NULL; + break; + case AUDIO_SAPM_MUX: + case AUDIO_SAPM_VIRT_MUX: + case AUDIO_SAPM_VALUE_MUX: + sapmComponent->PowerClockOp = NULL; + break; + case AUDIO_SAPM_ADC: + case AUDIO_SAPM_AIF_OUT: + sapmComponent->PowerClockOp = AudioSapmAdcPowerClock; + break; + case AUDIO_SAPM_DAC: + case AUDIO_SAPM_AIF_IN: + sapmComponent->PowerClockOp = AudioSapmDdcPowerClock; + break; + case AUDIO_SAPM_PGA: + case AUDIO_SAPM_OUT_DRV: + case AUDIO_SAPM_INPUT: + case AUDIO_SAPM_OUTPUT: + case AUDIO_SAPM_MICBIAS: + case AUDIO_SAPM_SPK: + case AUDIO_SAPM_HP: + case AUDIO_SAPM_MIC: + case AUDIO_SAPM_LINE: + sapmComponent->PowerClockOp = NULL; + break; + default: + sapmComponent->PowerClockOp = NULL; + break; + } + + return; +} + int32_t AudioSapmNewComponent(struct AudioCard *audioCard, const struct AudioSapmComponent *component) { struct AudioSapmComponent *sapmComponent = NULL; - if ((audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->codec == NULL) || (component == NULL)) { + if ((audioCard == NULL || audioCard->rtd == NULL) || (component == NULL)) { ADM_LOG_ERR("input params check error: audioCard=%p, component=%p.", audioCard, component); return HDF_FAILURE; } @@ -279,11 +340,13 @@ int32_t AudioSapmNewComponent(struct AudioCard *audioCard, const struct AudioSap OsalMemFree(sapmComponent); return HDF_FAILURE; } + sapmComponent->codec = audioCard->rtd->codec; + sapmComponent->accessory = audioCard->rtd->accessory; sapmComponent->kcontrolsNum = component->kcontrolsNum; sapmComponent->active = 0; AudioSampCheckPowerCallback(sapmComponent); - sapmComponent->PowerClockOp = NULL; + AudioSampPowerClockCallback(sapmComponent); DListHeadInit(&sapmComponent->sources); DListHeadInit(&sapmComponent->sinks); @@ -411,7 +474,7 @@ static void MixerSetPathStatus(const struct AudioSapmComponent *sapmComponent, s uint32_t invert; uint32_t curValue = 0; - if ((sapmComponent == NULL || sapmComponent->codec == NULL) || (path == NULL) || (mixerCtrl == NULL)) { + if ((sapmComponent == NULL) || (path == NULL) || (mixerCtrl == NULL)) { ADM_LOG_ERR("input params check error: sapmComponent=%p, path=%p, mixerCtrl=%p.", sapmComponent, path, mixerCtrl); return; @@ -422,9 +485,20 @@ static void MixerSetPathStatus(const struct AudioSapmComponent *sapmComponent, s mask = mixerCtrl->mask; invert = mixerCtrl->invert; - ret = AudioCodecReadReg(sapmComponent->codec, reg, &curValue); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("read reg fail!"); + if (sapmComponent->codec != NULL) { + ret = AudioCodecReadReg(sapmComponent->codec, reg, &curValue); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("read reg fail!"); + return; + } + } else if (sapmComponent->accessory != NULL) { + ret = AudioAccessoryReadReg(sapmComponent->accessory, reg, &curValue); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("read reg fail!"); + return; + } + } else { + ADM_LOG_ERR("accessory and codec is null!"); return; } @@ -448,25 +522,21 @@ static int32_t AudioSapmSetPathStatus(const struct AudioSapmComponent *sapmCompo switch (sapmComponent->sapmType) { case AUDIO_SAPM_MIXER: case AUDIO_SAPM_ANALOG_SWITCH: - case AUDIO_SAPM_MIXER_NAMED_CTRL: { + case AUDIO_SAPM_MIXER_NAMED_CTRL: MixerSetPathStatus(sapmComponent, path, (struct AudioMixerControl *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue)); - } - break; - case AUDIO_SAPM_MUX: { + break; + case AUDIO_SAPM_MUX: MuxSetPathStatus(sapmComponent, path, (struct AudioEnumKcontrol *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue), i); - } - break; - case AUDIO_SAPM_VALUE_MUX: { + break; + case AUDIO_SAPM_VALUE_MUX: MuxValueSetPathStatus(sapmComponent, path, (struct AudioEnumKcontrol *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue), i); - } - break; - default: { + break; + default: path->connect = CONNECT_SINK_AND_SOURCE; break; - } } return HDF_SUCCESS; @@ -601,7 +671,7 @@ static int32_t AudioSapmAddRoute(struct AudioCard *audioCard, const struct Audio struct AudioSapmComponent *sapmComponent = NULL; int32_t ret; - if ((audioCard == NULL) || (route == NULL || route->source == NULL || route->sink == NULL)) { + if (audioCard == NULL || route == NULL || route->source == NULL || route->sink == NULL) { ADM_LOG_ERR("input params check error: audioCard=%p, route=%p.", audioCard, route); return HDF_FAILURE; } @@ -1218,6 +1288,9 @@ int32_t AudioSampPowerUp(const struct AudioCard *card) DListHeadInit(&upList); DLIST_FOR_EACH_ENTRY(sapmComponent, &card->components, struct AudioSapmComponent, list) { + if (sapmComponent == NULL) { + continue; + } if (sapmComponent->power == SAPM_POWER_DOWN) { AudioSapmPowerSeqInsert(sapmComponent, &upList, SAPM_POWER_UP); } @@ -1279,19 +1352,22 @@ static void AudioSapmEnterSleep(uintptr_t para) return; } - if (!AudioSapmCheckTime()) { - return; + if (audioCard->standbyMode != AUDIO_SAPM_TURN_STANDBY_NOW) { + if (!AudioSapmCheckTime()) { + return; + } } - DLIST_FOR_EACH_ENTRY(sapmComponent, &audioCard->components, struct AudioSapmComponent, list) { - if (sapmComponent->PowerClockOp != NULL) { - if (g_audioSapmIsStandby == false) { - sapmComponent->PowerClockOp(sapmComponent); - g_audioSapmIsStandby = true; - AudioSapmRefreshTime(true); - } + if (g_audioSapmIsStandby == false) { + DLIST_FOR_EACH_ENTRY(sapmComponent, &audioCard->components, struct AudioSapmComponent, list) { + if (sapmComponent->PowerClockOp != NULL) { + sapmComponent->PowerClockOp(sapmComponent); + AudioSapmRefreshTime(true); + } } + g_audioSapmIsStandby = true; } + if (g_audioSapmIsStandby == true) { if (!AudioSapmCheckTime()) { return; diff --git a/test/unittest/model/audio/include/audio_core_test.h b/test/unittest/model/audio/include/audio_core_test.h index b36a9f99cfa48e80826fda647da5128c703325b0..0481e92711669d4f751c9efd488f1800eab3618f 100755 --- a/test/unittest/model/audio/include/audio_core_test.h +++ b/test/unittest/model/audio/include/audio_core_test.h @@ -17,25 +17,28 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t AudioSocTestRegisterDai(void); int32_t AudioSocTestRegisterPlatform(void); +int32_t AudioSocTestRegisterDai(void); +int32_t AudioTestRegisterAccessory(void); int32_t AudioTestRegisterCodec(void); -int32_t AudioTestBindDaiLink(void); +int32_t AudioTestRegisterDsp(void); int32_t AudioTestSocDeviceRegister(void); -int32_t AudioTestSocRegisterDsp(void); -int32_t AudioTestRegisterAccessory(void); -int32_t AudioTestUpdateRegBits(void); -int32_t AudioTestAiaoUpdateRegBits(void); +int32_t AudioTestBindDaiLink(void); +int32_t AudioTestUpdateCodecRegBits(void); +int32_t AudioTestUpdateAccessoryRegBits(void); int32_t AudioTestKcontrolGetCodec(void); -int32_t AudioTestAddControls(void); +int32_t AudioTestKcontrolGetAccessory(void); int32_t AudioTestAddControl(void); -int32_t AudioTestDeviceReadReg(void); -int32_t AudioTestAiaoDeviceReadReg(void); -int32_t AudioTestInfoCtrlSw(void); -int32_t AudioTestGetCtrlSw(void); -int32_t AudioTestPutCtrlSw(void); -int32_t AiaoTestGetCtrlSw(void); -int32_t AiaoTestPutCtrlSw(void); +int32_t AudioTestAddControls(void); +int32_t AudioTestCodecReadReg(void); +int32_t AudioTestAccessoryReadReg(void); +int32_t AudioTestCodecWriteReg(void); +int32_t AudioTestAccessoryWriteReg(void); +int32_t AudioTestInfoCtrlOps(void); +int32_t AudioTestCodecGetCtrlOps(void); +int32_t AudioTestAccessoryGetCtrlOps(void); +int32_t AudioTestCodecSetCtrlOps(void); +int32_t AudioTestAccessorySetCtrlOps(void); #ifdef __cplusplus #if __cplusplus diff --git a/test/unittest/model/audio/include/audio_host_test.h b/test/unittest/model/audio/include/audio_host_test.h index 42160326ba08daac6758c8ce86cca714f1ec50d5..abb05d3ac70752d5082902382b0f5c34ecaf6864 100755 --- a/test/unittest/model/audio/include/audio_host_test.h +++ b/test/unittest/model/audio/include/audio_host_test.h @@ -19,7 +19,6 @@ extern "C" { int32_t AudioKcontrolTestGetCodec(void); int32_t GetCardTestInstance(void); -int32_t AudioHostTestDestroy(void); #ifdef __cplusplus #if __cplusplus diff --git a/test/unittest/model/audio/include/hdf_audio_test.h b/test/unittest/model/audio/include/hdf_audio_test.h index 36a3f34de05166d1cc05ca14c66eba382227a499..9da3251a5b59a8889355f82f99cbbcb34aec5655 100755 --- a/test/unittest/model/audio/include/hdf_audio_test.h +++ b/test/unittest/model/audio/include/hdf_audio_test.h @@ -20,34 +20,45 @@ extern "C" { typedef enum { AUDIO_DRIVER_TESTGETCODEC, AUDIO_DRIVER_TESTGETCARDINSTANCE, - AUDIO_DRIVER_TESTHOSTDESTROY, AUDIO_DRIVER_TESTGETCCNFIGDATA, - AUDIO_DRIVER_TESTREGISTERDAI, AUDIO_DRIVER_TESTREGISTERPLATFORM, + AUDIO_DRIVER_TESTREGISTERDAI, + AUDIO_DRIVER_TESTREGISTERACCESSORY, AUDIO_DRIVER_TESTREGISTERCODEC, - AUDIO_DRIVER_TESTBINDDAILINK, - AUDIO_DRIVER_TESTDEVICEREGISTER, AUDIO_DRIVER_TESTREGISTERDSP, - AUDIO_DRIVER_TESTREGISTERACCESSORY, - AUDIO_DRIVER_TESTUPDATEREGBITS, - AUDIO_DRIVER_TESTAIAOUPDATEREGBITS, + AUDIO_DRIVER_TESTSOCDEVICEREGISTER, + AUDIO_DRIVER_TESTBINDDAILINK, + AUDIO_DRIVER_TESTUPDATECODECREGBITS, + AUDIO_DRIVER_TESTUPDATEACCESSORYREGBITS, + AUDIO_DRIVER_TESTUPDATECODECAIAOREGBITS, + AUDIO_DRIVER_TESTUPDATEACCESSORYAIAOREGBITS, AUDIO_DRIVER_TESTKCONTROLGETCODEC, - AUDIO_DRIVER_TESTADDCONTROLS, + AUDIO_DRIVER_TESTKCONTROLGETACCESSORY, AUDIO_DRIVER_TESTADDCONTROL, - AUDIO_DRIVER_TESTDEVICEREADREG, - AUDIO_DRIVER_TESTAIAODEVICEREADREG, - AUDIO_DRIVER_TESTINFOCTRLSW, - AUDIO_DRIVER_TESTGETCTRLSW, - AUDIO_DRIVER_TESTPUTCTRLSW, - AUDIO_DRIVER_TESTAIAOGETCTRLSW, - AUDIO_DRIVER_TESTAIAOPUTCTRLSW, + AUDIO_DRIVER_TESTADDCONTROLS, + AUDIO_DRIVER_TESTCODECREADREG, + AUDIO_DRIVER_TESTACCESSORYREADREG, + AUDIO_DRIVER_TESTCODECAIAOREADREG, + AUDIO_DRIVER_TESTACCESSORYAIAOREADREG, + AUDIO_DRIVER_TESTCODECWRITEREG, + AUDIO_DRIVER_TESTACCESSORYWRITEREG, + AUDIO_DRIVER_TESTCODECAIAOWRITEREG, + AUDIO_DRIVER_TESTACCESSORYAIAOWRITEREG, + AUDIO_DRIVER_TESTINFOCTRLOPS, + AUDIO_DRIVER_TESTCODECGETCTRLOPS, + AUDIO_DRIVER_TESTACCESSORYGETCTRLOPS, + AUDIO_DRIVER_TESTCODECAIAOGETCTRLOPS, + AUDIO_DRIVER_TESTACCESSORYAIAOGETCTRLOPS, + AUDIO_DRIVER_TESTCODECSETCTRLOPS, + AUDIO_DRIVER_TESTACCESSORYSETCTRLOPS, + AUDIO_DRIVER_TESTCODECAIAOSETCTRLOPS, + AUDIO_DRIVER_TESTACCESSORYAIAOSETCTRLOPS, AUDIO_DRIVER_TESTNEWCOMPONENT, AUDIO_DRIVER_TESTADDROUTES, AUDIO_DRIVER_TESTNEWCONTROLS, AUDIO_DRIVER_TESTPOWERCOMPONET, AUDIO_DRIVER_TESTREFRESHTIME, AUDIO_DRIVER_TESTSTREAMDISPATCH, - AUDIO_DRIVER_TESTSTREAMDESTORY, } HdfAudioTestCaseCmd; int32_t HdfAudioEntry(HdfTestMsg *msg); diff --git a/test/unittest/model/audio/src/audio_core_test.c b/test/unittest/model/audio/src/audio_core_test.c index 1c2c1a47b69910eb3d468c2b77935bd5415571ff..4d10e3390ab7612e1cf512cf04a9620923c8c6e7 100755 --- a/test/unittest/model/audio/src/audio_core_test.c +++ b/test/unittest/model/audio/src/audio_core_test.c @@ -8,156 +8,259 @@ #include "audio_core_test.h" #include "audio_core.h" +#include "audio_parse.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_core_test +#define AUDIO_CORE_SERVICE_TEST_NAME "hdf_audio_codec_dev0" +#define PLATFORM_TEST_NAME "codec_service_1" +#define PLATFORM_CODEC_TEST_NAME "codec_service_0" +#define ACCESSORY_DAI_TEST_NAME "accessory_dai" +#define DSP_TEST_NAME "dsp_service_0" + +const struct AudioMixerControl g_audioMixerRegParams = { + .reg = 0x2004, /* [0] output volume */ + .rreg = 0x2004, /* register value */ + .shift = 8, /* offset */ + .rshift = 8, /* right offset */ + .min = 0x28, /* min value */ + .max = 0x7F, /* max value */ + .mask = 0x7F, /* mask value */ + .invert = 0, /* invert */ +}; -int32_t AudioSocTestRegisterDai(void) +int32_t AudioSocTestRegisterPlatform(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct DaiData *data = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterDai(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterDai fail ret = %d", __func__, ret); + if (AudioSocRegisterPlatform(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterPlatform fail", __func__, __LINE__); + return HDF_FAILURE; } + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + struct PlatformData data = { + .drvPlatformName = PLATFORM_TEST_NAME, + }; + if (AudioSocRegisterPlatform(device, &data) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterPlatform fail", __func__); + return HDF_FAILURE; + } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioSocTestRegisterPlatform(void) +int32_t AudioSocTestRegisterDai(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct PlatformData *data = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterPlatform(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterPlatform fail ret = %d", __func__, ret); + if (AudioSocRegisterDai(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDai fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + struct DaiData data = { + .drvDaiName = ACCESSORY_DAI_TEST_NAME, + }; + if (AudioSocRegisterDai(device, &data) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDai fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestRegisterCodec(void) +int32_t AudioTestRegisterAccessory(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct CodecData *codecData = NULL; - struct DaiData *daiData = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioRegisterCodec(device, codecData, daiData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioRegisterCodec fail ret = %d", __func__, ret); + if (AudioRegisterAccessory(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterAccessory fail", __func__, __LINE__); + return HDF_FAILURE; } + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + struct AccessoryData data = { + .drvAccessoryName = ACCESSORY_DAI_TEST_NAME, + }; + struct DaiData daiData = { + .drvDaiName = ACCESSORY_DAI_TEST_NAME, + }; + + if (AudioRegisterAccessory(device, &data, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterAccessory fail", __func__, __LINE__); + return HDF_FAILURE; + } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestBindDaiLink(void) +int32_t AudioTestRegisterCodec(void) { - int32_t ret; - struct AudioCard *audioCard = NULL; - struct AudioConfigData *configData = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioBindDaiLink(audioCard, configData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioBindDaiLink fail ret = %d", __func__, ret); + if (AudioRegisterCodec(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterCodec fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + struct CodecData codecData = { + .drvCodecName = ACCESSORY_DAI_TEST_NAME, + }; + struct DaiData daiData = { + .drvDaiName = ACCESSORY_DAI_TEST_NAME, + }; + if (AudioRegisterCodec(device, &codecData, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterCodec fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestSocDeviceRegister(void) +int32_t AudioTestRegisterDsp(void) { - int32_t ret; - void *data = NULL; - enum AudioDeviceType deviceType; - struct HdfDeviceObject *device = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioSocDeviceRegister(device, data, deviceType); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocDeviceRegister fail ret = %d", __func__, ret); + if (AudioRegisterDsp(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDsp fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + struct DaiData daiData = { + .drvDaiName = ACCESSORY_DAI_TEST_NAME, + }; + struct DspData dspData = { + .drvDspName = DSP_TEST_NAME, + }; + + if (AudioRegisterDsp(device, &dspData, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDsp fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestSocRegisterDsp(void) +int32_t AudioTestSocDeviceRegister(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct DaiData *data = NULL; + struct { + char *name; + } data; + + enum AudioDeviceType deviceType = AUDIO_DAI_DEVICE; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterDsp(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterDsp fail ret = %d", __func__, ret); + if (AudioSocDeviceRegister(NULL, NULL, deviceType) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocDeviceRegister fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + data.name = ACCESSORY_DAI_TEST_NAME; + if (AudioSocDeviceRegister(device, &data, deviceType) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocDeviceRegister fail", __func__, __LINE__); + return HDF_FAILURE; } + deviceType = AUDIO_PLATFORM_DEVICE; + data.name = PLATFORM_TEST_NAME; + if (AudioSocDeviceRegister(device, &data, deviceType) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocDeviceRegister fail", __func__, __LINE__); + return HDF_FAILURE; + } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestRegisterAccessory(void) +int32_t AudioTestBindDaiLink(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct AccessoryData *data = NULL; - struct DaiData *daiData = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioRegisterAccessory(device, data, daiData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioRegisterAccessory fail ret = %d", __func__, ret); + if (AudioBindDaiLink(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioBindDaiLink fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct AudioCard *card = (struct AudioCard *)OsalMemCalloc(sizeof(struct AudioCard)); + if (card == NULL) { + ADM_LOG_ERR("%s_[%d] Malloc audioCard fail!", __func__, __LINE__); + return HDF_FAILURE; + } + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(AUDIO_CORE_SERVICE_TEST_NAME); + if (AudioFillConfigData(device, &(card->configData)) != HDF_SUCCESS) { + ADM_LOG_ERR("%s_[%d] AudioFillConfigData fail", __func__, __LINE__); + OsalMemFree(card); + card = NULL; + return HDF_FAILURE; } + if (AudioBindDaiLink(card, &(card->configData)) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioBindDaiLink fail", __func__, __LINE__); + OsalMemFree(card); + card = NULL; + return HDF_FAILURE; + } + OsalMemFree(card->rtd); + card->rtd = NULL; + OsalMemFree(card); + card = NULL; HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestUpdateRegBits(void) +int32_t ReadCodecReg(unsigned long virtualAddress, uint32_t reg, uint32_t *val) { - int32_t codecRet; - int32_t accessoryRet; - int32_t value; - void *device = NULL; - struct AudioMixerControl *mixerControl = NULL; - HDF_LOGI("%s: enter", __func__); + return HDF_SUCCESS; +} + +int32_t WriteCodecReg(unsigned long virtualAddress, uint32_t reg, uint32_t val) +{ + return HDF_SUCCESS; +} +int32_t AudioTestUpdateCodecRegBits(void) +{ + int32_t value = 0; + if (AudioUpdateCodecRegBits(NULL, NULL, value) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateCodecRegBits fail", __func__, __LINE__); + return HDF_FAILURE; + } - codecRet = AudioUpdateRegBits(AUDIO_CODEC_DEVICE, device, mixerControl, value); - accessoryRet = AudioUpdateRegBits(AUDIO_ACCESSORY_DEVICE, device, mixerControl, value); - if (codecRet != HDF_SUCCESS || accessoryRet != HDF_SUCCESS) { - HDF_LOGE("%s: AudioUpdateRegBits fail codecRet = %d, accessoryRet = %d", __func__, codecRet, accessoryRet); + struct CodecData codecData = { + .Read = ReadCodecReg, + .Write = WriteCodecReg, + }; + struct CodecDevice codec; + codec.devCodecName = PLATFORM_CODEC_TEST_NAME; + OsalMutexInit(&codec.mutex); + codec.devData = &codecData; + value = g_audioMixerRegParams.min + 1; + if (AudioUpdateCodecRegBits(&codec, &g_audioMixerRegParams, value) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateCodecRegBits fail", __func__, __LINE__); + OsalMutexDestroy(&codec.mutex); + return HDF_FAILURE; } + OsalMutexDestroy(&codec.mutex); HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAiaoUpdateRegBits(void) +int32_t AudioTestUpdateAccessoryRegBits(void) { - uint32_t reg; - uint32_t mask; - uint32_t shift; - int32_t value; - int32_t ret; - struct CodecDevice *codec = NULL; - HDF_LOGI("%s: enter", __func__); + struct AccessoryDevice *accessory = NULL; + struct AudioMixerControl *mixerControl = NULL; + int32_t value = 0; - ret = AudioAiaoUpdateRegBits(codec, reg, mask, shift, value); + int32_t ret = AudioUpdateAccessoryRegBits(accessory, mixerControl, value); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAiaoUpdateRegBits fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioTestUpdateAccessoryRegBits fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); @@ -172,7 +275,35 @@ int32_t AudioTestKcontrolGetCodec(void) codecDevice = AudioKcontrolGetCodec(kcontrol); if (codecDevice == NULL) { - HDF_LOGE("%s: AudioKcontrolGetCodec fail!", __func__); + HDF_LOGE("%s_[%d] AudioKcontrolGetCodec fail!", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioTestKcontrolGetAccessory(void) +{ + struct AudioKcontrol *kcontrol = NULL; + struct AccessoryDevice *accessory = AudioKcontrolGetAccessory(kcontrol); + if (accessory == NULL) { + HDF_LOGE("%s_[%d] AudioKcontrolGetAccessory fail!", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioTestAddControl(void) +{ + struct AudioCard *audioCard = NULL; + const struct AudioKcontrol *control = NULL; + struct AudioKcontrol *audioKcontrol = NULL; + HDF_LOGI("%s: enter", __func__); + + audioKcontrol = AudioAddControl(audioCard, control); + if (audioKcontrol == NULL) { + HDF_LOGE("%s_[%d] AudioAddControl fail!", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); @@ -183,143 +314,143 @@ int32_t AudioTestAddControls(void) { struct AudioCard *audioCard = NULL; const struct AudioKcontrol *controls = NULL; - int32_t controlMaxNum = 0; + int32_t controlMaxNum = 0x03; int32_t ret; HDF_LOGI("%s: enter", __func__); ret = AudioAddControls(audioCard, controls, controlMaxNum); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAddControls fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioAddControls fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAddControl(void) +int32_t AudioTestCodecReadReg(void) { - struct AudioCard *audioCard = NULL; - const struct AudioKcontrol *control = NULL; - struct AudioKcontrol *audioKcontrol = NULL; - HDF_LOGI("%s: enter", __func__); + struct CodecDevice *codec = NULL; + uint32_t reg = 0; + uint32_t val = 0; - audioKcontrol = AudioAddControl(audioCard, control); - if (audioKcontrol == NULL) { - HDF_LOGE("%s: AudioAddControl fail!", __func__); + int32_t ret = AudioCodecReadReg(codec, reg, &val); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecReadReg fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestDeviceReadReg(void) +int32_t AudioTestAccessoryReadReg(void) { - int32_t codecRet; - int32_t acccessoryRet; + struct AccessoryDevice *accessory = NULL; uint32_t reg = 0; + uint32_t val = 0; + + int32_t ret = AudioAccessoryReadReg(accessory, reg, &val); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessoryReadReg fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioTestCodecWriteReg(void) +{ struct CodecDevice *codec = NULL; - struct AccessoryDevice *accessory = NULL; - HDF_LOGI("%s: enter", __func__); + uint32_t reg = 0; + uint32_t val = 0; - codecRet = AudioCodecDeviceReadReg(codec, reg); - acccessoryRet = AudioAccessoryDeviceReadReg(accessory, reg); - if (codecRet != HDF_SUCCESS || acccessoryRet != HDF_SUCCESS) { - HDF_LOGE("%s: AudioDeviceReadReg fail codecRet = %d, acccessoryRet = %d", __func__, codecRet, acccessoryRet); + int32_t ret = AudioCodecWriteReg(codec, reg, val); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecWriteReg fail", __func__, __LINE__); } + HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAiaoDeviceReadReg(void) +int32_t AudioTestAccessoryWriteReg(void) { - int32_t ret; + struct AccessoryDevice *accessory = NULL; uint32_t reg = 0; - struct CodecDevice *codec = NULL; - HDF_LOGI("%s: enter", __func__); + uint32_t val = 0; - ret = AudioAiaoDeviceReadReg(codec, reg); + int32_t ret = AudioAccessoryWriteReg(accessory, reg, val); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAiaoDeviceReadReg fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioAccessoryWriteReg fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestInfoCtrlSw(void) +int32_t AudioTestInfoCtrlOps(void) { - int32_t ret; struct AudioKcontrol *kcontrol = NULL; struct AudioCtrlElemInfo *elemInfo = NULL; - HDF_LOGI("%s: enter", __func__); - ret = AudioInfoCtrlSw(kcontrol, elemInfo); + int32_t ret = AudioInfoCtrlOps(kcontrol, elemInfo); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioInfoCtrlSw fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioInfoCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestGetCtrlSw(void) +int32_t AudioTestCodecGetCtrlOps(void) { - int32_t ret; struct AudioKcontrol *kcontrol = NULL; struct AudioCtrlElemValue *elemValue = NULL; - HDF_LOGI("%s: enter", __func__); - ret = AudioGetCtrlSw(kcontrol, elemValue); + int32_t ret = AudioCodecGetCtrlOps(kcontrol, elemValue); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioGetCtrlSw fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioCodecGetCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestPutCtrlSw(void) +int32_t AudioTestAccessoryGetCtrlOps(void) { - int32_t ret; struct AudioKcontrol *kcontrol = NULL; struct AudioCtrlElemValue *elemValue = NULL; - HDF_LOGI("%s: enter", __func__); - ret = AudioPutCtrlSw(kcontrol, elemValue); + int32_t ret = AudioAccessoryGetCtrlOps(kcontrol, elemValue); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioPutCtrlSw fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioAccessoryGetCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AiaoTestGetCtrlSw(void) +int32_t AudioTestCodecSetCtrlOps(void) { - int32_t ret; struct AudioKcontrol *kcontrol = NULL; struct AudioCtrlElemValue *elemValue = NULL; - HDF_LOGI("%s: enter", __func__); - ret = AiaoGetCtrlSw(kcontrol, elemValue); + int32_t ret = AudioCodecSetCtrlOps(kcontrol, elemValue); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AiaoGetCtrlSw fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioCodecSetCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AiaoTestPutCtrlSw(void) +int32_t AudioTestAccessorySetCtrlOps(void) { - int32_t ret; struct AudioKcontrol *kcontrol = NULL; struct AudioCtrlElemValue *elemValue = NULL; - HDF_LOGI("%s: enter", __func__); - ret = AiaoPutCtrlSw(kcontrol, elemValue); + int32_t ret = AudioAccessorySetCtrlOps(kcontrol, elemValue); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AiaoPutCtrlSw fail ret = %d", __func__, ret); + HDF_LOGE("%s_[%d] AudioAccessorySetCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); diff --git a/test/unittest/model/audio/src/audio_host_test.c b/test/unittest/model/audio/src/audio_host_test.c index ef4d81c2a9243941ad150581b14e8903ecab8fbd..283c2cf028cf03106370124b671dfa967b83de09 100755 --- a/test/unittest/model/audio/src/audio_host_test.c +++ b/test/unittest/model/audio/src/audio_host_test.c @@ -8,21 +8,28 @@ #include "audio_host_test.h" #include "audio_host.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_host_test +#define KCONTROL_TEST_SERVICE_NAME "dsp_service_0" int32_t AudioKcontrolTestGetCodec(void) { - struct HdfDeviceObject *device = NULL; - struct AudioHost *audioHost = NULL; HDF_LOGI("%s: enter", __func__); - audioHost = AudioHostCreateAndBind(device); - if (audioHost != NULL) { - HDF_LOGE("%s: codecDevice is not NULL", __func__); + if (AudioHostCreateAndBind(NULL) != NULL) { + HDF_LOGE("%s_[%d] codecDevice is not NULL", __func__, __LINE__); return HDF_FAILURE; } + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(KCONTROL_TEST_SERVICE_NAME); + struct AudioHost *audioHost = AudioHostCreateAndBind(device); + if (audioHost == NULL) { + HDF_LOGE("%s_[%d] codecDevice is NULL", __func__, __LINE__); + return HDF_FAILURE; + } + + OsalMemFree(audioHost); HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } @@ -52,13 +59,3 @@ int32_t GetCardTestInstance(void) HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } - -int32_t AudioHostTestDestroy(void) -{ - struct AudioHost *host = NULL; - HDF_LOGI("%s: enter", __func__); - - AudioHostDestroy(host); - HDF_LOGI("%s: success", __func__); - return HDF_SUCCESS; -} diff --git a/test/unittest/model/audio/src/audio_parse_test.c b/test/unittest/model/audio/src/audio_parse_test.c index 74c61c61e427734d0b168c32999a8b64d1b2a997..24ab294cbca7e82475b1b72b1a477f40351909db 100755 --- a/test/unittest/model/audio/src/audio_parse_test.c +++ b/test/unittest/model/audio/src/audio_parse_test.c @@ -5,22 +5,26 @@ * the GPL, or the BSD license, at your option. * See the LICENSE file in the root of this repository for complete details. */ - #include "audio_parse_test.h" #include "audio_parse.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_parse_test +#define TEST_PARSE_SERVICE_NAME "hdf_audio_codec_dev0" int32_t AudioFillTestConfigData(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct AudioConfigData *configData = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioFillConfigData(device, configData); - if (ret == HDF_SUCCESS) { - HDF_LOGE("%s: AudioFillConfigData fail! ret = %d", __func__, ret); + if (AudioFillConfigData(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d]: AudioFillConfigData fail", __func__, __LINE__); + return HDF_FAILURE; + } + + struct HdfDeviceObject *device = DevSvcManagerClntGetDeviceObject(TEST_PARSE_SERVICE_NAME); + struct AudioConfigData configData; + if (AudioFillConfigData(device, &configData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d]: AudioFillConfigData fail", __func__, __LINE__); return HDF_FAILURE; } diff --git a/test/unittest/model/audio/src/audio_stream_dispatch_test.c b/test/unittest/model/audio/src/audio_stream_dispatch_test.c index 4d9d138c3c831c05d0de02198c586d3cbf4ed9ec..2d0f1c89fe04a08d5c1cdeb8c31da292ed15e740 100755 --- a/test/unittest/model/audio/src/audio_stream_dispatch_test.c +++ b/test/unittest/model/audio/src/audio_stream_dispatch_test.c @@ -27,14 +27,3 @@ int32_t AudioControlDispatchTestStreamDispatch(void) HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } - -int32_t AudioControlDispatchTestStreamHostDestroy(void) -{ - struct StreamHost *host = NULL; - HDF_LOGI("%s: enter", __func__); - - StreamHostDestroy(host); - - HDF_LOGI("%s: success", __func__); - return HDF_SUCCESS; -} diff --git a/test/unittest/model/audio/src/hdf_audio_test.c b/test/unittest/model/audio/src/hdf_audio_test.c index 72114884b47c7339eac7a41ed31535a063bbecd2..4af3765bd3e6fad3dfc3d7b05a3dc76b8127d3f1 100755 --- a/test/unittest/model/audio/src/hdf_audio_test.c +++ b/test/unittest/model/audio/src/hdf_audio_test.c @@ -20,34 +20,37 @@ static HdfTestCaseList g_hdfAudioTestCaseList[] = { {AUDIO_DRIVER_TESTGETCODEC, AudioKcontrolTestGetCodec}, {AUDIO_DRIVER_TESTGETCARDINSTANCE, GetCardTestInstance}, - {AUDIO_DRIVER_TESTHOSTDESTROY, AudioHostTestDestroy}, {AUDIO_DRIVER_TESTGETCCNFIGDATA, AudioFillTestConfigData}, - {AUDIO_DRIVER_TESTREGISTERDAI, AudioSocTestRegisterDai}, + {AUDIO_DRIVER_TESTREGISTERPLATFORM, AudioSocTestRegisterPlatform}, + {AUDIO_DRIVER_TESTREGISTERDAI, AudioSocTestRegisterDai}, + {AUDIO_DRIVER_TESTREGISTERACCESSORY, AudioTestRegisterAccessory}, {AUDIO_DRIVER_TESTREGISTERCODEC, AudioTestRegisterCodec}, + {AUDIO_DRIVER_TESTREGISTERDSP, AudioTestRegisterDsp}, + {AUDIO_DRIVER_TESTSOCDEVICEREGISTER, AudioTestSocDeviceRegister}, {AUDIO_DRIVER_TESTBINDDAILINK, AudioTestBindDaiLink}, - {AUDIO_DRIVER_TESTDEVICEREGISTER, AudioTestSocDeviceRegister}, - {AUDIO_DRIVER_TESTREGISTERDSP, AudioTestSocRegisterDsp}, - {AUDIO_DRIVER_TESTREGISTERACCESSORY, AudioTestRegisterAccessory}, - {AUDIO_DRIVER_TESTUPDATEREGBITS, AudioTestUpdateRegBits}, - {AUDIO_DRIVER_TESTAIAOUPDATEREGBITS, AudioTestAiaoUpdateRegBits}, + {AUDIO_DRIVER_TESTUPDATECODECREGBITS, AudioTestUpdateCodecRegBits}, + {AUDIO_DRIVER_TESTUPDATEACCESSORYREGBITS, AudioTestUpdateAccessoryRegBits}, {AUDIO_DRIVER_TESTKCONTROLGETCODEC, AudioTestKcontrolGetCodec}, - {AUDIO_DRIVER_TESTADDCONTROLS, AudioTestAddControls}, + {AUDIO_DRIVER_TESTKCONTROLGETACCESSORY, AudioTestKcontrolGetAccessory}, {AUDIO_DRIVER_TESTADDCONTROL, AudioTestAddControl}, - {AUDIO_DRIVER_TESTDEVICEREADREG, AudioTestDeviceReadReg}, - {AUDIO_DRIVER_TESTAIAODEVICEREADREG, AudioTestAiaoDeviceReadReg}, - {AUDIO_DRIVER_TESTINFOCTRLSW, AudioTestInfoCtrlSw}, - {AUDIO_DRIVER_TESTGETCTRLSW, AudioTestGetCtrlSw}, - {AUDIO_DRIVER_TESTPUTCTRLSW, AudioTestPutCtrlSw}, - {AUDIO_DRIVER_TESTAIAOGETCTRLSW, AiaoTestGetCtrlSw}, - {AUDIO_DRIVER_TESTAIAOPUTCTRLSW, AiaoTestPutCtrlSw}, + {AUDIO_DRIVER_TESTADDCONTROLS, AudioTestAddControls}, + {AUDIO_DRIVER_TESTCODECREADREG, AudioTestCodecReadReg}, + {AUDIO_DRIVER_TESTACCESSORYREADREG, AudioTestAccessoryReadReg}, + {AUDIO_DRIVER_TESTCODECWRITEREG, AudioTestCodecWriteReg}, + {AUDIO_DRIVER_TESTACCESSORYWRITEREG, AudioTestAccessoryWriteReg}, + {AUDIO_DRIVER_TESTINFOCTRLOPS, AudioTestInfoCtrlOps}, + {AUDIO_DRIVER_TESTCODECGETCTRLOPS, AudioTestCodecGetCtrlOps}, + {AUDIO_DRIVER_TESTACCESSORYGETCTRLOPS, AudioTestAccessoryGetCtrlOps}, + {AUDIO_DRIVER_TESTCODECSETCTRLOPS, AudioTestCodecSetCtrlOps}, + {AUDIO_DRIVER_TESTACCESSORYSETCTRLOPS, AudioTestAccessorySetCtrlOps}, + {AUDIO_DRIVER_TESTNEWCOMPONENT, AudioSapmTestNewComponents}, {AUDIO_DRIVER_TESTADDROUTES, AudioSapmTestAddRoutes}, {AUDIO_DRIVER_TESTNEWCONTROLS, AudioSapmTestNewControls}, {AUDIO_DRIVER_TESTPOWERCOMPONET, AudioSapmTestPowerComponents}, {AUDIO_DRIVER_TESTREFRESHTIME, AudioSapmTestRefreshTime}, {AUDIO_DRIVER_TESTSTREAMDISPATCH, AudioControlDispatchTestStreamDispatch}, - {AUDIO_DRIVER_TESTSTREAMDESTORY, AudioControlDispatchTestStreamHostDestroy}, }; int32_t HdfAudioEntry(HdfTestMsg *msg)