1 // Copyright (C) 2022 Beken Corporation
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <driver/int.h>
16 #include <os/mem.h>
17 #include <driver/gpio.h>
18 #include <driver/gpio_types.h>
19
20 #include <driver/dma.h>
21 #include <driver/i2c.h>
22 #include <driver/jpeg_enc.h>
23 #include <driver/jpeg_enc_types.h>
24
25 #include <driver/media_types.h>
26 #include <driver/dvp_camera.h>
27 #include <driver/dvp_camera_types.h>
28 #include "dvp_sensor_devices.h"
29
30 #include <os/os.h>
31 #include <os/mem.h>
32 #include <os/str.h>
33 #include <gpio_map.h>
34
35 #include "gpio_driver.h"
36 #include <driver/gpio.h>
37
38 #if (CONFIG_PSRAM)
39 #include <driver/psram.h>
40 #endif
41
42 #define TAG "dvp_drv"
43
44 #define LOGI(...) BK_LOGI(TAG, ##__VA_ARGS__)
45 #define LOGW(...) BK_LOGW(TAG, ##__VA_ARGS__)
46 #define LOGE(...) BK_LOGE(TAG, ##__VA_ARGS__)
47 #define LOGD(...) BK_LOGD(TAG, ##__VA_ARGS__)
48
49 #define FRAME_BUFFER_DMA_TH (1024 * 10)
50 #define JPEG_CRC_SIZE (5)
51 #define DROP_FRAME_COUNT (10)
52
53 #define FRAME_BUFFER_CACHE (1024 * 10)
54
55 #define DVP_I2C_TIMEOUT (2000)
56
57 //#define DVP_STRIP
58
59 #define IO_FUNCTION_ENABLE(pin, func) \
60 do { \
61 gpio_dev_unmap(pin); \
62 gpio_dev_map(pin, func); \
63 } while (0)
64
65
66 typedef struct
67 {
68 uint8 index : 1;
69 uint8 cached : 1;
70 uint8 eof : 1;
71 uint8 psram_dma;
72 uint8 psram_dma_busy;
73 uint16 psram_dma_left;
74 uint8 *buffer;
75 uint8 drop_count;
76 frame_buffer_t *frame;
77 } dvp_camera_drv_t;
78
79 typedef struct
80 {
81 uint8_t enable_set;
82 uint8_t auto_encode;
83 uint32_t up;
84 uint32_t low;
85 } dvp_camera_encode_t;
86
87 dvp_camera_drv_t *dvp_camera_drv = NULL;
88
89
90 const dvp_sensor_config_t *dvp_sensor_configs[] =
91 {
92 &dvp_sensor_gc0328c,
93 &dvp_sensor_hm1055,
94 &dvp_sensor_ov2640,
95 };
96
97 static const dvp_camera_i2c_callback_t dvp_camera_i2c_cb =
98 {
99 dvp_camera_i2c_read_uint8,
100 dvp_camera_i2c_read_uint16,
101 dvp_camera_i2c_write_uint8,
102 dvp_camera_i2c_write_uint16,
103 };
104
105 static const dvp_sensor_config_t *current_sensor = NULL;
106 static dvp_camera_config_t dvp_camera_config = {0};
107
108 static uint8_t dvp_camera_dma_channel = 0;
109
110 static uint8_t dvp_diag_debug = 0;
111
112 #define DVP_BUFFER_SIZE 1024
113 #define DVP_BUFFER_COUNT 4
114
115 uint32_t sequence = 0;
116 dvp_camera_encode_t dvp_camera_encode = {0, 0, 50 * 1024, 30 * 1024};
117 static beken_semaphore_t dvp_sema = NULL;
118
119 extern media_debug_t *media_debug;
120
121 frame_buffer_t *curr_frame_buffer = NULL;
122
123 dvp_camera_device_t *dvp_camera_device = NULL;
124
125 bk_err_t dvp_memcpy_by_chnl(void *out, const void *in, uint32_t len, dma_id_t cpy_chnls);
126
get_sensor_config_interface_by_id(sensor_id_t id)127 const dvp_sensor_config_t *get_sensor_config_interface_by_id(sensor_id_t id)
128 {
129 uint32_t i, size = sizeof(dvp_sensor_configs) / sizeof(dvp_sensor_config_t *);
130
131 for (i = 0; i < size; i++)
132 {
133 if (dvp_sensor_configs[i]->id == id)
134 {
135 return dvp_sensor_configs[i];
136 }
137 }
138
139 return NULL;
140 }
141
142 /*
143 static void jpeg_dump(char *tag, uint8_t *src, uint32_t size)
144 {
145 uint32_t i;
146
147 LOGE("%s: ", tag);
148
149 for (i = 0; i < size; i++)
150 {
151 os_printf("%02X ", src[i]);
152 }
153 os_printf("\n");
154 }
155 */
156
157 #ifdef DVP_STRIP
dvp_frame_sram_strip(uint8_t * src,uint32_t size)158 static uint32_t dvp_frame_sram_strip(uint8_t *src, uint32_t size)
159 {
160 uint32_t i;
161 uint32_t tail = size - 1;
162
163 if (src[tail] != 0xD9
164 && src[tail -1 ] != 0xFF)
165 {
166 LOGE("strip tail error\n");
167 return size;
168 }
169 else
170 {
171 tail -= 2;
172 }
173
174 //jpeg_dump("before", src + size - 10, 10);
175
176 for (i = tail; i > 0; i--)
177 {
178 if (src[i] == 0xFF)
179 {
180 tail--;
181 }
182 else
183 {
184 tail++;
185 break;
186 }
187 }
188
189 src[tail++] = 0xFF;
190 src[tail++] = 0xD9;
191
192 //jpeg_dump("after", src + tail - 10, 10);
193
194 return tail;
195 }
196 #endif
197
dvp_memcpy_finish_callback(dma_id_t id)198 static void dvp_memcpy_finish_callback(dma_id_t id)
199 {
200 if (dvp_diag_debug)
201 {
202 bk_gpio_pull_up(GPIO_2);
203 }
204
205 dvp_camera_drv->psram_dma_busy = false;
206 dvp_camera_drv->index = !dvp_camera_drv->index;
207
208 if (dvp_camera_drv->eof == true)
209 {
210 frame_buffer_t *frame = dvp_camera_drv->frame;
211
212 if (dvp_camera_drv->psram_dma_left != 0)
213 {
214 dvp_memcpy_by_chnl(frame->frame + frame->length,
215 dvp_camera_drv->index ? (dvp_camera_drv->buffer + FRAME_BUFFER_CACHE) : dvp_camera_drv->buffer,
216 dvp_camera_drv->psram_dma_left, dvp_camera_drv->psram_dma);
217 frame->length += dvp_camera_drv->psram_dma_left;
218 frame->sequence = ++sequence;
219 dvp_camera_drv->psram_dma_left = 0;
220 }
221 else
222 {
223 dvp_camera_config.frame_complete(frame);
224 dvp_camera_drv->index = 0;
225 dvp_camera_drv->frame = NULL;
226 dvp_camera_drv->eof = false;
227
228 curr_frame_buffer = dvp_camera_config.frame_alloc();
229
230 if (curr_frame_buffer == NULL
231 || curr_frame_buffer->frame == NULL)
232 {
233 LOGE("alloc frame error\n");
234 return;
235 }
236
237 curr_frame_buffer->length = 0;
238
239 bk_dma_start(dvp_camera_dma_channel);
240 }
241 }
242
243
244 if (dvp_diag_debug)
245 {
246 bk_gpio_pull_down(GPIO_2);
247 }
248 }
249
dvp_memcpy_by_chnl(void * out,const void * in,uint32_t len,dma_id_t cpy_chnls)250 bk_err_t dvp_memcpy_by_chnl(void *out, const void *in, uint32_t len, dma_id_t cpy_chnls)
251 {
252 dma_config_t dma_config;
253
254 /* fix for psram 4bytes alignment */
255 if (len % 4)
256 {
257 len = (len / 4 + 1) * 4;
258 }
259
260 os_memset(&dma_config, 0, sizeof(dma_config_t));
261
262 dma_config.mode = DMA_WORK_MODE_SINGLE;
263 dma_config.chan_prio = 1;
264
265 dma_config.src.dev = DMA_DEV_DTCM;
266 dma_config.src.width = DMA_DATA_WIDTH_32BITS;
267 dma_config.src.addr_inc_en = DMA_ADDR_INC_ENABLE;
268 dma_config.src.start_addr = (uint32_t)in;
269 dma_config.src.end_addr = (uint32_t)(in + len);
270
271 dma_config.dst.dev = DMA_DEV_DTCM;
272 dma_config.dst.width = DMA_DATA_WIDTH_32BITS;
273 dma_config.dst.addr_inc_en = DMA_ADDR_INC_ENABLE;
274 dma_config.dst.start_addr = (uint32_t)out;
275 dma_config.dst.end_addr = (uint32_t)(out + len);
276
277 dvp_camera_drv->psram_dma_busy = true;
278
279 BK_LOG_ON_ERR(bk_dma_init(cpy_chnls, &dma_config));
280 BK_LOG_ON_ERR(bk_dma_set_transfer_len(cpy_chnls, len));
281
282 BK_LOG_ON_ERR(bk_dma_register_isr(cpy_chnls, NULL, dvp_memcpy_finish_callback));
283 BK_LOG_ON_ERR(bk_dma_enable_finish_interrupt(cpy_chnls));
284 BK_LOG_ON_ERR(bk_dma_start(cpy_chnls));
285 //BK_WHILE (bk_dma_get_enable_status(cpy_chnl));
286
287
288 return BK_OK;
289
290 }
291
292
dvp_camera_eof_handler(jpeg_unit_t id,void * param)293 static void dvp_camera_eof_handler(jpeg_unit_t id, void *param)
294 {
295 uint32_t real_length = bk_jpeg_enc_get_frame_size();
296 uint32_t remain_length = FRAME_BUFFER_CACHE - bk_dma_get_remain_len(dvp_camera_dma_channel);
297 uint32_t left_length = remain_length - JPEG_CRC_SIZE;
298
299 media_debug->isr_jpeg++;
300
301 if (dvp_diag_debug)
302 {
303 bk_gpio_pull_up(GPIO_8);
304 }
305
306 if (dvp_sema != NULL)
307 {
308 rtos_set_semaphore(&dvp_sema);
309 }
310
311 if (dvp_camera_drv->drop_count)
312 {
313 dvp_camera_drv->drop_count--;
314 bk_dma_stop(dvp_camera_dma_channel);
315 bk_dma_start(dvp_camera_dma_channel);
316 return;
317 }
318
319 if (dvp_camera_drv->cached)
320 {
321
322 if (dvp_camera_encode.enable_set)
323 {
324 if (dvp_camera_encode.auto_encode)
325 {
326 bk_jpeg_enc_enable_encode_auto_ctrl(dvp_camera_encode.auto_encode);
327 bk_jpeg_enc_set_target_size(dvp_camera_encode.up, dvp_camera_encode.low);
328 }
329 else
330 {
331 bk_jpeg_enc_enable_encode_auto_ctrl(dvp_camera_encode.auto_encode);
332 }
333
334 dvp_camera_encode.enable_set = 0;
335 }
336
337 if (curr_frame_buffer == NULL
338 || curr_frame_buffer->frame == NULL)
339 {
340 LOGE("curr_frame_buffer NULL error\n");
341 goto error;
342 }
343
344 if (curr_frame_buffer->length + left_length != real_length)
345 {
346 LOGW("size no match: %u:%u:%u\n", curr_frame_buffer->length + left_length, real_length, remain_length);
347 }
348
349 #ifdef DVP_STRIP
350 left_length = dvp_frame_sram_strip(dvp_camera_drv->index ? (dvp_camera_drv->buffer + FRAME_BUFFER_CACHE) : dvp_camera_drv->buffer, left_length);
351 #endif
352
353 if (dvp_camera_drv->psram_dma_busy == true)
354 {
355 dvp_camera_drv->frame = curr_frame_buffer;
356 dvp_camera_drv->psram_dma_left = left_length;
357 dvp_camera_drv->eof = true;
358 }
359 else
360 {
361 dvp_camera_drv->frame = curr_frame_buffer;
362 dvp_camera_drv->psram_dma_left = 0;
363 dvp_camera_drv->eof = true;
364
365 dvp_memcpy_by_chnl(curr_frame_buffer->frame + curr_frame_buffer->length,
366 dvp_camera_drv->index ? (dvp_camera_drv->buffer + FRAME_BUFFER_CACHE) : dvp_camera_drv->buffer,
367 left_length, dvp_camera_drv->psram_dma);
368 curr_frame_buffer->length += left_length;
369 curr_frame_buffer->sequence = ++sequence;
370 }
371
372 bk_dma_stop(dvp_camera_dma_channel);
373 }
374 else
375 {
376 remain_length = FRAME_BUFFER_DMA_TH - bk_dma_get_remain_len(dvp_camera_dma_channel);
377 left_length = remain_length - JPEG_CRC_SIZE;
378
379 if (curr_frame_buffer->length + left_length != real_length)
380 {
381 LOGW("size no match: %u:%u:%u\n", curr_frame_buffer->length + left_length, real_length, remain_length);
382 LOGW("size: %u:%u:%u\n", bk_dma_get_remain_len(dvp_camera_dma_channel), bk_jpeg_enc_get_frame_size(), curr_frame_buffer->size);
383 }
384
385 curr_frame_buffer->length += left_length;
386 dvp_camera_config.frame_complete(curr_frame_buffer);
387 curr_frame_buffer = dvp_camera_config.frame_alloc();
388 curr_frame_buffer->length = 0;
389
390 if (curr_frame_buffer == NULL
391 || curr_frame_buffer->frame == NULL)
392 {
393 LOGE("alloc frame error\n");
394 return;
395 }
396
397 bk_dma_stop(dvp_camera_dma_channel);
398 bk_dma_set_dest_addr(dvp_camera_dma_channel, (uint32_t)curr_frame_buffer->frame, (uint32_t)(curr_frame_buffer->frame + curr_frame_buffer->size));
399 bk_dma_start(dvp_camera_dma_channel);
400
401 }
402
403
404 #if 0
405 dvp_camera_drv->index = 0;
406 bk_dma_start(dvp_camera_dma_channel);
407 #endif
408
409 if (dvp_diag_debug)
410 {
411 bk_gpio_pull_down(GPIO_8);
412 }
413
414 return;
415
416 error:
417 bk_dma_stop(dvp_camera_dma_channel);
418 bk_jpeg_enc_set_enable(0, JPEG_ENC_MODE);
419 }
420
dvp_camera_dma_finish_callback(dma_id_t id)421 static void dvp_camera_dma_finish_callback(dma_id_t id)
422 {
423 if (dvp_diag_debug)
424 {
425 bk_gpio_pull_up(GPIO_9);
426 }
427
428 if (dvp_camera_drv->cached == true)
429 {
430 if (curr_frame_buffer == NULL
431 || curr_frame_buffer->frame == NULL)
432 {
433 LOGE("%s curr_frame_buffer NULL\n");
434 return;
435 }
436
437 if (dvp_camera_drv->drop_count == 0)
438 {
439 dvp_memcpy_by_chnl(curr_frame_buffer->frame + curr_frame_buffer->length,
440 dvp_camera_drv->index ? (dvp_camera_drv->buffer + FRAME_BUFFER_CACHE) : dvp_camera_drv->buffer,
441 FRAME_BUFFER_CACHE, dvp_camera_drv->psram_dma);
442 curr_frame_buffer->length += FRAME_BUFFER_CACHE;
443 }
444 }
445 else
446 {
447 curr_frame_buffer->length += FRAME_BUFFER_DMA_TH;
448 }
449
450 if (dvp_diag_debug)
451 {
452 bk_gpio_pull_down(GPIO_9);
453 }
454 }
455
dvp_camera_dma_config(void)456 static bk_err_t dvp_camera_dma_config(void)
457 {
458 bk_err_t ret = BK_OK;
459 dma_config_t dma_config = {0};
460 uint32_t jpeg_fifo_addr;
461
462 curr_frame_buffer = dvp_camera_config.frame_alloc();
463
464 if (curr_frame_buffer == NULL)
465 {
466 LOGE("malloc frame fail \r\n");
467 ret = BK_FAIL;
468 return ret;
469 }
470
471 curr_frame_buffer->length = 0;
472
473 dvp_camera_dma_channel = bk_dma_alloc(DMA_DEV_JPEG);
474 if ((dvp_camera_dma_channel < DMA_ID_0) || (dvp_camera_dma_channel >= DMA_ID_MAX))
475 {
476 LOGE("malloc dma fail \r\n");
477 ret = BK_FAIL;
478 return ret;
479 }
480 bk_jpeg_enc_get_fifo_addr(&jpeg_fifo_addr);
481
482 dma_config.mode = DMA_WORK_MODE_REPEAT;
483 dma_config.chan_prio = 0;
484 dma_config.src.dev = DMA_DEV_JPEG;
485 dma_config.src.width = DMA_DATA_WIDTH_32BITS;
486 dma_config.src.start_addr = jpeg_fifo_addr;
487 dma_config.dst.dev = DMA_DEV_DTCM;
488 dma_config.dst.width = DMA_DATA_WIDTH_32BITS;
489 dma_config.dst.addr_inc_en = DMA_ADDR_INC_ENABLE;
490 dma_config.dst.addr_loop_en = DMA_ADDR_LOOP_ENABLE;
491
492 if (dvp_camera_drv->cached)
493 {
494 dma_config.dst.start_addr = (uint32_t)dvp_camera_drv->buffer;
495 dma_config.dst.end_addr = (uint32_t)(dvp_camera_drv->buffer + FRAME_BUFFER_CACHE * 2);
496 }
497 else
498 {
499 dma_config.dst.start_addr = (uint32_t)curr_frame_buffer->frame;
500 dma_config.dst.end_addr = (uint32_t)(curr_frame_buffer->frame + curr_frame_buffer->size);
501 }
502
503 //os_printf("dst_start_addr:%08x, dst_end_addr:%08x\r\n", (uint32_t)info.buffer_addr, dma_config.dst.end_addr);
504
505 BK_LOG_ON_ERR(bk_dma_init(dvp_camera_dma_channel, &dma_config));
506
507 if (dvp_camera_drv->cached)
508 {
509 BK_LOG_ON_ERR(bk_dma_set_transfer_len(dvp_camera_dma_channel, FRAME_BUFFER_CACHE));
510 }
511 else
512 {
513 BK_LOG_ON_ERR(bk_dma_set_transfer_len(dvp_camera_dma_channel, FRAME_BUFFER_DMA_TH));
514 }
515 BK_LOG_ON_ERR(bk_dma_register_isr(dvp_camera_dma_channel, NULL, dvp_camera_dma_finish_callback));
516 BK_LOG_ON_ERR(bk_dma_enable_finish_interrupt(dvp_camera_dma_channel));
517 BK_LOG_ON_ERR(bk_dma_start(dvp_camera_dma_channel));
518
519 return ret;
520 }
521
dvp_camera_yuv_eof_handler(jpeg_unit_t id,void * param)522 static void dvp_camera_yuv_eof_handler(jpeg_unit_t id, void *param)
523 {
524 frame_buffer_t *frame = NULL;
525
526 if (dvp_sema != NULL)
527 {
528 rtos_set_semaphore(&dvp_sema);
529 }
530
531 media_debug->isr_jpeg++;
532
533 curr_frame_buffer->sequence = ++sequence;
534
535 if (dvp_camera_device)
536 {
537 curr_frame_buffer->length = dvp_camera_device->pixel_size;
538 }
539
540 dvp_camera_config.frame_complete(curr_frame_buffer);
541
542 frame = dvp_camera_config.frame_alloc();
543
544 if (frame != NULL)
545 {
546 curr_frame_buffer = frame;
547 bk_jpeg_set_em_base_addr(curr_frame_buffer->frame);
548 }
549 else
550 {
551 LOGE("%s malloc frame failed\n", __func__);
552 }
553 }
554
get_sensor_auto_detect(const dvp_camera_i2c_callback_t * cb)555 const dvp_sensor_config_t *get_sensor_auto_detect(const dvp_camera_i2c_callback_t *cb)
556 {
557 uint32_t i, size = sizeof(dvp_sensor_configs) / sizeof(const dvp_sensor_config_t *);
558
559 for (i = 0; i < size; i++)
560 {
561 if (dvp_sensor_configs[i]->detect(cb) == true)
562 {
563 return dvp_sensor_configs[i];
564 }
565 }
566
567 return NULL;
568 }
569
dvp_camera_i2c_read_uint8(uint8_t addr,uint8_t reg,uint8_t * value)570 int dvp_camera_i2c_read_uint8(uint8_t addr, uint8_t reg, uint8_t *value)
571 {
572 i2c_mem_param_t mem_param = {0};
573
574 mem_param.dev_addr = addr;
575 mem_param.mem_addr_size = I2C_MEM_ADDR_SIZE_8BIT;
576 mem_param.data_size = 1;
577 mem_param.timeout_ms = DVP_I2C_TIMEOUT;
578 mem_param.mem_addr = reg;
579 mem_param.data = value;
580
581 return bk_i2c_memory_read(CAMERA_DVP_I2C_ID, &mem_param);
582 }
583
dvp_camera_i2c_read_uint16(uint8_t addr,uint16_t reg,uint8_t * value)584 int dvp_camera_i2c_read_uint16(uint8_t addr, uint16_t reg, uint8_t *value)
585 {
586 i2c_mem_param_t mem_param = {0};
587
588 mem_param.dev_addr = addr;
589 mem_param.mem_addr_size = I2C_MEM_ADDR_SIZE_16BIT;
590 mem_param.data_size = 1;
591 mem_param.timeout_ms = DVP_I2C_TIMEOUT;
592 mem_param.mem_addr = reg;
593 mem_param.data = value;
594
595 return bk_i2c_memory_read(CAMERA_DVP_I2C_ID, &mem_param);
596 }
597
dvp_camera_i2c_write_uint8(uint8_t addr,uint8_t reg,uint8_t value)598 int dvp_camera_i2c_write_uint8(uint8_t addr, uint8_t reg, uint8_t value)
599 {
600 i2c_mem_param_t mem_param = {0};
601 mem_param.dev_addr = addr;
602 mem_param.mem_addr_size = I2C_MEM_ADDR_SIZE_8BIT;
603 mem_param.data_size = 1;
604 mem_param.timeout_ms = DVP_I2C_TIMEOUT;
605 mem_param.mem_addr = reg;
606 mem_param.data = (uint8_t *)(&value);
607
608 return bk_i2c_memory_write(CAMERA_DVP_I2C_ID, &mem_param);
609 }
610
dvp_camera_i2c_write_uint16(uint8_t addr,uint16_t reg,uint8_t value)611 int dvp_camera_i2c_write_uint16(uint8_t addr, uint16_t reg, uint8_t value)
612 {
613 i2c_mem_param_t mem_param = {0};
614 mem_param.dev_addr = addr;
615 mem_param.mem_addr_size = I2C_MEM_ADDR_SIZE_16BIT;
616 mem_param.data_size = 1;
617 mem_param.timeout_ms = DVP_I2C_TIMEOUT;
618 mem_param.mem_addr = reg;
619 mem_param.data = (uint8_t *)(&value);
620
621 return bk_i2c_memory_write(CAMERA_DVP_I2C_ID, &mem_param);
622 }
623
bk_dvp_camera_gpio_init(const dvp_camera_config_t * config,uint8_t mode)624 bk_err_t bk_dvp_camera_gpio_init(const dvp_camera_config_t *config, uint8_t mode)
625 {
626
627 if (mode == 1)
628 {
629 IO_FUNCTION_ENABLE(CAMERA_DVP_MCLK_PIN, CAMERA_DVP_MCLK_FUNC);
630 IO_FUNCTION_ENABLE(CAMERA_DVP_PCLK_PIN, CAMERA_DVP_PCLK_FUNC);
631 }
632
633 if (mode == 2)
634 {
635 IO_FUNCTION_ENABLE(CAMERA_DVP_HSYNC_PIN, CAMERA_DVP_HSYNC_FUNC);
636 IO_FUNCTION_ENABLE(CAMERA_DVP_VSYNC_PIN, CAMERA_DVP_VSYNC_FUNC);
637
638 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA0_PIN, CAMERA_DVP_PXDATA0_FUNC);
639 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA1_PIN, CAMERA_DVP_PXDATA1_FUNC);
640 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA2_PIN, CAMERA_DVP_PXDATA2_FUNC);
641 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA3_PIN, CAMERA_DVP_PXDATA3_FUNC);
642 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA4_PIN, CAMERA_DVP_PXDATA4_FUNC);
643 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA5_PIN, CAMERA_DVP_PXDATA5_FUNC);
644 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA6_PIN, CAMERA_DVP_PXDATA6_FUNC);
645 IO_FUNCTION_ENABLE(CAMERA_DVP_PXDATA7_PIN, CAMERA_DVP_PXDATA7_FUNC);
646
647
648 }
649 if (dvp_diag_debug)
650 {
651 //gpio_dev_unmap(GPIO_2);
652 //bk_gpio_pull_down(GPIO_2);
653 //gpio_dev_unmap(GPIO_3);
654 //bk_gpio_pull_down(GPIO_3);
655 //gpio_dev_unmap(GPIO_4);
656 //bk_gpio_pull_down(GPIO_4);
657 //gpio_dev_unmap(GPIO_5);
658 //bk_gpio_pull_down(GPIO_5);
659 gpio_dev_unmap(GPIO_6);
660 bk_gpio_pull_down(GPIO_6);
661 gpio_dev_unmap(GPIO_7);
662 bk_gpio_pull_down(GPIO_7);
663 gpio_dev_unmap(GPIO_8);
664 bk_gpio_pull_down(GPIO_8);
665 gpio_dev_unmap(GPIO_9);
666 bk_gpio_pull_down(GPIO_9);
667 }
668
669 return 0;
670 }
671
672
bk_dvp_camera_driver_init(dvp_camera_config_t * config)673 bk_err_t bk_dvp_camera_driver_init(dvp_camera_config_t *config)
674 {
675 int ret = kNoErr;
676 i2c_config_t i2c_config = {0};
677 jpeg_config_t jpeg_config = {0};
678
679 BK_ASSERT(config->frame_alloc != NULL);
680 BK_ASSERT(config->frame_complete != NULL);
681
682 #if (CONFIG_PSRAM)
683 bk_psram_init();
684 #endif
685
686 if (dvp_camera_device == NULL)
687 {
688 dvp_camera_device = (dvp_camera_device_t *)os_malloc(sizeof(dvp_camera_device_t));
689
690 if (dvp_camera_device == NULL)
691 {
692 LOGE("dvp_camera_device malloc failed\n");
693 goto error;
694 }
695
696 os_memset(dvp_camera_device, 0, sizeof(dvp_camera_device_t));
697 }
698
699 dvp_camera_device->mode = config->mode;
700
701 os_memcpy(&dvp_camera_config, config, sizeof(dvp_camera_config_t));
702
703 bk_dvp_camera_gpio_init(&dvp_camera_config, 1);
704
705
706 ret = bk_jpeg_enc_driver_init();
707
708 if (ret != BK_OK)
709 {
710 LOGE("jpeg encode driver init failed\n");
711 goto error;
712 }
713
714 bk_jpeg_enc_mclk_enable();
715
716 rtos_delay_milliseconds(5);
717
718 if (config->mode == DVP_MODE_JPG)
719 {
720 jpeg_config.yuv_mode = 0;
721 }
722 else if (config->mode == DVP_MODE_YUV)
723 {
724 jpeg_config.yuv_mode = 1;
725 }
726
727 i2c_config.baud_rate = CAMERA_DVP_I2C_BAUD_RATE;
728 i2c_config.addr_mode = CAMERA_DVP_I2C_MODE;
729 bk_i2c_init(CAMERA_DVP_I2C_ID, &i2c_config);
730
731 current_sensor = get_sensor_auto_detect(&dvp_camera_i2c_cb);
732
733 if (current_sensor == NULL)
734 {
735 LOGE("%s no dvp camera found\n", __func__);
736 ret = kGenericErrorBase;
737 goto error;
738 }
739
740 dvp_camera_device->ppi = current_sensor->def_ppi;
741 dvp_camera_device->fps = current_sensor->def_fps;
742 dvp_camera_device->name = current_sensor->name;
743 dvp_camera_device->id = current_sensor->id;
744 dvp_camera_device->fps_cap = current_sensor->fps_cap;
745 dvp_camera_device->ppi_cap = current_sensor->ppi_cap;
746
747 if ((config->ppi != dvp_camera_device->ppi)
748 && (pixel_ppi_to_cap(config->ppi) & (dvp_camera_device->ppi_cap)))
749 {
750 dvp_camera_device->ppi = config->ppi;
751 LOGI("%s switch ppi to %dX%d\n", __func__, config->ppi >> 16, config->ppi & 0xFFFF);
752 }
753
754 dvp_camera_device->pixel_size = get_ppi_size(dvp_camera_device->ppi);
755
756 LOGI("Pixel size: %d\n", dvp_camera_device->pixel_size);
757
758 if (config->mode == DVP_MODE_JPG)
759 {
760 config->frame_set_ppi(dvp_camera_device->ppi, FRAME_JPEG);
761
762 if (dvp_camera_drv == NULL)
763 {
764 dvp_camera_drv = (dvp_camera_drv_t *)os_malloc(sizeof(dvp_camera_drv_t));
765
766 if (dvp_camera_drv == NULL)
767 {
768 LOGE("dvp_camera_drv malloc failed\n");
769 goto error;
770 }
771
772 os_memset(dvp_camera_drv, 0, sizeof(dvp_camera_drv_t));
773
774 dvp_camera_drv->cached = true;
775 }
776
777 if (dvp_camera_drv->cached)
778 {
779 dvp_camera_drv->buffer = (uint8 *)os_malloc(FRAME_BUFFER_CACHE * 2);
780 os_memset(dvp_camera_drv->buffer, 0, FRAME_BUFFER_CACHE * 2);
781
782 if (dvp_camera_drv->buffer == NULL)
783 {
784 LOGE("dvp_camera_drv malloc failed\n");
785 goto error;
786 }
787
788 dvp_camera_drv->psram_dma = bk_dma_alloc(DMA_DEV_JPEG);
789 if ((dvp_camera_drv->psram_dma < DMA_ID_0) || (dvp_camera_drv->psram_dma >= DMA_ID_MAX))
790 {
791 LOGE("malloc dvp_camera_drv->psram_dma fail \r\n");
792 ret = BK_FAIL;
793 goto error;
794 }
795
796 }
797
798 ret = dvp_camera_dma_config();
799
800 if (ret != BK_OK)
801 {
802 LOGE("dma init failed\n");
803 goto error;
804 }
805 }
806
807 jpeg_config.x_pixel = ppi_to_pixel_x(dvp_camera_device->ppi) / 8;
808 jpeg_config.y_pixel = ppi_to_pixel_y(dvp_camera_device->ppi) / 8;
809
810 switch (current_sensor->clk)
811 {
812 case JPEG_96M_MCLK_16M:
813 jpeg_config.sys_clk_div = 4;
814 jpeg_config.mclk_div = 1;
815 break;
816
817 case JPEG_96M_MCLK_24M:
818 jpeg_config.sys_clk_div = 4;
819 jpeg_config.mclk_div = 0;
820 break;
821
822 case JPEG_120M_MCLK_30M:
823 jpeg_config.sys_clk_div = 3;
824 jpeg_config.mclk_div = 0;
825 break;
826
827 default:
828 break;
829 }
830
831
832 ret = bk_jpeg_enc_dvp_init(&jpeg_config);
833 if (ret != BK_OK)
834 {
835 LOGE("jpeg init error\n");
836 goto error;
837 }
838
839 if (config->mode == DVP_MODE_JPG)
840 {
841 bk_jpeg_enc_register_isr(END_OF_FRAME, dvp_camera_eof_handler, NULL);
842 }
843 else if (config->mode == DVP_MODE_YUV)
844 {
845 config->frame_set_ppi(dvp_camera_device->ppi, FRAME_DISPLAY);
846
847 curr_frame_buffer = dvp_camera_config.frame_alloc();
848
849 if (curr_frame_buffer == NULL)
850 {
851 LOGE("malloc frame fail \r\n");
852 ret = BK_FAIL;
853 goto error;
854 }
855
856 bk_jpeg_enc_register_isr(END_OF_YUV, dvp_camera_yuv_eof_handler, NULL);
857 bk_jpeg_set_em_base_addr(curr_frame_buffer->frame);
858 }
859
860
861 current_sensor->init(&dvp_camera_i2c_cb);
862 bk_dvp_camera_gpio_init(&dvp_camera_config, 2);
863 current_sensor->set_fps(&dvp_camera_i2c_cb, dvp_camera_device->fps);
864 current_sensor->set_ppi(&dvp_camera_i2c_cb, dvp_camera_device->ppi);
865
866 media_debug->isr_jpeg = 0;
867
868 LOGI("dvp camera init complete with mode: %d\n", config->mode);
869
870 return ret;
871
872 error:
873
874 if (dvp_camera_drv != NULL)
875 {
876 if (dvp_camera_drv->buffer != NULL)
877 {
878 os_free(dvp_camera_drv->buffer);
879 dvp_camera_drv->buffer = NULL;
880 }
881
882 os_free(dvp_camera_drv);
883 dvp_camera_drv = NULL;
884 }
885
886 if (dvp_camera_device)
887 {
888 os_free(dvp_camera_device);
889 dvp_camera_device = NULL;
890 }
891
892 LOGI("dvp camera init failed\n");
893
894 return ret;
895 }
896
897
bk_dvp_camera_get_device(void)898 dvp_camera_device_t *bk_dvp_camera_get_device(void)
899 {
900 return dvp_camera_device;
901 }
902
bk_dvp_camera_driver_deinit(void)903 bk_err_t bk_dvp_camera_driver_deinit(void)
904 {
905 int ret = rtos_init_semaphore(&dvp_sema, 1);
906 if(ret != kNoErr){
907 LOGE("jpeg sema not init ok\r\n");
908 return ret;
909 }
910
911 ret = rtos_get_semaphore(&dvp_sema, 10000);
912 if (ret != kNoErr)
913 {
914 LOGI("Not wait jpeg eof!\r\n");
915 }
916
917 bk_jpeg_enc_dvp_deinit();
918
919 bk_dma_stop(dvp_camera_dma_channel);
920 bk_dma_deinit(dvp_camera_dma_channel);
921 bk_dma_free(DMA_DEV_JPEG, dvp_camera_dma_channel);
922
923 if (dvp_camera_drv)
924 {
925 bk_dma_stop(dvp_camera_drv->psram_dma);
926 bk_dma_deinit(dvp_camera_drv->psram_dma);
927 bk_dma_free(DMA_DEV_JPEG, dvp_camera_drv->psram_dma);
928 os_free(dvp_camera_drv->buffer);
929 os_free(dvp_camera_drv);
930 dvp_camera_drv = NULL;
931 }
932
933 bk_i2c_deinit(CAMERA_DVP_I2C_ID);
934
935 #if CONFIG_SOC_BK7256XX
936 bk_jpeg_enc_driver_deinit();
937 #endif
938
939 if (dvp_camera_device)
940 {
941 os_free(dvp_camera_device);
942 dvp_camera_device = NULL;
943 }
944
945 current_sensor = NULL;
946 os_memset(&dvp_camera_config, 0, sizeof(dvp_camera_config_t));
947 dvp_camera_dma_channel = 0;
948 curr_frame_buffer = NULL;
949
950 rtos_deinit_semaphore(&dvp_sema);
951 dvp_sema = NULL;
952
953 LOGI("dvp camera deinit complete\n");
954 return kNoErr;
955 }
956
bk_dvp_camera_encode_config(uint8_t auto_ctrl,uint32_t up_size,uint32_t low_size)957 bk_err_t bk_dvp_camera_encode_config(uint8_t auto_ctrl, uint32_t up_size, uint32_t low_size)
958 {
959 dvp_camera_encode.enable_set = 1;
960
961 dvp_camera_encode.auto_encode = auto_ctrl;
962
963 if (dvp_camera_encode.auto_encode)
964 {
965 if (up_size > low_size)
966 {
967 dvp_camera_encode.up = up_size;
968 dvp_camera_encode.low = low_size;
969 }
970 }
971
972 return kNoErr;
973 }
974
975