1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2022 Rockchip Electronics Co., Ltd */
3
4 #define pr_fmt(fmt) "isp_rockit: %s:%d " fmt, __func__, __LINE__
5
6 #include <linux/of.h>
7 #include <linux/of_platform.h>
8 #include <soc/rockchip/rockchip_rockit.h>
9
10 #include "dev.h"
11 #include "capture.h"
12 #include "regs.h"
13
14 static struct rockit_cfg *rockit_cfg;
15
16 struct rkisp_rockit_buffer {
17 struct rkisp_buffer isp_buf;
18 struct dma_buf *dmabuf;
19 void *mpi_mem;
20 void *mpi_buf;
21 struct list_head queue;
22 int buf_id;
23 union {
24 u32 buff_addr;
25 void *vaddr;
26 };
27 };
28
rkisp_rockit_get_stream(struct rockit_cfg * input_rockit_cfg)29 static struct rkisp_stream *rkisp_rockit_get_stream(struct rockit_cfg *input_rockit_cfg)
30 {
31 struct rkisp_device *ispdev = NULL;
32 struct rkisp_stream *stream = NULL;
33 u8 i;
34
35 if (!rockit_cfg) {
36 pr_err("rockit_cfg is null get stream failed\n");
37 return NULL;
38 }
39 if (!input_rockit_cfg) {
40 pr_err("input is null get stream failed\n");
41 return NULL;
42 }
43
44 for (i = 0; i < rockit_cfg->isp_num; i++) {
45 if (!strcmp(rockit_cfg->rkisp_dev_cfg[i].isp_name,
46 input_rockit_cfg->current_name)) {
47 ispdev = rockit_cfg->rkisp_dev_cfg[i].isp_dev;
48 break;
49 }
50 }
51
52 if (ispdev == NULL) {
53 pr_err("Can not find ispdev!");
54 return NULL;
55 }
56
57 switch (input_rockit_cfg->nick_id) {
58 case 0:
59 stream = &ispdev->cap_dev.stream[RKISP_STREAM_MP];
60 break;
61 case 1:
62 stream = &ispdev->cap_dev.stream[RKISP_STREAM_SP];
63 break;
64 case 2:
65 stream = &ispdev->cap_dev.stream[RKISP_STREAM_BP];
66 break;
67 case 3:
68 stream = &ispdev->cap_dev.stream[RKISP_STREAM_MPDS];
69 break;
70 case 4:
71 stream = &ispdev->cap_dev.stream[RKISP_STREAM_BPDS];
72 break;
73 case 5:
74 stream = &ispdev->cap_dev.stream[RKISP_STREAM_LUMA];
75 break;
76 default:
77 stream = NULL;
78 break;
79 }
80
81 return stream;
82 }
83
rkisp_rockit_buf_queue(struct rockit_cfg * input_rockit_cfg)84 int rkisp_rockit_buf_queue(struct rockit_cfg *input_rockit_cfg)
85 {
86 struct rkisp_stream *stream = NULL;
87 struct rkisp_rockit_buffer *isprk_buf = NULL;
88 struct rkisp_device *ispdev = NULL;
89 const struct vb2_mem_ops *g_ops = NULL;
90 int i, ret, height, offset, dev_id;
91 struct rkisp_stream_cfg *stream_cfg = NULL;
92 void *mem = NULL;
93 struct sg_table *sg_tbl;
94 unsigned long lock_flags = 0;
95
96 if (!input_rockit_cfg)
97 return -EINVAL;
98
99 stream = rkisp_rockit_get_stream(input_rockit_cfg);
100 if (!stream || stream->id >= ROCKIT_STREAM_NUM_MAX) {
101 pr_err("inval stream");
102 return -EINVAL;
103 }
104
105 dev_id = stream->ispdev->dev_id;
106 ispdev = stream->ispdev;
107 g_ops = ispdev->hw_dev->mem_ops;
108
109 stream_cfg = &rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[stream->id];
110 stream_cfg->node = input_rockit_cfg->node;
111 /* invalid dmabuf for wrap mode */
112 if (!input_rockit_cfg->buf)
113 return -EINVAL;
114
115 for (i = 0; i < ROCKIT_BUF_NUM_MAX; i++) {
116 if (stream_cfg->buff_id[i] == input_rockit_cfg->mpi_id) {
117 input_rockit_cfg->is_alloc = 0;
118 break;
119 }
120 }
121
122 if (input_rockit_cfg->is_alloc) {
123 for (i = 0; i < ROCKIT_BUF_NUM_MAX; i++) {
124 if (!stream_cfg->buff_id[i] && !stream_cfg->rkisp_buff[i]) {
125 stream_cfg->buff_id[i] = input_rockit_cfg->mpi_id;
126 isprk_buf = kzalloc(sizeof(struct rkisp_rockit_buffer), GFP_KERNEL);
127 if (!isprk_buf) {
128 stream_cfg->buff_id[i] = 0;
129 pr_err("rkisp_buff alloc failed!\n");
130 return -ENOMEM;
131 }
132 break;
133 }
134 }
135 if (i == ROCKIT_BUF_NUM_MAX)
136 return -EINVAL;
137
138 mem = g_ops->attach_dmabuf(stream->ispdev->hw_dev->dev,
139 input_rockit_cfg->buf,
140 input_rockit_cfg->buf->size,
141 DMA_BIDIRECTIONAL);
142 if (IS_ERR(mem)) {
143 kfree(isprk_buf);
144 stream_cfg->buff_id[i] = 0;
145 return PTR_ERR(mem);
146 }
147
148 ret = g_ops->map_dmabuf(mem);
149 if (ret) {
150 g_ops->detach_dmabuf(mem);
151 kfree(isprk_buf);
152 stream_cfg->buff_id[i] = 0;
153 return ret;
154 }
155 if (ispdev->hw_dev->is_dma_sg_ops) {
156 sg_tbl = (struct sg_table *)g_ops->cookie(mem);
157 isprk_buf->buff_addr = sg_dma_address(sg_tbl->sgl);
158 } else {
159 isprk_buf->buff_addr = *((u32 *)g_ops->cookie(mem));
160 }
161 get_dma_buf(input_rockit_cfg->buf);
162
163 isprk_buf->mpi_mem = mem;
164 isprk_buf->dmabuf = input_rockit_cfg->buf;
165 isprk_buf->mpi_buf = input_rockit_cfg->mpibuf;
166 stream_cfg->rkisp_buff[i] = isprk_buf;
167
168 for (i = 0; i < stream->out_isp_fmt.mplanes; i++)
169 isprk_buf->isp_buf.buff_addr[i] = isprk_buf->buff_addr;
170 }
171
172 if (stream_cfg->is_discard && stream->streaming)
173 return -EINVAL;
174
175 spin_lock_irqsave(&stream->vbq_lock, lock_flags);
176 isprk_buf = NULL;
177 for (i = 0; i < ROCKIT_BUF_NUM_MAX; i++) {
178 if (stream_cfg->buff_id[i] == input_rockit_cfg->mpi_id) {
179 isprk_buf = stream_cfg->rkisp_buff[i];
180 break;
181 }
182 }
183
184 if (!isprk_buf) {
185 spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
186 return -EINVAL;
187 }
188
189 if (stream->out_isp_fmt.mplanes == 1) {
190 for (i = 0; i < stream->out_isp_fmt.cplanes - 1; i++) {
191 height = stream->out_fmt.height;
192 offset = (i == 0) ?
193 stream->out_fmt.plane_fmt[i].bytesperline * height :
194 stream->out_fmt.plane_fmt[i].sizeimage;
195 isprk_buf->isp_buf.buff_addr[i + 1] =
196 isprk_buf->isp_buf.buff_addr[i] + offset;
197 }
198 }
199
200 v4l2_dbg(2, rkisp_debug, &ispdev->v4l2_dev,
201 "stream:%d rockit_queue buf:%p y:0x%x uv:0x%x\n",
202 stream->id, isprk_buf,
203 isprk_buf->isp_buf.buff_addr[0], isprk_buf->isp_buf.buff_addr[1]);
204
205 /* single sensor with pingpong buf, update next if need */
206 if (stream->ispdev->hw_dev->is_single &&
207 stream->id != RKISP_STREAM_VIR &&
208 stream->id != RKISP_STREAM_LUMA &&
209 stream->streaming && !stream->next_buf) {
210 stream->next_buf = &isprk_buf->isp_buf;
211 stream->ops->update_mi(stream);
212 } else {
213 list_add_tail(&isprk_buf->isp_buf.queue, &stream->buf_queue);
214 }
215 spin_unlock_irqrestore(&stream->vbq_lock, lock_flags);
216
217 return 0;
218 }
219
rkisp_rockit_buf_done(struct rkisp_stream * stream,int cmd)220 int rkisp_rockit_buf_done(struct rkisp_stream *stream, int cmd)
221 {
222 struct rkisp_device *dev = stream->ispdev;
223 struct rkisp_rockit_buffer *isprk_buf = NULL;
224 struct rkisp_stream_cfg *stream_cfg = NULL;
225 u32 seq, dev_id = stream->ispdev->dev_id;
226 u64 ns = 0;
227
228 if (!rockit_cfg ||
229 !rockit_cfg->rkisp_rockit_mpibuf_done ||
230 stream->id >= ROCKIT_STREAM_NUM_MAX)
231 return -EINVAL;
232
233 stream_cfg = &rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[stream->id];
234 if (cmd == ROCKIT_DVBM_END) {
235 isprk_buf =
236 container_of(stream->curr_buf, struct rkisp_rockit_buffer, isp_buf);
237
238 rockit_cfg->mpibuf = isprk_buf->mpi_buf;
239
240 rockit_cfg->frame.u64PTS = stream->curr_buf->vb.vb2_buf.timestamp;
241
242 rockit_cfg->frame.u32TimeRef = stream->curr_buf->vb.sequence;
243 } else {
244 if (stream->ispdev->cap_dev.wrap_line &&
245 stream->id == RKISP_STREAM_MP) {
246 if (stream_cfg->is_discard || stream->ops->is_stream_stopped(stream))
247 return 0;
248 } else if (stream_cfg->dst_fps) {
249 if (!stream_cfg->is_discard && !stream->curr_buf) {
250 rockit_cfg->is_qbuf = true;
251 } else {
252 rockit_cfg->is_qbuf = false;
253 return 0;
254 }
255 } else {
256 return 0;
257 }
258
259 rkisp_dmarx_get_frame(stream->ispdev, &seq, NULL, &ns, true);
260
261 if (!ns)
262 ns = ktime_get_ns();
263
264 rockit_cfg->frame.u64PTS = ns;
265
266 rockit_cfg->frame.u32TimeRef = seq;
267 }
268
269 rockit_cfg->is_color = !rkisp_read(dev, ISP3X_IMG_EFF_CTRL, true);
270
271 rockit_cfg->frame.u32Height = stream->out_fmt.height;
272
273 rockit_cfg->frame.u32Width = stream->out_fmt.width;
274
275 rockit_cfg->frame.enPixelFormat = stream->out_fmt.pixelformat;
276
277 rockit_cfg->frame.u32VirWidth = stream->out_fmt.width;
278
279 rockit_cfg->frame.u32VirHeight = stream->out_fmt.height;
280
281 rockit_cfg->current_name = dev->name;
282
283 rockit_cfg->node = stream_cfg->node;
284
285 rockit_cfg->event = cmd;
286
287 if (list_empty(&stream->buf_queue))
288 rockit_cfg->is_empty = true;
289 else
290 rockit_cfg->is_empty = false;
291
292 if (rockit_cfg->rkisp_rockit_mpibuf_done)
293 rockit_cfg->rkisp_rockit_mpibuf_done(rockit_cfg);
294
295 return 0;
296 }
297
rkisp_rockit_pause_stream(struct rockit_cfg * input_rockit_cfg)298 int rkisp_rockit_pause_stream(struct rockit_cfg *input_rockit_cfg)
299 {
300 struct rkisp_stream *stream = NULL;
301
302 stream = rkisp_rockit_get_stream(input_rockit_cfg);
303
304 if (stream == NULL) {
305 pr_err("the stream is NULL");
306 return -EINVAL;
307 }
308
309 rockit_isp_ops.rkisp_stream_stop(stream);
310
311 return 0;
312 }
313 EXPORT_SYMBOL(rkisp_rockit_pause_stream);
314
rkisp_rockit_config_stream(struct rockit_cfg * input_rockit_cfg,int width,int height,int wrap_line)315 int rkisp_rockit_config_stream(struct rockit_cfg *input_rockit_cfg,
316 int width, int height, int wrap_line)
317 {
318 struct rkisp_stream *stream = NULL;
319 struct rkisp_buffer *isp_buf;
320 int offset, i, ret;
321
322 stream = rkisp_rockit_get_stream(input_rockit_cfg);
323
324 if (stream == NULL) {
325 pr_err("the stream is NULL");
326 return -EINVAL;
327 }
328 stream->ispdev->cap_dev.wrap_line = wrap_line;
329 stream->out_fmt.width = width;
330 stream->out_fmt.height = height;
331 stream->out_fmt.plane_fmt[0].bytesperline = 0;
332 ret = rockit_isp_ops.rkisp_set_fmt(stream, &stream->out_fmt, false);
333 if (ret < 0) {
334 pr_err("stream id %d config failed\n", stream->id);
335 return -EINVAL;
336 }
337 if (stream->ispdev->cap_dev.wrap_line && stream->id == RKISP_STREAM_MP)
338 rkisp_dvbm_init(stream);
339
340 if (stream->curr_buf) {
341 list_add_tail(&stream->curr_buf->queue, &stream->buf_queue);
342 stream->curr_buf = NULL;
343 }
344 if (stream->next_buf) {
345 list_add_tail(&stream->next_buf->queue, &stream->buf_queue);
346 stream->next_buf = NULL;
347 }
348
349 list_for_each_entry(isp_buf, &stream->buf_queue, queue) {
350 if (stream->out_isp_fmt.mplanes == 1) {
351 for (i = 0; i < stream->out_isp_fmt.cplanes - 1; i++) {
352 height = stream->out_fmt.height;
353 offset = (i == 0) ?
354 stream->out_fmt.plane_fmt[i].bytesperline * height :
355 stream->out_fmt.plane_fmt[i].sizeimage;
356 isp_buf->buff_addr[i + 1] =
357 isp_buf->buff_addr[i] + offset;
358 }
359 }
360 }
361
362 return 0;
363 }
364 EXPORT_SYMBOL(rkisp_rockit_config_stream);
365
rkisp_rockit_resume_stream(struct rockit_cfg * input_rockit_cfg)366 int rkisp_rockit_resume_stream(struct rockit_cfg *input_rockit_cfg)
367 {
368 struct rkisp_stream *stream = NULL;
369 int ret = 0;
370
371 stream = rkisp_rockit_get_stream(input_rockit_cfg);
372
373 if (stream == NULL) {
374 pr_err("the stream is NULL");
375 return -EINVAL;
376 }
377
378 stream->streaming = true;
379 ret = rockit_isp_ops.rkisp_stream_start(stream);
380 if (ret < 0) {
381 pr_err("stream id %d start failed\n", stream->id);
382 return -EINVAL;
383 }
384 if (stream->ispdev->isp_state == ISP_STOP) {
385 stream->ispdev->isp_state = ISP_START;
386 rkisp_rdbk_trigger_event(stream->ispdev, T_CMD_QUEUE, NULL);
387 }
388
389 return 0;
390 }
391 EXPORT_SYMBOL(rkisp_rockit_resume_stream);
392
rkisp_rockit_get_tb_stream_info(struct rockit_cfg * input_rockit_cfg,struct rkisp_tb_stream_info * info)393 int rkisp_rockit_get_tb_stream_info(struct rockit_cfg *input_rockit_cfg,
394 struct rkisp_tb_stream_info *info)
395 {
396 struct rkisp_stream *stream;
397
398 if (!input_rockit_cfg || !info)
399 return -EINVAL;
400
401 stream = rkisp_rockit_get_stream(input_rockit_cfg);
402 if (!stream)
403 return -EINVAL;
404 if (info->buf[0].timestamp)
405 stream->is_using_resmem = false;
406 return rkisp_get_tb_stream_info(stream, info);
407 }
408 EXPORT_SYMBOL(rkisp_rockit_get_tb_stream_info);
409
rkisp_rockit_free_tb_stream_buf(struct rockit_cfg * input_rockit_cfg)410 int rkisp_rockit_free_tb_stream_buf(struct rockit_cfg *input_rockit_cfg)
411 {
412 struct rkisp_stream *stream;
413
414 if (!input_rockit_cfg)
415 return -EINVAL;
416 stream = rkisp_rockit_get_stream(input_rockit_cfg);
417 if (!stream)
418 return -EINVAL;
419
420 return rkisp_free_tb_stream_buf(stream);
421 }
422 EXPORT_SYMBOL(rkisp_rockit_free_tb_stream_buf);
423
rkisp_rockit_buf_state_clear(struct rkisp_stream * stream)424 void rkisp_rockit_buf_state_clear(struct rkisp_stream *stream)
425 {
426 struct rkisp_stream_cfg *stream_cfg;
427 u32 i = 0, dev_id = stream->ispdev->dev_id;
428
429 if (!rockit_cfg || stream->id >= ROCKIT_STREAM_NUM_MAX)
430 return;
431
432 stream_cfg = &rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[stream->id];
433 stream_cfg->is_discard = false;
434 for (i = 0; i < ROCKIT_BUF_NUM_MAX; i++)
435 stream_cfg->buff_id[i] = 0;
436 }
437
rkisp_rockit_buf_free(struct rkisp_stream * stream)438 int rkisp_rockit_buf_free(struct rkisp_stream *stream)
439 {
440 const struct vb2_mem_ops *g_ops = stream->ispdev->hw_dev->mem_ops;
441 struct rkisp_rockit_buffer *isprk_buf;
442 struct rkisp_stream_cfg *stream_cfg;
443 u32 i = 0, dev_id = stream->ispdev->dev_id;
444
445 if (!rockit_cfg || stream->id >= ROCKIT_STREAM_NUM_MAX)
446 return -EINVAL;
447
448 stream_cfg = &rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[stream->id];
449 for (i = 0; i < ROCKIT_BUF_NUM_MAX; i++) {
450 if (stream_cfg->rkisp_buff[i]) {
451 isprk_buf = (struct rkisp_rockit_buffer *)stream_cfg->rkisp_buff[i];
452 if (isprk_buf->mpi_mem) {
453 g_ops->unmap_dmabuf(isprk_buf->mpi_mem);
454 g_ops->detach_dmabuf(isprk_buf->mpi_mem);
455 dma_buf_put(isprk_buf->dmabuf);
456 }
457 kfree(stream_cfg->rkisp_buff[i]);
458 stream_cfg->rkisp_buff[i] = NULL;
459 }
460 }
461 return 0;
462 }
463
rkisp_rockit_dev_init(struct rkisp_device * dev)464 void rkisp_rockit_dev_init(struct rkisp_device *dev)
465 {
466 int i;
467
468 if (rockit_cfg == NULL) {
469 rockit_cfg = kzalloc(sizeof(struct rockit_cfg), GFP_KERNEL);
470 if (rockit_cfg == NULL)
471 return;
472 }
473 rockit_cfg->isp_num = dev->hw_dev->dev_num;
474 for (i = 0; i < rockit_cfg->isp_num; i++) {
475 if (dev->hw_dev->isp[i]) {
476 rockit_cfg->rkisp_dev_cfg[i].isp_name =
477 dev->hw_dev->isp[i]->name;
478 rockit_cfg->rkisp_dev_cfg[i].isp_dev =
479 dev->hw_dev->isp[i];
480 }
481 }
482 }
483
rkisp_rockit_dev_deinit(void)484 void rkisp_rockit_dev_deinit(void)
485 {
486 if (rockit_cfg) {
487 kfree(rockit_cfg);
488 rockit_cfg = NULL;
489 }
490 }
491
rkisp_rockit_fps_set(int * dst_fps,struct rkisp_stream * stream)492 int rkisp_rockit_fps_set(int *dst_fps, struct rkisp_stream *stream)
493 {
494 int dev_id = stream->ispdev->dev_id;
495 int id = stream->id;
496
497 if (stream->id >= ROCKIT_STREAM_NUM_MAX) {
498 pr_err("fps_set stream id %u exceeds maximum\n", id);
499 return -EINVAL;
500 }
501
502 if (dst_fps == NULL) {
503 pr_err("fps_set dst_fps is null\n");
504 return -EINVAL;
505 }
506
507 if (!rockit_cfg)
508 return -EINVAL;
509
510 rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[id].dst_fps = *dst_fps;
511 rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[id].fps_cnt = *dst_fps;
512 return 0;
513 }
514
rkisp_rockit_fps_get(int * dst_fps,struct rkisp_stream * stream)515 int rkisp_rockit_fps_get(int *dst_fps, struct rkisp_stream *stream)
516 {
517 int dev_id = stream->ispdev->dev_id;
518 int id = stream->id;
519
520 if (id >= ROCKIT_STREAM_NUM_MAX) {
521 pr_err("fps_get stream id %u exceeds maximum\n", id);
522 return -EINVAL;
523 }
524
525 if (dst_fps == NULL) {
526 pr_err("fps_get dst_fps is null\n");
527 return -EINVAL;
528 }
529
530 if (!rockit_cfg)
531 return -EINVAL;
532
533 *dst_fps = rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[id].cur_fps;
534 return 0;
535 }
536
rkisp_rockit_ctrl_fps(struct rkisp_stream * stream)537 bool rkisp_rockit_ctrl_fps(struct rkisp_stream *stream)
538 {
539 struct rkisp_device *dev = stream->ispdev;
540 struct rkisp_sensor_info *sensor = NULL;
541 int dev_id = stream->ispdev->dev_id, id = stream->id;
542 struct rkisp_stream_cfg *stream_cfg;
543 int ret, dst_fps, *fps_cnt;
544 static int fps_in, cur_fps[ROCKIT_STREAM_NUM_MAX];
545 u32 denominator = 0, numerator = 0;
546 bool *is_discard;
547 u64 cur_time, *old_time;
548
549 if (!rockit_cfg || stream->id >= ROCKIT_STREAM_NUM_MAX)
550 return false;
551 stream_cfg = &rockit_cfg->rkisp_dev_cfg[dev_id].rkisp_stream_cfg[id];
552 fps_cnt = &stream_cfg->fps_cnt;
553 is_discard = &stream_cfg->is_discard;
554 old_time = &stream_cfg->old_time;
555 dst_fps = stream_cfg->dst_fps;
556 if (dst_fps == 0 || !stream->streaming) {
557 *is_discard = false;
558 return false;
559 }
560
561 if (dev->active_sensor == NULL) {
562 *is_discard = false;
563 pr_err("the sensor is not found\n");
564 return false;
565 }
566
567 sensor = dev->active_sensor;
568
569 ret = v4l2_subdev_call(sensor->sd, video, g_frame_interval, &sensor->fi);
570 if (!ret) {
571 denominator = sensor->fi.interval.denominator;
572 numerator = sensor->fi.interval.numerator;
573 if (numerator)
574 fps_in = denominator / numerator;
575 else {
576 *is_discard = false;
577 pr_err("the numerator is 0\n");
578 return false;
579 }
580 }
581
582 if (dst_fps >= fps_in) {
583 /* avoid from small frame rate to big frame rate lead to all buf is discard issue */
584 *is_discard = false;
585 stream_cfg->dst_fps = fps_in;
586 return false;
587 }
588
589 if ((fps_in > 0) && (dst_fps > 0)) {
590 if (*fps_cnt < 0)
591 *fps_cnt = fps_in - dst_fps;
592 *fps_cnt += dst_fps;
593
594 if (*fps_cnt < fps_in) {
595 *is_discard = true;
596 if (stream->next_buf || !list_empty(&stream->buf_queue))
597 stream->skip_frame = 1;
598 } else {
599 *fps_cnt -= fps_in;
600 *is_discard = false;
601 ++cur_fps[stream->id];
602 cur_time = ktime_get_ns();
603 if (cur_time - *old_time >= 1000000000) {
604 *old_time = cur_time;
605 stream_cfg->cur_fps = cur_fps[stream->id];
606 cur_fps[stream->id] = 0;
607 }
608 }
609 } else {
610 *is_discard = false;
611 }
612 return true;
613 }
614
rkisp_rockit_function_register(void * function,int cmd)615 void *rkisp_rockit_function_register(void *function, int cmd)
616 {
617 if (rockit_cfg == NULL) {
618 pr_err("rockit_cfg is null function register failed");
619 return NULL;
620 }
621
622 switch (cmd) {
623 case ROCKIT_BUF_QUE:
624 function = rkisp_rockit_buf_queue;
625 break;
626 case ROCKIT_MPIBUF_DONE:
627 rockit_cfg->rkisp_rockit_mpibuf_done = function;
628 if (!rockit_cfg->rkisp_rockit_mpibuf_done)
629 pr_err("get rkisp_rockit_buf_queue failed!");
630 break;
631 default:
632 break;
633 }
634 return function;
635 }
636 EXPORT_SYMBOL(rkisp_rockit_function_register);
637
rkisp_rockit_get_ispdev(char ** name)638 int rkisp_rockit_get_ispdev(char **name)
639 {
640 int i = 0;
641
642 if (rockit_cfg == NULL) {
643 pr_err("rockit_cfg is null");
644 return -EINVAL;
645 }
646
647 if (name == NULL) {
648 pr_err("the name is null");
649 return -EINVAL;
650 }
651
652 for (i = 0; i < rockit_cfg->isp_num; i++)
653 name[i] = rockit_cfg->rkisp_dev_cfg[i].isp_name;
654 if (name[0] == NULL)
655 return -EINVAL;
656 else
657 return 0;
658 }
659 EXPORT_SYMBOL(rkisp_rockit_get_ispdev);
660