drv_adc.c 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. /*
  2. * Copyright (c) 2021-2023 HPMicro
  3. *
  4. * SPDX-License-Identifier: BSD-3-Clause
  5. */
  6. #include <rtthread.h>
  7. #ifdef BSP_USING_ADC
  8. #include <rtdevice.h>
  9. #include "board.h"
  10. #include "drv_adc.h"
  11. #ifdef BSP_USING_ADC12
  12. #include "hpm_adc12_drv.h"
  13. #endif
  14. #ifdef BSP_USING_ADC16
  15. #include "hpm_adc16_drv.h"
  16. #endif
  17. #include "hpm_sysctl_drv.h"
  18. typedef struct
  19. {
  20. bool enabled;
  21. } adc_channel_state_t;
  22. typedef struct
  23. {
  24. char *adc_name;
  25. struct rt_adc_device hpm_adc_device;
  26. bool is_adc12;
  27. bool adc_enabled;
  28. uint32_t adc_base;
  29. adc_channel_state_t chn_state[16];
  30. }hpm_rtt_adc;
  31. static uint32_t hpm_adc_init_clock(struct rt_adc_device *device);
  32. static rt_err_t hpm_adc_enabled(struct rt_adc_device *device, rt_int8_t channel, rt_bool_t enabled);
  33. static rt_err_t hpm_get_adc_value(struct rt_adc_device *device, rt_int8_t channel, rt_uint32_t *value);
  34. static rt_uint8_t hpm_get_resolution(struct rt_adc_device *device);
  35. static rt_int16_t hpm_get_vref(struct rt_adc_device *device);
  36. static const struct rt_adc_ops hpm_adc_ops =
  37. {
  38. .enabled = hpm_adc_enabled,
  39. .convert = hpm_get_adc_value,
  40. .get_resolution = hpm_get_resolution,
  41. .get_vref = hpm_get_vref,
  42. };
  43. static hpm_rtt_adc hpm_adc_config_tbl[] =
  44. {
  45. #ifdef BSP_USING_ADC0
  46. {
  47. .adc_name = "adc0",
  48. #ifdef BSP_USING_ADC12
  49. .is_adc12 = true,
  50. #else
  51. .is_adc12 = false,
  52. #endif
  53. .adc_base = (uint32_t)HPM_ADC0,
  54. },
  55. #endif
  56. #ifdef BSP_USING_ADC1
  57. {
  58. .adc_name = "adc1",
  59. #ifdef BSP_USING_ADC12
  60. .is_adc12 = true,
  61. #else
  62. .is_adc12 = false,
  63. #endif
  64. .adc_base = (uint32_t)HPM_ADC1,
  65. },
  66. #endif
  67. #ifdef BSP_USING_ADC2
  68. {
  69. .adc_name = "adc2",
  70. #ifdef BSP_USING_ADC12
  71. .is_adc12 = true,
  72. #else
  73. .is_adc12 = false,
  74. #endif
  75. .adc_base = (uint32_t)HPM_ADC2,
  76. },
  77. #endif
  78. #ifdef BSP_USING_ADC3
  79. {
  80. .adc_name = "adc3",
  81. .is_adc12 = false,
  82. .adc_base = (uint32_t)HPM_ADC3,
  83. },
  84. #endif
  85. };
  86. static uint8_t adc_nums = sizeof(hpm_adc_config_tbl) / sizeof(hpm_rtt_adc);
  87. static uint32_t hpm_adc_init_clock(struct rt_adc_device *device)
  88. {
  89. hpm_rtt_adc *hpm_adc;
  90. uint32_t clock_freq = 0;
  91. RT_ASSERT(device != RT_NULL);
  92. hpm_adc = (hpm_rtt_adc *)device->parent.user_data;
  93. #if defined(ADC12_SOC_MAX_CH_NUM)
  94. if (hpm_adc->is_adc12)
  95. {
  96. clock_freq = board_init_adc12_clock((ADC12_Type*)hpm_adc->adc_base);
  97. } else
  98. #endif
  99. {
  100. clock_freq = board_init_adc16_clock((ADC16_Type*)hpm_adc->adc_base);
  101. }
  102. return clock_freq;
  103. }
  104. static rt_err_t init_adc_config(hpm_rtt_adc *adc)
  105. {
  106. hpm_stat_t ret;
  107. if (adc->is_adc12) {
  108. #ifdef BSP_USING_ADC12
  109. adc12_config_t cfg;
  110. adc12_get_default_config(&cfg);
  111. cfg.res = adc12_res_12_bits;
  112. cfg.conv_mode = adc12_conv_mode_oneshot;
  113. cfg.adc_ahb_en = true;
  114. cfg.adc_clk_div = 3;
  115. ret = adc12_init((ADC12_Type *)adc->adc_base, &cfg);
  116. if (ret != status_success) {
  117. return RT_ERROR;
  118. }
  119. #endif
  120. } else {
  121. #ifdef BSP_USING_ADC16
  122. adc16_config_t cfg;
  123. adc16_get_default_config(&cfg);
  124. cfg.conv_mode = adc16_conv_mode_oneshot;
  125. cfg.res = adc16_res_16_bits;
  126. cfg.adc_clk_div = 4;
  127. cfg.sel_sync_ahb = true;
  128. cfg.adc_ahb_en = true;
  129. cfg.wait_dis = 0;
  130. ret = adc16_init((ADC16_Type *)adc->adc_base, &cfg);
  131. if (ret != status_success) {
  132. return RT_ERROR;
  133. }
  134. #endif
  135. }
  136. return RT_EOK;
  137. }
  138. static rt_err_t init_channel_config(hpm_rtt_adc *adc, uint16_t channel)
  139. {
  140. hpm_stat_t ret;
  141. if (adc->is_adc12) {
  142. #ifdef BSP_USING_ADC12
  143. adc12_channel_config_t ch_cfg;
  144. adc12_get_channel_default_config(&ch_cfg);
  145. ch_cfg.ch = adc->channel;
  146. ch_cfg.diff_sel = adc12_sample_signal_single_ended;
  147. ch_cfg.sample_cycle = 20;
  148. ret = adc12_init_channel((ADC12_Type *)adc->adc_base, &ch_cfg);
  149. if (ret != status_success) {
  150. return RT_ERROR;
  151. }
  152. #endif
  153. } else {
  154. #ifdef BSP_USING_ADC16
  155. adc16_channel_config_t ch_cfg;
  156. adc16_get_channel_default_config(&ch_cfg);
  157. ch_cfg.ch = channel;
  158. ch_cfg.sample_cycle = 20;
  159. ret = adc16_init_channel((ADC16_Type *)adc->adc_base, &ch_cfg);
  160. if (ret != status_success) {
  161. return RT_ERROR;
  162. }
  163. #endif
  164. }
  165. return RT_EOK;
  166. }
  167. static rt_err_t hpm_adc_enabled(struct rt_adc_device *device, rt_int8_t channel, rt_bool_t enabled)
  168. {
  169. hpm_rtt_adc *hpm_adc;
  170. rt_err_t ret;
  171. RT_ASSERT(device != RT_NULL);
  172. hpm_adc = (hpm_rtt_adc *)device->parent.user_data;
  173. if (enabled == RT_TRUE) {
  174. if (!hpm_adc->chn_state[channel].enabled)
  175. {
  176. if (!hpm_adc->adc_enabled)
  177. {
  178. (void)hpm_adc_init_clock(device);
  179. ret = init_adc_config(hpm_adc);
  180. if (ret != RT_EOK) {
  181. return RT_ERROR;
  182. }
  183. hpm_adc->adc_enabled = true;
  184. }
  185. hpm_adc->chn_state[channel].enabled = true;
  186. ret = init_channel_config(hpm_adc, channel);
  187. if (ret != RT_EOK) {
  188. return RT_ERROR;
  189. }
  190. }
  191. }
  192. else
  193. {
  194. /* Since the ADC channel cannot be truly disabled, do nothing here */
  195. }
  196. return RT_EOK;
  197. }
  198. static rt_err_t hpm_get_adc_value(struct rt_adc_device *device, rt_int8_t channel, rt_uint32_t *value)
  199. {
  200. hpm_rtt_adc *hpm_adc;
  201. rt_err_t ret;
  202. rt_uint16_t val;
  203. RT_ASSERT(device != RT_NULL);
  204. RT_ASSERT(value != RT_NULL);
  205. hpm_adc = (hpm_rtt_adc *)device->parent.user_data;
  206. uint32_t adc_chn = (uint16_t)channel;
  207. if (hpm_adc->is_adc12) {
  208. #ifdef BSP_USING_ADC12
  209. adc12_get_oneshot_result((ADC12_Type *)hpm_adc->adc_base, adc_chn, &val);
  210. *value = val;
  211. #endif
  212. } else {
  213. #ifdef BSP_USING_ADC16
  214. hpm_stat_t status = adc16_get_oneshot_result((ADC16_Type *)hpm_adc->adc_base, adc_chn, &val);
  215. *value = val;
  216. // rt_kprintf("%s, status=%d\n", __func__, status);
  217. #endif
  218. }
  219. return RT_EOK;
  220. }
  221. static rt_uint8_t hpm_get_resolution(struct rt_adc_device *device)
  222. {
  223. hpm_rtt_adc *hpm_adc;
  224. RT_ASSERT(device != RT_NULL);
  225. hpm_adc = (hpm_rtt_adc *)device->parent.user_data;
  226. if (hpm_adc->is_adc12) {
  227. return 12;
  228. } else {
  229. return 16;
  230. }
  231. }
  232. static rt_int16_t hpm_get_vref(struct rt_adc_device *device)
  233. {
  234. return -RT_EIO;
  235. }
  236. int rt_hw_adc_init(void)
  237. {
  238. rt_err_t ret = RT_EOK;
  239. for (uint32_t i = 0; i < adc_nums; i++) {
  240. ret = rt_hw_adc_register(&hpm_adc_config_tbl[i].hpm_adc_device,
  241. hpm_adc_config_tbl[i].adc_name,
  242. &hpm_adc_ops,
  243. &hpm_adc_config_tbl[i]);
  244. if (ret != RT_EOK) {
  245. ret = RT_ERROR;
  246. break;
  247. }
  248. }
  249. return ret;
  250. }
  251. INIT_BOARD_EXPORT(rt_hw_adc_init);
  252. #endif /* BSP_USING_ADC */