1 /*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2023-03-24 spaceman the first version
9 */
10
11 #include "board.h"
12 #include "drv_dcmi.h"
13
14 #ifdef BSP_USING_DCMI
15
16 #define DRV_DEBUG
17 #define LOG_TAG "drv.dcmi"
18 #include <drv_log.h>
19
20 static struct stm32_dcmi rt_dcmi_dev = {0};
21 static volatile uint8_t ov2640_fps; // 帧率
22
23
rt_hw_dmci_dma_init(struct stm32_dcmi * dcmi_dev)24 static void rt_hw_dmci_dma_init(struct stm32_dcmi *dcmi_dev)
25 {
26 RT_ASSERT(dcmi_dev != RT_NULL);
27 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
28 DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
29 RT_ASSERT(_dcmi_handle != RT_NULL);
30 RT_ASSERT(_dma_handle != RT_NULL);
31
32 __HAL_RCC_DMA2_CLK_ENABLE(); // 使能DMA2时钟
33
34 _dma_handle->Instance = DMA2_Stream7; // DMA2数据流7
35 _dma_handle->Init.Request = DMA_REQUEST_DCMI; // DMA请求来自DCMI
36 _dma_handle->Init.Direction = DMA_PERIPH_TO_MEMORY; // 外设到存储器模式
37 _dma_handle->Init.PeriphInc = DMA_PINC_DISABLE; // 外设地址禁止自增
38 _dma_handle->Init.MemInc = DMA_MINC_ENABLE; // 存储器地址自增
39 _dma_handle->Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; // DCMI数据位宽，32位
40 _dma_handle->Init.MemDataAlignment = DMA_MDATAALIGN_WORD; // 存储器数据位宽，32位
41 _dma_handle->Init.Mode = DMA_CIRCULAR; // 循环模式
42 _dma_handle->Init.Priority = DMA_PRIORITY_LOW; // 优先级低
43 _dma_handle->Init.FIFOMode = DMA_FIFOMODE_ENABLE; // 使能fifo
44 _dma_handle->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; // 全fifo模式，4*32bit大小
45 _dma_handle->Init.MemBurst = DMA_MBURST_SINGLE; // 单次传输
46 _dma_handle->Init.PeriphBurst = DMA_PBURST_SINGLE; // 单次传输
47
48 if (HAL_DMA_Init(_dma_handle) != HAL_OK) {
49 Error_Handler();
50 }
51 HAL_DMA_Init(_dma_handle); // 配置DMA
52 __HAL_LINKDMA(_dcmi_handle, DMA_Handle, *_dma_handle); // 关联DCMI句柄
53 HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 0, 0); // 设置中断优先级
54 HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn); // 使能中断
55 }
56
rt_hw_dcmi_init(struct stm32_dcmi * dcmi_dev)57 static rt_err_t rt_hw_dcmi_init(struct stm32_dcmi *dcmi_dev)
58 {
59 RT_ASSERT(dcmi_dev != RT_NULL);
60 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
61 RT_ASSERT(_dcmi_handle != RT_NULL);
62
63 _dcmi_handle->Instance = DCMI;
64 _dcmi_handle->Init.SynchroMode = DCMI_SYNCHRO_HARDWARE; // 硬件同步模式，即使用外部的VS、HS信号进行同步
65 _dcmi_handle->Init.PCKPolarity = DCMI_PCKPOLARITY_RISING; // 像素时钟上升沿有效
66 _dcmi_handle->Init.VSPolarity = DCMI_VSPOLARITY_LOW; // VS低电平有效
67 _dcmi_handle->Init.HSPolarity = DCMI_HSPOLARITY_LOW; // HS低电平有效
68 _dcmi_handle->Init.CaptureRate = DCMI_CR_ALL_FRAME; // 捕获等级，设置每一帧都进行捕获
69 _dcmi_handle->Init.ExtendedDataMode = DCMI_EXTEND_DATA_8B; // 8位数据模式
70 _dcmi_handle->Init.JPEGMode = DCMI_JPEG_DISABLE; // 禁止JPEG模式
71 _dcmi_handle->Init.ByteSelectMode = DCMI_BSM_ALL; // DCMI接口捕捉所有数据
72 _dcmi_handle->Init.ByteSelectStart = DCMI_OEBS_ODD; // 选择开始字节，从 帧/行 的第一个数据开始捕获
73 _dcmi_handle->Init.LineSelectMode = DCMI_LSM_ALL; // 捕获所有行
74 _dcmi_handle->Init.LineSelectStart = DCMI_OELS_ODD; // 选择开始行,在帧开始后捕获第一行
75 if (HAL_DCMI_Init(_dcmi_handle) != HAL_OK) {
76 LOG_E("dcmi init error!");
77 return -RT_ERROR;
78 }
79
80 HAL_NVIC_SetPriority(DCMI_IRQn, 0, 5); // 设置中断优先级
81 HAL_NVIC_EnableIRQ(DCMI_IRQn); // 开启DCMI中断
82
83 DCMI->IER = 0x0;
84
85 // 在JPG模式下，一定要单独使能该中断
86 __HAL_DCMI_ENABLE_IT(_dcmi_handle, DCMI_IT_FRAME);
87 __HAL_DCMI_ENABLE(_dcmi_handle);
88
89 rt_hw_dmci_dma_init(dcmi_dev);
90
91 return RT_EOK;
92 }
93
94 /***************************************************************************************************************************************
95 * 函 数 名: ov2640_dcmi_crop
96 *
97 * 入口参数: displey_xsize 、displey_ysize - 显示器的长宽
98 * sensor_xsize、sensor_ysize - 摄像头传感器输出图像的长宽
99 *
100 * 函数功能: 使用DCMI的裁剪功能，将传感器输出的图像裁剪成适应屏幕的大小
101 *
102 * 说 明: 1. 因为摄像头输出的画面比例固定为4:3，不一定匹配显示器
103 * 2. 需要注意的是，摄像头输出的图像长、宽必须要能被4整除！（ 使用OV2640_Set_Framesize函数进行设置 ）
104 * 3. DCMI的水平有效像素也必须要能被4整除！
105 * 4. 函数会计算水平和垂直偏移，尽量让画面居中裁剪
106 *****************************************************************************************************************************************/
ov2640_dcmi_crop(struct stm32_dcmi * dcmi_dev,uint16_t displey_xsize,uint16_t displey_ysize,uint16_t sensor_xsize,uint16_t sensor_ysize)107 static rt_err_t ov2640_dcmi_crop(struct stm32_dcmi *dcmi_dev, uint16_t displey_xsize, uint16_t displey_ysize, uint16_t sensor_xsize, uint16_t sensor_ysize)
108 {
109 RT_ASSERT(dcmi_dev != RT_NULL);
110 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
111 RT_ASSERT(_dcmi_handle != RT_NULL);
112
113 uint16_t dcmi_x_offset, dcmi_y_offset; // 水平和垂直偏移，垂直代表的是行数，水平代表的是像素时钟数（pclk周期数）
114 uint16_t dcmi_capcnt; // 水平有效像素，代表的是像素时钟数（pclk周期数）
115 uint16_t dcmi_vline; // 垂直有效行数
116
117 if ((displey_xsize >= sensor_xsize) || (displey_ysize >= sensor_ysize)) {
118 LOG_E("actual displayed size (%d, %d) >= camera output size (%d, %d), exit dcmi cropping", displey_xsize, displey_ysize, sensor_xsize, sensor_ysize);
119 return -RT_ERROR; // 如果实际显示的尺寸大于或等于摄像头输出的尺寸，则退出当前函数，不进行裁剪
120 }
121
122 // 在设置为rgb565格式时，水平偏移，必须是奇数，否则画面色彩不正确，
123 // 因为一个有效像素是2个字节，需要2个pclk周期，所以必须从奇数位开始，不然数据会错乱，
124 // 需要注意的是，寄存器值是从0开始算起的 ！
125 dcmi_x_offset = sensor_xsize - displey_xsize; // 实际计算过程为（sensor_xsize - lcd_xsize）/2*2
126
127 // 计算垂直偏移，尽量让画面居中裁剪，该值代表的是行数，
128 dcmi_y_offset = (sensor_ysize - displey_ysize) / 2 - 1; // 寄存器值是从0开始算起的，所以要-1
129
130 // 因为一个有效像素是2个字节，需要2个pclk周期，所以要乘2
131 // 最终得到的寄存器值，必须要能被4整除！
132 dcmi_capcnt = displey_xsize * 2 - 1; // 寄存器值是从0开始算起的，所以要-1
133
134 dcmi_vline = displey_ysize - 1; // 垂直有效行数
135
136 // LOG_D("%d %d %d %d", dcmi_x_offset, dcmi_y_offset, dcmi_capcnt, dcmi_vline);
137 HAL_DCMI_ConfigCrop(_dcmi_handle, dcmi_x_offset, dcmi_y_offset, dcmi_capcnt, dcmi_vline); // 设置裁剪窗口
138 HAL_DCMI_EnableCrop(_dcmi_handle); // 使能裁剪
139
140 return RT_EOK;
141 }
142
143 /***************************************************************************************************************************************
144 * 函 数 名: ov2640_dma_transmit_continuous
145 *
146 * 入口参数: dma_buffer - DMA将要传输的地址，即用于存储摄像头数据的存储区地址
147 * dma_buffersize - 传输的数据大小，32位宽
148 *
149 * 函数功能: 启动DMA传输，连续模式
150 *
151 * 说 明: 1. 开启连续模式之后，会一直进行传输，除非挂起或者停止DCMI
152 * 2. OV2640使用RGB565模式时，1个像素点需要2个字节来存储
153 * 3. 因为DMA配置传输数据为32位宽，计算 dma_buffersize 时，需要除以4，例如：
154 * 要获取 240*240分辨率 的图像，需要传输 240*240*2 = 115200 字节的数据，
155 * 则 dma_buffersize = 115200 / 4 = 28800 。
156 *
157 *****************************************************************************************************************************************/
ov2640_dma_transmit_continuous(struct stm32_dcmi * dcmi_dev,uint32_t dma_buffer,uint32_t dma_buffersize)158 static void ov2640_dma_transmit_continuous(struct stm32_dcmi *dcmi_dev, uint32_t dma_buffer, uint32_t dma_buffersize)
159 {
160 RT_ASSERT(dcmi_dev != RT_NULL);
161 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
162 DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
163 RT_ASSERT(_dcmi_handle != RT_NULL);
164 RT_ASSERT(_dma_handle != RT_NULL);
165
166 _dma_handle->Init.Mode = DMA_CIRCULAR; // 循环模式
167
168 HAL_DMA_Init(_dma_handle); // 配置DMA
169
170 // 使能DCMI采集数据,连续采集模式
171 HAL_DCMI_Start_DMA(_dcmi_handle, DCMI_MODE_CONTINUOUS, (uint32_t)dma_buffer, dma_buffersize);
172 }
173
174 /***************************************************************************************************************************************
175 * 函 数 名: ov2640_dma_transmit_snapshot
176 *
177 * 入口参数: dma_buffer - DMA将要传输的地址，即用于存储摄像头数据的存储区地址
178 * dma_buffersize - 传输的数据大小，32位宽
179 *
180 * 函数功能: 启动DMA传输，快照模式，传输一帧图像后停止
181 *
182 * 说 明: 1. 快照模式，只传输一帧的数据
183 * 2. OV2640使用RGB565模式时，1个像素点需要2个字节来存储
184 * 3. 因为DMA配置传输数据为32位宽，计算 dma_buffersize 时，需要除以4，例如：
185 * 要获取 240*240分辨率 的图像，需要传输 240*240*2 = 115200 字节的数据，
186 * 则 dma_buffersize = 115200 / 4 = 28800 。
187 * 4. 使用该模式传输完成之后，DCMI会被挂起，再次启用传输之前，需要调用 OV2640_DCMI_Resume() 恢复DCMI
188 *
189 *****************************************************************************************************************************************/
ov2640_dma_transmit_snapshot(struct stm32_dcmi * dcmi_dev,uint32_t dma_buffer,uint32_t dma_buffersize)190 static void ov2640_dma_transmit_snapshot(struct stm32_dcmi *dcmi_dev, uint32_t dma_buffer, uint32_t dma_buffersize)
191 {
192 RT_ASSERT(dcmi_dev != RT_NULL);
193 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
194 DMA_HandleTypeDef *_dma_handle = &dcmi_dev->dma_handle;
195 RT_ASSERT(_dcmi_handle != RT_NULL);
196 RT_ASSERT(_dma_handle != RT_NULL);
197
198 _dma_handle->Init.Mode = DMA_NORMAL; // 正常模式
199
200 HAL_DMA_Init(_dma_handle); // 配置DMA
201
202 HAL_DCMI_Start_DMA(_dcmi_handle, DCMI_MODE_SNAPSHOT, (uint32_t)dma_buffer, dma_buffersize);
203 }
204
205 /***************************************************************************************************************************************
206 * 函 数 名: ov2640_dcmi_suspend
207 *
208 * 函数功能: 挂起dcmi，停止捕获数据
209 *
210 * 说 明: 1. 开启连续模式之后，再调用该函数，会停止捕获dcmi的数据
211 * 2. 可以调用 ov2640_dcmi_resume() 恢复dcmi
212 * 3. 需要注意的，挂起dcmi期间，dma是没有停止工作的
213 *fanke
214 *****************************************************************************************************************************************/
ov2640_dcmi_suspend(struct stm32_dcmi * dcmi_dev)215 static void ov2640_dcmi_suspend(struct stm32_dcmi *dcmi_dev)
216 {
217 RT_ASSERT(dcmi_dev != RT_NULL);
218 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
219 RT_ASSERT(_dcmi_handle != RT_NULL);
220
221 HAL_DCMI_Suspend(_dcmi_handle); // 挂起dcmi
222 }
223
224 /***************************************************************************************************************************************
225 * 函 数 名: ov2640_dcmi_resume
226 *
227 * 函数功能: 恢复dcmi，开始捕获数据
228 *
229 * 说 明: 1. 当dcmi被挂起时，可以调用该函数恢复
230 * 2. 使用 ov2640_dma_transmit_snapshot() 快照模式，传输完成之后，dcmi也会被挂起，再次启用传输之前，
231 * 需要调用本函数恢复dcmi捕获
232 *
233 *****************************************************************************************************************************************/
ov2640_dcmi_resume(struct stm32_dcmi * dcmi_dev)234 static void ov2640_dcmi_resume(struct stm32_dcmi *dcmi_dev)
235 {
236 RT_ASSERT(dcmi_dev != RT_NULL);
237 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
238 RT_ASSERT(_dcmi_handle != RT_NULL);
239
240 _dcmi_handle->State = HAL_DCMI_STATE_BUSY; // 变更dcmi标志
241 _dcmi_handle->Instance->CR |= DCMI_CR_CAPTURE; // 开启dcmi捕获
242 }
243
244 /***************************************************************************************************************************************
245 * 函 数 名: ov2640_dcmi_stop
246 *
247 * 函数功能: 禁止dcmi的dma请求，停止dcmi捕获，禁止dcmi外设
248 *
249 *****************************************************************************************************************************************/
ov2640_dcmi_stop(struct stm32_dcmi * dcmi_dev)250 static void ov2640_dcmi_stop(struct stm32_dcmi *dcmi_dev)
251 {
252 RT_ASSERT(dcmi_dev != RT_NULL);
253 DCMI_HandleTypeDef *_dcmi_handle = &dcmi_dev->dcmi_handle;
254 RT_ASSERT(_dcmi_handle != RT_NULL);
255
256 HAL_DCMI_Stop(_dcmi_handle);
257 }
258
DCMI_IRQHandler(void)259 void DCMI_IRQHandler(void)
260 {
261 /* enter interrupt */
262 rt_interrupt_enter();
263
264 HAL_DCMI_IRQHandler(&rt_dcmi_dev.dcmi_handle);
265
266 /* leave interrupt */
267 rt_interrupt_leave();
268 }
269
DMA2_Stream7_IRQHandler(void)270 void DMA2_Stream7_IRQHandler(void)
271 {
272 /* enter interrupt */
273 rt_interrupt_enter();
274
275 HAL_DMA_IRQHandler(&rt_dcmi_dev.dma_handle);
276
277 /* leave interrupt */
278 rt_interrupt_leave();
279 }
280
281 /* Capture a frame of the image */
HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef * hdcmi)282 void HAL_DCMI_FrameEventCallback(DCMI_HandleTypeDef *hdcmi)
283 {
284 /* enter interrupt */
285 rt_interrupt_enter();
286
287 static uint32_t dcmi_tick = 0; // 用于保存当前的时间计数值
288 static uint8_t dcmi_frame_count = 0; // 帧数计数
289 if (HAL_GetTick() - dcmi_tick >= 1000) // 每隔 1s 计算一次帧率
290 {
291 dcmi_tick = HAL_GetTick(); // 重新获取当前时间计数值
292 ov2640_fps = dcmi_frame_count; // 获得fps
293 dcmi_frame_count = 0; // 计数清0
294 }
295 dcmi_frame_count++; // 没进入一次中断（每次传输完一帧数据），计数值+1
296
297 rt_sem_release(&rt_dcmi_dev.cam_semaphore);
298 /* leave interrupt */
299 rt_interrupt_leave();
300 }
301
HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef * hdcmi)302 void HAL_DCMI_ErrorCallback(DCMI_HandleTypeDef *hdcmi)
303 {
304 /* enter interrupt */
305 rt_interrupt_enter();
306
307 if (HAL_DCMI_GetError(hdcmi) == HAL_DCMI_ERROR_OVR) {
308 LOG_E("FIFO overflow error");
309 }
310 LOG_E("error:0x%08x", HAL_DCMI_GetError(hdcmi));
311
312 /* leave interrupt */
313 rt_interrupt_leave();
314 }
315
rt_dcmi_init(rt_device_t dev)316 static rt_err_t rt_dcmi_init(rt_device_t dev)
317 {
318 RT_ASSERT(dev != RT_NULL);
319 rt_err_t result = RT_EOK;
320 struct stm32_dcmi *_rt_dcmi_dev = DCMI_DEVICE(dev);
321
322 result = rt_hw_dcmi_init(_rt_dcmi_dev);
323 if (result != RT_EOK) {
324 return result;
325 }
326
327 return result;
328 }
329
rt_dcmi_open(rt_device_t dev,rt_uint16_t oflag)330 static rt_err_t rt_dcmi_open(rt_device_t dev, rt_uint16_t oflag)
331 {
332 RT_ASSERT(dev != RT_NULL);
333
334 return RT_EOK;
335 }
336
rt_dcmi_close(rt_device_t dev)337 static rt_err_t rt_dcmi_close(rt_device_t dev)
338 {
339 RT_ASSERT(dev != RT_NULL);
340
341 return RT_EOK;
342 }
343
rt_dcmi_control(rt_device_t dev,int cmd,void * args)344 static rt_err_t rt_dcmi_control(rt_device_t dev, int cmd, void *args)
345 {
346 RT_ASSERT(dev != RT_NULL);
347 struct stm32_dcmi *_rt_dcmi_dev = DCMI_DEVICE(dev);
348
349 switch (cmd) {
350 case DCMI_CTRL_CROP: {
351 RT_ASSERT(args != RT_NULL);
352 struct stm32_dcmi_cropsize* cropsize = (struct stm32_dcmi_cropsize*)args;
353 ov2640_dcmi_crop(_rt_dcmi_dev, cropsize->displey_xsize, cropsize->displey_ysize, cropsize->sensor_xsize, cropsize->sensor_ysize);
354 } break;
355 case DCMI_CTRL_TRANSMIT_CONTINUOUS: {
356 RT_ASSERT(args != RT_NULL);
357 struct stm32_dcmi_dma_transmitbuffer* transmitbuffer = (struct stm32_dcmi_dma_transmitbuffer*)args;
358 ov2640_dma_transmit_continuous(_rt_dcmi_dev, transmitbuffer->dma_buffer, transmitbuffer->dma_buffersize);
359 } break;
360 case DCMI_CTRL_TRANSMIT_SNAPSHOT: {
361 RT_ASSERT(args != RT_NULL);
362 struct stm32_dcmi_dma_transmitbuffer* transmitbuffer = (struct stm32_dcmi_dma_transmitbuffer*)args;
363 ov2640_dma_transmit_snapshot(_rt_dcmi_dev, transmitbuffer->dma_buffer, transmitbuffer->dma_buffersize);
364 } break;
365 case DCMI_CTRL_SUSPEND: {
366 ov2640_dcmi_suspend(_rt_dcmi_dev);
367 } break;
368 case DCMI_CTRL_RESUME: {
369 ov2640_dcmi_resume(_rt_dcmi_dev);
370 } break;
371 case DCMI_CTRL_STOP: {
372 ov2640_dcmi_stop(_rt_dcmi_dev);
373 } break;
374 case DCMI_CTRL_GET_FPS: {
375 *(uint8_t*)args = ov2640_fps;
376 } break;
377
378 default:
379 return -RT_EINVAL;
380 }
381
382 return RT_EOK;
383 }
384
rt_dcmi_read(rt_device_t dev,rt_off_t pos,void * buffer,rt_size_t size)385 static rt_ssize_t rt_dcmi_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
386 {
387 RT_ASSERT(dev != RT_NULL);
388
389 return RT_EOK;
390 }
391
rt_dcmi_write(rt_device_t dev,rt_off_t pos,const void * buffer,rt_size_t size)392 static rt_ssize_t rt_dcmi_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
393 {
394 RT_ASSERT(dev != RT_NULL);
395
396 return RT_EOK;
397 }
398
399 #ifdef RT_USING_DEVICE_OPS
400 const static struct rt_device_ops dcmi_ops =
401 {
402 rt_dcmi_init,
403 rt_dcmi_open,
404 rt_dcmi_close,
405 rt_dcmi_read,
406 rt_dcmi_write,
407 rt_dcmi_control,
408 };
409 #endif
410
dcmi_init(void)411 int dcmi_init(void)
412 {
413 int ret = 0;
414 rt_device_t device = &rt_dcmi_dev.parent;
415
416 /* memset rt_dcmi_dev to zero */
417 memset(&rt_dcmi_dev, 0x00, sizeof(rt_dcmi_dev));
418
419 /* init cam_semaphore semaphore */
420 ret = rt_sem_init(&rt_dcmi_dev.cam_semaphore, "cam_sem", 0, RT_IPC_FLAG_FIFO);
421 if (ret != RT_EOK) {
422 LOG_E("init semaphore failed!\n");
423 ret = -RT_ENOMEM;
424 goto __exit;
425 }
426
427 device->type = RT_Device_Class_Miscellaneous;
428 #ifdef RT_USING_DEVICE_OPS
429 device->ops = &dcmi_ops;
430 #else
431 device->init = rt_dcmi_init;
432 device->open = rt_dcmi_open;
433 device->close = rt_dcmi_close;
434 device->read = rt_dcmi_read;
435 device->write = rt_dcmi_write;
436 device->control = rt_dcmi_control;
437 #endif
438 device->user_data = RT_NULL;
439
440 ret = rt_device_register(device, "dcmi", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
441 if (ret != RT_EOK) {
442 LOG_E("dcmi registered fail!\n\r");
443 return -RT_ERROR;
444 }
445
446 LOG_I("dcmi init success!");
447
448 return RT_EOK;
449 __exit:
450 if (ret != RT_EOK) {
451 rt_sem_delete(&rt_dcmi_dev.cam_semaphore);
452 }
453 return ret;
454 }
455 INIT_BOARD_EXPORT(dcmi_init);
456
457 #endif /* BSP_USING_DCMI */
458