drv_dao.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289
  1. /*
  2. * Copyright (c) 2022 HPMicro
  3. *
  4. * SPDX-License-Identifier: BSD-3-Clause
  5. *
  6. */
  7. #include <rtthread.h>
  8. #include <rtdevice.h>
  9. #define DBG_TAG "dao"
  10. #define DBG_LVL DBG_INFO
  11. #include <rtdbg.h>
  12. #ifdef BSP_USING_DAO
  13. #include "drivers/audio.h"
  14. #include "hpm_i2s_drv.h"
  15. #include "hpm_dao_drv.h"
  16. #include "board.h"
  17. #include "drv_dao.h"
  18. #include "hpm_dma_drv.h"
  19. #include "hpm_dmamux_drv.h"
  20. #include "hpm_l1c_drv.h"
  21. #include "hpm_clock_drv.h"
  22. #include "hpm_dma_manager.h"
  23. /* DAO connect to I2S1 TX*/
  24. #define DAO_DMA_REQ HPM_DMA_SRC_I2S1_TX
  25. #define DAO_I2S_DATA_LINE 0
  26. struct hpm_dao
  27. {
  28. struct rt_audio_device audio;
  29. struct rt_audio_configure play_config;
  30. rt_uint8_t* tx_fifo;
  31. };
  32. struct hpm_dao hpm_dao_dev = { 0 };
  33. static hpm_dma_resource_t dma_resource = { 0 };
  34. void dao_dma_callback(DMA_Type *ptr, uint32_t channel, void *user_data, uint32_t int_stat)
  35. {
  36. if (int_stat == DMA_CHANNEL_STATUS_TC) {
  37. rt_audio_tx_complete(&hpm_dao_dev.audio);
  38. }
  39. }
  40. static rt_err_t hpm_dao_getcaps(struct rt_audio_device* audio, struct rt_audio_caps* caps)
  41. {
  42. rt_err_t result = RT_EOK;
  43. RT_ASSERT(audio != RT_NULL);
  44. struct hpm_dao* hpm_audio = (struct hpm_dao*)audio->parent.user_data;
  45. switch(caps->main_type)
  46. {
  47. case AUDIO_TYPE_OUTPUT:
  48. {
  49. switch(caps->sub_type)
  50. {
  51. case AUDIO_DSP_PARAM:
  52. caps->udata.config.samplerate = hpm_audio->play_config.samplerate;
  53. caps->udata.config.channels = hpm_audio->play_config.channels;
  54. caps->udata.config.samplebits = hpm_audio->play_config.samplebits;
  55. break;
  56. case AUDIO_DSP_SAMPLERATE:
  57. caps->udata.config.samplerate = hpm_audio->play_config.samplerate;
  58. break;
  59. case AUDIO_DSP_CHANNELS:
  60. caps->udata.config.channels = hpm_audio->play_config.channels;
  61. break;
  62. case AUDIO_DSP_SAMPLEBITS:
  63. caps->udata.config.samplebits = hpm_audio->play_config.samplebits;
  64. break;
  65. default:
  66. result = -RT_ERROR;
  67. break;
  68. }
  69. break;
  70. }
  71. default:
  72. result = -RT_ERROR;
  73. break;
  74. }
  75. return result;
  76. }
  77. static rt_err_t hpm_dao_set_samplerate(uint32_t samplerate)
  78. {
  79. uint32_t mclk_hz;
  80. i2s_transfer_config_t transfer;
  81. mclk_hz = clock_get_frequency(clock_i2s1);
  82. i2s_get_default_transfer_config_for_dao(&transfer);
  83. transfer.sample_rate = samplerate;
  84. if (status_success != i2s_config_tx(DAO_I2S, mclk_hz, &transfer))
  85. {
  86. LOG_E("dao_i2s configure transfer failed\n");
  87. return -RT_ERROR;
  88. }
  89. return RT_EOK;
  90. }
  91. static rt_err_t hpm_dao_configure(struct rt_audio_device* audio, struct rt_audio_caps* caps)
  92. {
  93. rt_err_t result = RT_EOK;
  94. RT_ASSERT(audio != RT_NULL);
  95. struct hpm_dao* hpm_audio = (struct hpm_dao*)audio->parent.user_data;
  96. switch(caps->main_type)
  97. {
  98. case AUDIO_TYPE_OUTPUT:
  99. {
  100. switch(caps->sub_type)
  101. {
  102. case AUDIO_DSP_SAMPLERATE:
  103. {
  104. hpm_audio->play_config.samplerate = caps->udata.config.samplerate;
  105. hpm_dao_set_samplerate(caps->udata.config.samplerate);
  106. break;
  107. }
  108. default:
  109. result = -RT_ERROR;
  110. break;
  111. }
  112. }
  113. default:
  114. result = -RT_ERROR;
  115. break;
  116. }
  117. return result;
  118. }
  119. static rt_err_t hpm_dao_init(struct rt_audio_device* audio)
  120. {
  121. RT_ASSERT(audio != RT_NULL);
  122. rt_uint32_t mclk_hz;
  123. i2s_config_t i2s_config;
  124. i2s_transfer_config_t transfer;
  125. dao_config_t dao_config;
  126. init_dao_pins();
  127. board_init_dao_clock();
  128. i2s_get_default_config(DAO_I2S, &i2s_config);
  129. i2s_init(DAO_I2S, &i2s_config);
  130. i2s_enable_tx_dma_request(DAO_I2S);
  131. mclk_hz = clock_get_frequency(clock_i2s1);
  132. i2s_get_default_transfer_config_for_dao(&transfer);
  133. if (status_success != i2s_config_tx(DAO_I2S, mclk_hz, &transfer))
  134. {
  135. LOG_E("dao_i2s configure transfer failed\n");
  136. return -RT_ERROR;
  137. }
  138. /* init audio configure */
  139. hpm_dao_dev.play_config.channels = 2U; /* fix to 2 channels*/
  140. hpm_dao_dev.play_config.samplebits = 32U; /* fix to 32 sample bits */
  141. hpm_dao_dev.play_config.samplerate = 48000U; /* default 48KHz sample rate */
  142. dao_get_default_config(HPM_DAO, &dao_config);
  143. dao_config.enable_mono_output = true;
  144. if (status_success != dao_init(HPM_DAO, &dao_config)) {
  145. LOG_E("dao init failed\n");
  146. return -RT_ERROR;
  147. }
  148. return RT_EOK;
  149. }
  150. static rt_err_t hpm_dao_start(struct rt_audio_device* audio, int stream)
  151. {
  152. RT_ASSERT(audio != RT_NULL);
  153. dao_start(HPM_DAO);
  154. if (dma_manager_request_resource(&dma_resource) == status_success) {
  155. uint8_t dmamux_ch;
  156. dma_manager_install_interrupt_callback(&dma_resource, dao_dma_callback, NULL);
  157. dma_manager_enable_dma_interrupt(&dma_resource, 1);
  158. dmamux_ch = DMA_SOC_CHN_TO_DMAMUX_CHN(dma_resource.base, dma_resource.channel);
  159. dmamux_config(HPM_DMAMUX, dmamux_ch, DAO_DMA_REQ, true);
  160. } else {
  161. LOG_E("no dma resource available for DAO transfer.\n");
  162. return -RT_ERROR;
  163. }
  164. rt_audio_tx_complete(audio);
  165. return RT_EOK;
  166. }
  167. static rt_err_t hpm_dao_stop(struct rt_audio_device* audio, int stream)
  168. {
  169. RT_ASSERT(audio != RT_NULL);
  170. dao_stop(HPM_DAO);
  171. dma_manager_release_resource(&dma_resource);
  172. return RT_EOK;
  173. }
  174. static rt_ssize_t hpm_dao_transmit(struct rt_audio_device* audio, const void* writeBuf, void* readBuf, rt_size_t size)
  175. {
  176. RT_ASSERT(audio != RT_NULL);
  177. dma_channel_config_t ch_config = {0};
  178. dma_default_channel_config(dma_resource.base, &ch_config);
  179. ch_config.src_addr = core_local_mem_to_sys_address(HPM_CORE0, (uint32_t)writeBuf);
  180. ch_config.dst_addr = (uint32_t)&DAO_I2S->TXD[DAO_I2S_DATA_LINE];
  181. ch_config.src_width = DMA_TRANSFER_WIDTH_WORD;
  182. ch_config.dst_width = DMA_TRANSFER_WIDTH_WORD;
  183. ch_config.src_addr_ctrl = DMA_ADDRESS_CONTROL_INCREMENT;
  184. ch_config.dst_addr_ctrl = DMA_ADDRESS_CONTROL_FIXED;
  185. ch_config.size_in_byte = size;
  186. ch_config.dst_mode = DMA_HANDSHAKE_MODE_HANDSHAKE;
  187. ch_config.src_burst_size = DMA_NUM_TRANSFER_PER_BURST_1T;
  188. if (l1c_dc_is_enabled()) {
  189. /* cache writeback for sent buff */
  190. l1c_dc_writeback((uint32_t)writeBuf, size);
  191. }
  192. if (status_success != dma_setup_channel(dma_resource.base, dma_resource.channel, &ch_config, true)) {
  193. return 0;
  194. }
  195. return size;
  196. }
  197. static void hpm_dao_buffer_info(struct rt_audio_device* audio, struct rt_audio_buf_info* info)
  198. {
  199. RT_ASSERT(audio != RT_NULL);
  200. /**
  201. * AUD_FIFO
  202. * +----------------+----------------+
  203. * | block1 | block2 |
  204. * +----------------+----------------+
  205. * \ block_size /
  206. */
  207. info->buffer = hpm_dao_dev.tx_fifo;
  208. info->total_size = DAO_FIFO_SIZE;
  209. info->block_size = DAO_FIFO_SIZE / 2;
  210. info->block_count = 2;
  211. }
  212. static struct rt_audio_ops hpm_dao_ops =
  213. {
  214. .getcaps = hpm_dao_getcaps,
  215. .configure = hpm_dao_configure,
  216. .init = hpm_dao_init,
  217. .start = hpm_dao_start,
  218. .stop = hpm_dao_stop,
  219. .transmit = hpm_dao_transmit,
  220. .buffer_info = hpm_dao_buffer_info,
  221. };
  222. ATTR_ALIGN(HPM_L1C_CACHELINE_SIZE) uint8_t dao_tx_fifo[DAO_FIFO_SIZE];
  223. int rt_hw_dao_init(void)
  224. {
  225. hpm_dao_dev.tx_fifo = dao_tx_fifo;
  226. hpm_dao_dev.audio.ops = &hpm_dao_ops;
  227. LOG_I("audio dao registered.\n");
  228. LOG_I("!!!Note: dao depends on i2s1, they share clock.\n");
  229. rt_audio_register(&hpm_dao_dev.audio, "dao", RT_DEVICE_FLAG_WRONLY, &hpm_dao_dev);
  230. return RT_EOK;
  231. }
  232. INIT_DEVICE_EXPORT(rt_hw_dao_init);
  233. #endif /* BSP_USING_DAO */