1:
13:
14:
18:
19:
20:
#include <stdio.h>
21:
#include "pgpmgr_common.h"
22:
#include "pgp/pgpprm.h"
23:
#include "via/viamgr.h"
24:
#include "vid/vidmgr.h"
25:
26:
34:
false, 0,
35: 0, {{0}},
36: 0, {{0}},
37: 0, {{0}},
38: 0, {{0}},
39: {NULL}, {NULL}, {NULL}, {NULL},
40: {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL},
41: {0},
42: };
43:
44:
50: PgpMgrContext *PgpGetContext(
void)
51: {
52:
return &PgpContext;
53: }
54:
55:
56:
57:
#define CSC_MUL_MASK 0xFFF
58:
#define CSC_ADD_MASK 0xFFFFF
59:
60:
#define SPF1_COEFF_MASK 0xFF
61:
#define SPF1_OFFSET_MASK 0x1FF
62:
63:
#define THR_MSK_L_MASK 0x1
64:
#define THR_MSK_H_MASK 0x1
65:
#define THR_MSK_X_MASK 0x1
66:
#define THR_MSK_HMAX_MASK 0xFF
67:
#define THR_MSK_HMIN_MASK 0xFF
68:
#define THR_MSK_LMAX_MASK 0xFF
69:
#define THR_MSK_LMIN_MASK 0xFF
70:
71:
#define THR_8THR_MAXV_MASK 0xFF
72:
#define THR_8THR_MAXTH_MASK 0xFF
73:
#define THR_8THR_MINTH_MASK 0xFF
74:
75:
#define THR_SPF1_COEFF_MASK 0x1
76:
#define THR_SPF1_THR_MASK 0x3F
77:
78:
#define IFC_GAIN_MASK 0xFF
79:
80:
#ifndef AG903_PGP_MGR_TS_FORCE_DISABLE
81:
82:
93: int32_t
AG903_PgpMgrEnableTimeSharingPipeline(_Bool enable)
94: {
95:
if ((PgpContext.num_pipeline_handles != 0) ||
96: (PgpContext.num_vram_input_handles != 0) ||
97: (PgpContext.num_frame_calc_handles != 0) ||
98: (PgpContext.num_dgc_lut != 0)) {
99:
return -
AG903_EINVAL;
100: }
101:
102: PgpContext.pipeline_time_sharing_enable = enable;
103:
104:
return AG903_ENONE;
105: }
106:
#endif
107:
108:
109:
119: int32_t
AG903_PgpMgrGetPipelineHandle(int32_t num,
AG903_PgpMgrPipelineHandle **handles)
120: {
121:
int i, j;
122:
123:
124:
if (PgpContext.pipeline_time_sharing_enable ==
true) {
125:
if ((num + PgpContext.num_pipeline_handles) >
AG903_PGP_MGR_MAX_PIPELINE_HANDLE) {
126:
return -
AG903_EINVAL;
127: }
128: }
else {
129:
if ((num + PgpContext.num_pipeline_handles) >
AG903_PGP_MGR_PIPELINE_NUM) {
130:
return -
AG903_EINVAL;
131: }
132: }
133:
134:
if (handles == NULL) {
135:
return -
AG903_EINVAL;
136: }
137:
138:
139:
for (i = 0; i < num; i++) {
140:
for (j = 0; j <
AG903_PGP_MGR_MAX_PIPELINE_HANDLE; j++) {
141:
if (PgpContext.pipeline_handles[j].is_used ==
false) {
142:
143: PgpMgrInitPipelineHandle(&PgpContext.pipeline_handles[j]);
144:
145: PgpContext.pipeline_handles[j].is_used =
true;
146: PgpContext.pipeline_handles[j].id =
AG903_PGP_MGR_PIPELINE_HANDLE_ID;
147: handles[i] = &PgpContext.pipeline_handles[j];
148:
break;
149: }
150: }
151: }
152:
153:
154:
if (PgpContext.num_pipeline_handles == 0) {
155: PgpMgrSetIntr();
156: }
157: PgpContext.num_pipeline_handles += num;
158:
return AG903_ENONE;
159: }
160:
161:
162:
171: int32_t
AG903_PgpMgrReleasePipelineHandle(
AG903_PgpMgrPipelineHandle *handle)
172: {
173:
174:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
175:
return -
AG903_EINVAL;
176: }
177:
178:
if (handle->is_used_frame_calc ==
true) {
179:
return -
AG903_EINVAL;
180: }
181:
182:
183:
if (handle->pipeline_no != -1) {
184:
185:
if (PgpContext.exec_pipeline[handle->pipeline_no] == handle) {
186:
PGPPrmParamPGPnSTATE state;
187:
AG903_PgpPrmGetPGPnSTATE(handle->pipeline_no, &state);
188:
if (state.st !=
AG903_PGP_MGR_STATE_IDLE) {
189:
return -
AG903_EBUSY;
190: }
191: PgpContext.exec_pipeline[handle->pipeline_no] = NULL;
192: }
193:
if (PgpContext.assign_pipeline[handle->pipeline_no] == handle) {
194: PgpContext.assign_pipeline[handle->pipeline_no] = NULL;
195: }
196: }
197:
if (handle->input_handle != NULL) {
198:
AG903_PgpMgrVRAMInputHandle *vram_handle = (
AG903_PgpMgrVRAMInputHandle *)handle->input_handle;
199:
200:
if (vram_handle->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID) {
201: vram_handle->ref_cnt--;
202:
203:
if (PgpContext.pipeline_time_sharing_enable ==
false) {
204:
if ((vram_handle->ref_cnt == 0) && (vram_handle->port_no != -1)) {
205:
if (PgpContext.assign_vram[vram_handle->port_no] == vram_handle) {
206: PgpContext.assign_vram[vram_handle->port_no] = NULL;
207: }
208: }
209: }
210: }
211: }
212:
213:
if (handle->dgc_lut != NULL) {
214: handle->dgc_lut->ref_cnt--;
215: }
216: handle->is_used =
false;
217: handle->id = 0;
218: PgpContext.num_pipeline_handles--;
219:
220:
221:
if (PgpContext.num_pipeline_handles == 0) {
222: PgpMgrResetIntr();
223: }
224:
return AG903_ENONE;
225: }
226:
227:
228:
245: int32_t
AG903_PgpMgrAssignPipeline(
void *handle)
246: {
247: uint32_t id;
248:
249:
if (handle == NULL) {
250:
return -
AG903_EINVAL;
251: }
252:
253:
254: id = ((
AG903_PgpMgrPipelineHandle *)handle)->id;
255:
if ((id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) && (id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
256:
return -
AG903_EINVAL;
257: }
258:
259:
if (id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
260:
AG903_PgpMgrPipelineHandle *p = (
AG903_PgpMgrPipelineHandle *)handle;
261:
262:
if (p->is_assign ==
true) {
263:
return -
AG903_EINVAL;
264: }
265:
266:
if (p->input_handle == NULL) {
267:
return -
AG903_EINVAL;
268: }
269:
270:
return PgpMgrAssignPipelineHandle(p);
271: }
else {
272:
AG903_PgpMgrFrameCalcHandle *f = (
AG903_PgpMgrFrameCalcHandle *)handle;
273:
274:
if (f->master_handle->is_assign ==
true) {
275:
return -
AG903_EINVAL;
276: }
277:
278:
if (f->master_handle->input_handle == NULL) {
279:
return -
AG903_EINVAL;
280: }
281:
282:
if (f->slave_pipeline ==
true) {
283:
AG903_PgpMgrPipelineHandle *slave = (
AG903_PgpMgrPipelineHandle *)f->slave_handle;
284:
if (slave->input_handle == NULL) {
285:
return -
AG903_EINVAL;
286: }
287: }
288:
289:
return PgpMgrAssignFrameCalcHandle(f);
290: }
291: }
292:
293:
294:
306: int32_t
AG903_PgpMgrForceAssignPipeline(
void *handle, uint32_t pipeline)
307: {
308: uint32_t id;
309:
310:
if (handle == NULL) {
311:
return -
AG903_EINVAL;
312: }
313:
314: id = ((
AG903_PgpMgrPipelineHandle *)handle)->id;
315:
if ((id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) && (id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
316:
return -
AG903_EINVAL;
317: }
318:
switch (pipeline) {
319:
case AG903_PGP_MGR_CALC_PIPELINE0:
320:
case AG903_PGP_MGR_CALC_PIPELINE1:
321:
case AG903_PGP_MGR_INPUT_PIPELINE0:
322:
case AG903_PGP_MGR_INPUT_PIPELINE1:
323:
case AG903_PGP_MGR_FRAME_PIPELINE0:
324:
case AG903_PGP_MGR_FRAME_PIPELINE1:
325:
break;
326:
default:
327:
return -
AG903_EINVAL;
328: }
329:
330:
if (id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
331:
AG903_PgpMgrPipelineHandle *p = (
AG903_PgpMgrPipelineHandle *)handle;
332:
333:
if (p->is_assign ==
true) {
334:
return -
AG903_EINVAL;
335: }
336:
337:
if (p->input_handle == NULL) {
338:
return -
AG903_EINVAL;
339: }
340:
341:
if (p->is_used_frame_calc ==
true) {
342:
return -
AG903_EINVAL;
343: }
344:
345:
return PgpMgrForceAssignPipelineHandle(p, pipeline);
346: }
else {
347:
AG903_PgpMgrFrameCalcHandle *f = (
AG903_PgpMgrFrameCalcHandle *)handle;
348:
349:
if (f->master_handle->is_assign ==
true) {
350:
return -
AG903_EINVAL;
351: }
352:
353:
if (f->master_handle->input_handle == NULL) {
354:
return -
AG903_EINVAL;
355: }
356:
357:
if (f->slave_pipeline ==
true) {
358:
AG903_PgpMgrPipelineHandle *slave = (
AG903_PgpMgrPipelineHandle *)f->slave_handle;
359:
if (slave->input_handle == NULL) {
360:
return -
AG903_EINVAL;
361: }
362: }
363:
364:
return PgpMgrForceAssignFrameCalcHandle(f, pipeline);
365: }
366: }
367:
368:
369:
379: int32_t
AG903_PgpMgrReleaseAssignment(
void *handle)
380: {
381: uint32_t id;
382:
AG903_PgpMgrVRAMInputHandle *vram_handle;
383:
384:
if (handle == NULL) {
385:
return -
AG903_EINVAL;
386: }
387:
388: id = ((
AG903_PgpMgrPipelineHandle *)handle)->id;
389:
if ((id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) && (id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
390:
return -
AG903_EINVAL;
391: }
392:
393:
if (id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
394:
AG903_PgpMgrPipelineHandle *p = (
AG903_PgpMgrPipelineHandle *)handle;
395:
396:
if (p->is_assign ==
false) {
397:
return -
AG903_EINVAL;
398: }
399:
if (PgpContext.exec_pipeline[p->pipeline_no] == p) {
400:
401:
PGPPrmParamPGPnSTATE state;
402:
AG903_PgpPrmGetPGPnSTATE(p->pipeline_no, &state);
403:
if (state.st !=
AG903_PGP_MGR_STATE_IDLE) {
404:
return -
AG903_EBUSY;
405: }
406: PgpContext.exec_pipeline[p->pipeline_no] = NULL;
407: }
408:
409:
if (PgpContext.assign_pipeline[p->pipeline_no] == handle) {
410: PgpContext.assign_pipeline[p->pipeline_no] = NULL;
411: }
412:
413: vram_handle = (
AG903_PgpMgrVRAMInputHandle *)p->input_handle;
414:
if ((vram_handle != NULL) && (vram_handle->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
415: vram_handle->ref_cnt--;
416: }
417: p->is_assign =
false;
418: p->pipeline_no = -1;
419: p->input_handle = NULL;
420: }
else {
421:
AG903_PgpMgrFrameCalcHandle *f = (
AG903_PgpMgrFrameCalcHandle *)handle;
422:
AG903_PgpMgrPipelineHandle *master = (
AG903_PgpMgrPipelineHandle *)f->master_handle;
423:
AG903_PgpMgrPipelineHandle *slave = (
AG903_PgpMgrPipelineHandle *)f->slave_handle;
424:
425:
if (master->is_assign ==
false) {
426:
return -
AG903_EINVAL;
427: }
428:
if (PgpContext.exec_pipeline[master->pipeline_no] == master) {
429:
430:
PGPPrmParamPGPnSTATE state;
431:
AG903_PgpPrmGetPGPnSTATE(master->pipeline_no, &state);
432:
if (state.st !=
AG903_PGP_MGR_STATE_IDLE) {
433:
return -
AG903_EBUSY;
434: }
435: PgpContext.exec_pipeline[master->pipeline_no] = NULL;
436: }
437:
438:
if (PgpContext.assign_pipeline[master->pipeline_no] == master) {
439: PgpContext.assign_pipeline[master->pipeline_no] = NULL;
440: }
441:
442: vram_handle = (
AG903_PgpMgrVRAMInputHandle *)master->input_handle;
443:
if ((vram_handle != NULL) && (vram_handle->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
444: vram_handle->ref_cnt--;
445: }
446: master->is_assign =
false;
447: master->pipeline_no = -1;
448: master->input_handle = NULL;
449:
450:
if (slave->id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
451:
if (PgpContext.assign_pipeline[slave->pipeline_no] == slave) {
452: PgpContext.assign_pipeline[slave->pipeline_no] = NULL;
453: }
454:
if (PgpContext.exec_pipeline[slave->pipeline_no] == slave) {
455: PgpContext.exec_pipeline[slave->pipeline_no] = NULL;
456: }
457:
458: vram_handle = (
AG903_PgpMgrVRAMInputHandle *)slave->input_handle;
459:
if ((vram_handle != NULL) && (vram_handle->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
460: vram_handle->ref_cnt--;
461: }
462: slave->is_assign =
false;
463: slave->pipeline_no = -1;
464: slave->input_handle = NULL;
465: }
466: }
467:
468:
return AG903_ENONE;
469: }
470:
471:
472:
481: int32_t
AG903_PgpMgrCheckFunctionValidation(
AG903_PgpMgrPipelineHandle *handle, uint32_t pipeline)
482: {
483:
484:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
485:
return -
AG903_EINVAL;
486: }
487:
488:
489:
switch (pipeline) {
490:
case AG903_PGP_MGR_CALC_PIPELINE0:
491:
case AG903_PGP_MGR_CALC_PIPELINE1:
492:
case AG903_PGP_MGR_INPUT_PIPELINE0:
493:
case AG903_PGP_MGR_INPUT_PIPELINE1:
494:
case AG903_PGP_MGR_FRAME_PIPELINE0:
495:
case AG903_PGP_MGR_FRAME_PIPELINE1:
496:
break;
497:
default:
498:
return -
AG903_EINVAL;
499: }
500:
501:
return PgpMgrCheckAssignPipelineHandle(handle, pipeline);
502: }
503:
504:
505:
523: int32_t
AG903_PgpMgrExecPipeline(
void *handle, uint32_t cmd)
524: {
525: uint32_t id;
526:
527:
if (handle == NULL) {
528:
return -
AG903_EINVAL;
529: }
530:
531:
532: id = ((
AG903_PgpMgrPipelineHandle *)handle)->id;
533:
if ((id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) && (id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
534:
return -
AG903_EINVAL;
535: }
536:
537:
switch (cmd) {
538:
case AG903_PGP_MGR_CMD_NONE:
539:
case AG903_PGP_MGR_CMD_EXEC:
540:
case AG903_PGP_MGR_CMD_EXEC_CONTINUE:
541:
case AG903_PGP_MGR_CMD_TRIG:
542:
case AG903_PGP_MGR_CMD_TRIG_CONTINUE:
543:
case AG903_PGP_MGR_CMD_IDLE:
544:
case AG903_PGP_MGR_CMD_RESET_TIMESTAMP_CNT:
545:
case AG903_PGP_MGR_CMD_RESET_FRAME_CNT:
546:
case AG903_PGP_MGR_CMD_RESET_INTR_CNT:
547:
case AG903_PGP_MGR_CMD_FORCE_QUIT:
548:
break;
549:
default:
550:
return -
AG903_EINVAL;
551: }
552:
553:
if (id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
554:
AG903_PgpMgrPipelineHandle *p = (
AG903_PgpMgrPipelineHandle *)handle;
555:
556:
if (p->is_assign ==
false) {
557:
return -
AG903_EINVAL;
558: }
559:
560:
return PgpMgrExecPipelineHandle(p, cmd);
561: }
else {
562:
AG903_PgpMgrFrameCalcHandle *f = (
AG903_PgpMgrFrameCalcHandle *)handle;
563:
AG903_PgpMgrPipelineHandle *master = (
AG903_PgpMgrPipelineHandle *)f->master_handle;
564:
565:
if (master->is_assign ==
false) {
566:
return -
AG903_EINVAL;
567: }
568:
569:
return PgpMgrExecFrameCalcHandle(f, cmd);
570: }
571: }
572:
573:
574:
585: int32_t
AG903_PgpMgrSetIntrCallbackFunc(
AG903_PgpMgrPipelineHandle *handle, uint32_t type,
void (*func)(int32_t id,
void *handle))
586: {
587:
588:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
589:
return -
AG903_EINVAL;
590: }
591:
592:
switch (type) {
593:
case AG903_PGP_MGR_INTR_INPUT:
594: handle->intr_vsynci_enable = (func == NULL) ?
false :
true;
595: handle->intr_input_func = func;
596:
break;
597:
case AG903_PGP_MGR_INTR_OUTPUT:
598: handle->intr_vsynco_enable = (func == NULL) ?
false :
true;
599: handle->intr_output_func = func;
600:
break;
601:
case AG903_PGP_MGR_INTR_DONE:
602: handle->intr_vsynco_enable = (func == NULL) ?
false :
true;
603: handle->intr_done_func = func;
604:
break;
605:
case AG903_PGP_MGR_INTR_VRAM_ERROR:
606: handle->intr_voicpl_enable = handle->intr_vooflw_enable = (func == NULL) ?
false :
true;
607: handle->intr_vram_error_func = func;
608:
break;
609:
case AG903_PGP_MGR_INTR_LBL_ERROR:
610: handle->intr_lblcrpt_enable = (func == NULL) ?
false :
true;
611: handle->intr_lbl_error_func = func;
612:
break;
613:
case AG903_PGP_MGR_INTR_HGM_ERROR:
614: handle->intr_hgmicpl_enable = (func == NULL) ?
false :
true;
615: handle->intr_hgm_error_func = func;
616:
break;
617:
case AG903_PGP_MGR_INTR_ND:
618: handle->intr_nd_enable = (func == NULL) ?
false :
true;
619: handle->intr_nd_func = func;
620:
break;
621:
case AG903_PGP_MGR_INTR_IFC_OVF:
622: handle->intr_ifcofs_enable = handle->intr_ifcofm_enable = (func == NULL) ?
false :
true;
623: handle->intr_ifc_ovf_func = func;
624:
break;
625:
case AG903_PGP_MGR_INTR_INPUT_LINE:
626: handle->intr_vlinei_enable = (func == NULL) ?
false :
true;
627: handle->intr_input_line_func = func;
628:
break;
629:
case AG903_PGP_MGR_INTR_OUTPUT_LINE:
630: handle->intr_vlineo_enable = (func == NULL) ?
false :
true;
631: handle->intr_output_line_func = func;
632:
break;
633:
case AG903_PGP_MGR_INTR_LBL_DONE:
634: handle->intr_lblcpl_enable = (func == NULL) ?
false :
true;
635: handle->intr_lbl_done_func = func;
636:
break;
637:
case AG903_PGP_MGR_INTR_HGM_DONE:
638: handle->intr_hgmcpl_enable = (func == NULL) ?
false :
true;
639: handle->intr_hgm_done_func = func;
640:
break;
641:
default:
642:
return -
AG903_EINVAL;
643: }
644:
645: handle->is_dirty =
true;
646: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_INTR_ENABLE] =
true;
647:
return AG903_ENONE;
648: }
649:
650:
651:
677: int32_t
AG903_PgpMgrSetConfigIntrCtrl(
AG903_PgpMgrPipelineHandle *handle, uint32_t input_field, uint32_t input_fcnt, uint32_t input_line, uint32_t output_field, uint32_t output_fcnt, uint32_t output_line)
678: {
679:
680:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
681:
return -
AG903_EINVAL;
682: }
683:
684:
685:
switch (input_field) {
686:
case AG903_PGP_MGR_INTR_CTRL_FIELD_ODD:
687:
case AG903_PGP_MGR_INTR_CTRL_FIELD_EVEN:
688:
case AG903_PGP_MGR_INTR_CTRL_FIELD_ODD_EVEN:
689:
break;
690:
default:
691:
return -
AG903_EINVAL;
692: }
693:
if ((input_fcnt == 0) || (input_fcnt >
AG903_PGP_MGR_INTR_CTRL_MAX_FRAME_CNT)) {
694:
return -
AG903_EINVAL;
695: }
696:
if (input_line >
AG903_PGP_MGR_INTR_CTRL_MAX_INPUT_LINE) {
697:
return -
AG903_EINVAL;
698: }
699:
switch (output_field) {
700:
case AG903_PGP_MGR_INTR_CTRL_FIELD_ODD:
701:
case AG903_PGP_MGR_INTR_CTRL_FIELD_EVEN:
702:
case AG903_PGP_MGR_INTR_CTRL_FIELD_ODD_EVEN:
703:
break;
704:
default:
705:
return -
AG903_EINVAL;
706: }
707:
if ((output_fcnt == 0) || (output_fcnt >
AG903_PGP_MGR_INTR_CTRL_MAX_FRAME_CNT)) {
708:
return -
AG903_EINVAL;
709: }
710:
if (output_line >
AG903_PGP_MGR_INTR_CTRL_MAX_OUTPUT_LINE) {
711:
return -
AG903_EINVAL;
712: }
713:
714:
715: handle->input_intr_field = input_field;
716: handle->input_intr_fcnt = input_fcnt;
717: handle->input_intr_line = input_line;
718: handle->output_intr_field = output_field;
719: handle->output_intr_fcnt = output_fcnt;
720: handle->output_intr_line = output_line;
721: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_INTR_CTRL] =
true;
722: handle->is_dirty =
true;
723:
return AG903_ENONE;
724: }
725:
726:
727:
742: int32_t
AG903_PgpMgrGetPipelineStatus(
AG903_PgpMgrPipelineHandle *handle, uint32_t *blank, _Bool *is_vram_out, uint32_t *queue_cnt, uint32_t *sub_status, uint32_t *status)
743: {
744:
PGPPrmParamPGPnSTATE state;
745:
746:
747:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
748:
return -
AG903_EINVAL;
749: }
750:
751:
if (handle->is_assign !=
true) {
752:
return -
AG903_EINVAL;
753: }
754:
755:
756:
AG903_PgpPrmGetPGPnSTATE(handle->pipeline_no, &state);
757:
758:
759:
if ((PgpContext.exec_pipeline[handle->pipeline_no] != handle) && (state.st !=
AG903_PGP_MGR_STATE_IDLE)) {
760:
return -
AG903_EINVAL;
761: }
762:
763:
if (blank != NULL) {
764: *blank = state.blank;
765: }
766:
if (is_vram_out != NULL) {
767: *is_vram_out = state.vrmacc;
768: }
769:
if (queue_cnt != NULL) {
770: *queue_cnt = state.queue;
771: }
772:
if (sub_status != NULL) {
773: *sub_status = state.sst;
774: }
775:
if (status != NULL) {
776: *status = state.st;
777: }
778:
return AG903_ENONE;
779: }
780:
781:
782:
796: int32_t
AG903_PgpMgrEnableParamTrigCtrl(
AG903_PgpMgrPipelineHandle *handle, _Bool vlinei_enable, _Bool vsynci_enable, _Bool vlineo_enable, _Bool vsynco_enable)
797: {
798:
799:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
800:
return -
AG903_EINVAL;
801: }
802:
803:
804:
if (handle->is_assign ==
true) {
805:
return -
AG903_EBUSY;
806: }
807:
808:
809: handle->trig_vlinei_enable = vlinei_enable;
810: handle->trig_vsynci_enable = vsynci_enable;
811: handle->trig_vlineo_enable = vlineo_enable;
812: handle->trig_vsynco_enable = vsynco_enable;
813: handle->is_dirty =
true;
814:
return AG903_ENONE;
815: }
816:
817:
818:
844: int32_t
AG903_PgpMgrSetConfigTrigCtrl(
AG903_PgpMgrPipelineHandle *handle, uint32_t input_field, uint32_t input_fcnt, uint32_t input_line, uint32_t output_field, uint32_t output_fcnt, uint32_t output_line)
845: {
846:
847:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
848:
return -
AG903_EINVAL;
849: }
850:
851:
852:
switch (input_field) {
853:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_ODD:
854:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_EVEN:
855:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_ODD_EVEN:
856:
break;
857:
default:
858:
return -
AG903_EINVAL;
859: }
860:
if ((input_fcnt == 0) || (input_fcnt >
AG903_PGP_MGR_TRIG_CTRL_MAX_FRAME_CNT)) {
861:
return -
AG903_EINVAL;
862: }
863:
if (input_line >
AG903_PGP_MGR_TRIG_CTRL_MAX_INPUT_LINE) {
864:
return -
AG903_EINVAL;
865: }
866:
switch (output_field) {
867:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_ODD:
868:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_EVEN:
869:
case AG903_PGP_MGR_TRIG_CTRL_FIELD_ODD_EVEN:
870:
break;
871:
default:
872:
return -
AG903_EINVAL;
873: }
874:
if ((output_fcnt == 0) || (output_fcnt >
AG903_PGP_MGR_TRIG_CTRL_MAX_FRAME_CNT)) {
875:
return -
AG903_EINVAL;
876: }
877:
if (output_line >
AG903_PGP_MGR_TRIG_CTRL_MAX_OUTPUT_LINE) {
878:
return -
AG903_EINVAL;
879: }
880:
881:
882: handle->input_trig_field = input_field;
883: handle->input_trig_fcnt = input_fcnt;
884: handle->input_trig_line = input_line;
885: handle->output_trig_field = output_field;
886: handle->output_trig_fcnt = output_fcnt;
887: handle->output_trig_line = output_line;
888: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_TRIG_CTRL] =
true;
889: handle->is_dirty =
true;
890:
return AG903_ENONE;
891: }
892:
893:
894:
910: int32_t
AG903_PgpMgrSetParamInputHSyncDelay(
AG903_PgpMgrPipelineHandle *handle, uint32_t h_delay)
911: {
912:
913:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
914:
return -
AG903_EINVAL;
915: }
916:
917:
918:
if (h_delay >
AG903_PGP_MGR_MAX_INPUT_HSYNC_DELAY) {
919:
return -
AG903_EINVAL;
920: }
921:
922:
923:
if (handle->is_assign ==
true) {
924:
return -
AG903_EBUSY;
925: }
926:
927:
928: handle->input_hsync_delay = h_delay;
929: handle->is_dirty =
true;
930:
return AG903_ENONE;
931: }
932:
933:
934:
946: int32_t
AG903_PgpMgrSetParamInputMode(
AG903_PgpMgrPipelineHandle *handle, uint32_t md)
947: {
948:
949:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
950:
return -
AG903_EINVAL;
951: }
952:
953:
954:
switch (md) {
955:
case AG903_PGP_MGR_INPUT_MD_VSYNC:
956:
case AG903_PGP_MGR_INPUT_MD_ODD_VSYNC:
957:
break;
958:
default:
959:
return -
AG903_EINVAL;
960: }
961:
962:
963:
if (handle->is_assign ==
true) {
964:
return -
AG903_EBUSY;
965: }
966:
967:
968: handle->input_mode = md;
969: handle->is_dirty =
true;
970:
return AG903_ENONE;
971: }
972:
973:
974:
986: int32_t
AG903_PgpMgrSetParamInputTimeCLK(
AG903_PgpMgrPipelineHandle *handle, uint32_t tick)
987: {
988:
989:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
990:
return -
AG903_EINVAL;
991: }
992:
993:
994:
switch (tick) {
995:
case AG903_PGP_MGR_INPUT_TIME_CLK0:
996:
case AG903_PGP_MGR_INPUT_TIME_CLK1:
997:
break;
998:
default:
999:
return -
AG903_EINVAL;
1000: }
1001:
1002:
1003:
if (handle->is_assign ==
true) {
1004:
return -
AG903_EBUSY;
1005: }
1006:
1007:
1008: handle->input_timer_clk = tick;
1009: handle->is_dirty =
true;
1010:
return AG903_ENONE;
1011: }
1012:
1013:
1014:
1028: int32_t
AG903_PgpMgrSetConfigInputTrigChannel(
AG903_PgpMgrPipelineHandle *handle, uint32_t timer_ch)
1029: {
1030:
1031:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1032:
return -
AG903_EINVAL;
1033: }
1034:
1035:
1036:
if (timer_ch >
AG903_PGP_MGR_MAX_TRIG_TIMER_CHANNEL) {
1037:
return -
AG903_EINVAL;
1038: }
1039:
1040:
1041: handle->input_trig_timer_ch = timer_ch;
1042: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_INPUT_TRIG_CH] =
true;
1043: handle->is_dirty =
true;
1044:
return AG903_ENONE;
1045: }
1046:
1047:
1048:
1066: int32_t
AG903_PgpMgrSetInputPort(
AG903_PgpMgrPipelineHandle *handle,
void *src)
1067: {
1068:
const uint32_t via_port[4] = {
1069:
AG903_PGP_MGR_INPUT_PORT_VIA_0,
1070:
AG903_PGP_MGR_INPUT_PORT_VIA_1,
1071:
AG903_PGP_MGR_INPUT_PORT_VIA_2,
1072:
AG903_PGP_MGR_INPUT_PORT_VIA_3,
1073: };
1074:
const uint32_t vid_port[4] = {
1075:
AG903_PGP_MGR_INPUT_PORT_VID_0,
1076:
AG903_PGP_MGR_INPUT_PORT_VID_1,
1077:
AG903_PGP_MGR_INPUT_PORT_VID_2,
1078:
AG903_PGP_MGR_INPUT_PORT_VID_3,
1079: };
1080:
1081:
AG903_ViaMgrInputHandle *via_h = (
AG903_ViaMgrInputHandle *)src;
1082:
AG903_VidMgrOutputHandle *vid_h = (
AG903_VidMgrOutputHandle *)src;
1083:
AG903_PgpMgrVRAMInputHandle *vram_h = (
AG903_PgpMgrVRAMInputHandle *)src;
1084:
1085:
1086:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1087:
return -
AG903_EINVAL;
1088: }
1089:
1090:
if (src != NULL) {
1091:
if (via_h->id ==
AG903_VIA_MGR_INPUT_HANDLE_ID) {
1092: handle->input_port = via_port[via_h->port_no];
1093: }
else if (vid_h->id ==
AG903_VID_MGR_OUTPUT_HANDLE_ID) {
1094: handle->input_port = vid_port[vid_h->port_no];
1095: }
else if (vram_h->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID) {
1096:
1097: vram_h->ref_cnt++;
1098: }
else {
1099:
return -
AG903_EINVAL;
1100: }
1101: }
1102:
1103:
1104: vram_h = (
AG903_PgpMgrVRAMInputHandle *)handle->input_handle;
1105:
if ((vram_h != NULL) && (vram_h->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
1106: vram_h->ref_cnt--;
1107: }
1108:
1109:
1110: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_INPUT_TRIG_CH] =
true;
1111: handle->input_handle = src;
1112:
return AG903_ENONE;
1113: }
1114:
1115:
1116:
1128: int32_t
AG903_PgpMgrSetParamInputFormat(
AG903_PgpMgrPipelineHandle *handle, uint32_t format)
1129: {
1130:
1131:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1132:
return -
AG903_EINVAL;
1133: }
1134:
1135:
1136:
switch (format) {
1137:
case AG903_PGP_MGR_INPUT_FMT_RGB888:
1138:
case AG903_PGP_MGR_INPUT_FMT_RGB565:
1139:
case AG903_PGP_MGR_INPUT_FMT_YCBCR444:
1140:
case AG903_PGP_MGR_INPUT_FMT_YCBCR422_WO_IP:
1141:
case AG903_PGP_MGR_INPUT_FMT_YCBCR422_W_IP:
1142:
case AG903_PGP_MGR_INPUT_FMT_CLUT8:
1143:
case AG903_PGP_MGR_INPUT_FMT_CLUT1:
1144:
break;
1145:
default:
1146:
return -
AG903_EINVAL;
1147: }
1148:
1149:
1150:
if (handle->is_assign ==
true) {
1151:
return -
AG903_EBUSY;
1152: }
1153:
1154:
1155: handle->input_format = format;
1156: handle->is_dirty =
true;
1157:
return AG903_ENONE;
1158: }
1159:
1160:
1161:
1179: int32_t
AG903_PgpMgrSetParamInputSize(
AG903_PgpMgrPipelineHandle *handle, uint32_t vsize, uint32_t hsize)
1180: {
1181:
1182:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1183:
return -
AG903_EINVAL;
1184: }
1185:
1186:
1187:
if ((vsize == 0) || (vsize >
AG903_PGP_MGR_MAX_INPUT_SIZE)) {
1188:
return -
AG903_EINVAL;
1189: }
1190:
if ((hsize == 0) || (hsize >
AG903_PGP_MGR_MAX_INPUT_SIZE)) {
1191:
return -
AG903_EINVAL;
1192: }
1193:
1194:
1195:
if (handle->is_assign ==
true) {
1196:
return -
AG903_EBUSY;
1197: }
1198:
1199:
1200: handle->input_vsize = vsize;
1201: handle->input_hsize = hsize;
1202: handle->is_dirty =
true;
1203:
return AG903_ENONE;
1204: }
1205:
1206:
1207:
1225: int32_t
AG903_PgpMgrSetParamInputPosition(
AG903_PgpMgrPipelineHandle *handle, uint32_t vpos, uint32_t hpos)
1226: {
1227:
1228:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1229:
return -
AG903_EINVAL;
1230: }
1231:
1232:
1233:
if (vpos >
AG903_PGP_MGR_MAX_INPUT_POS) {
1234:
return -
AG903_EINVAL;
1235: }
1236:
if (hpos >
AG903_PGP_MGR_MAX_INPUT_POS) {
1237:
return -
AG903_EINVAL;
1238: }
1239:
1240:
1241:
if (handle->is_assign ==
true) {
1242:
return -
AG903_EBUSY;
1243: }
1244:
1245:
1246: handle->input_vpos = vpos;
1247: handle->input_hpos = hpos;
1248: handle->is_dirty =
true;
1249:
return AG903_ENONE;
1250: }
1251:
1252:
1253:
1267: int32_t
AG903_PgpMgrSetParamInputScan(
AG903_PgpMgrPipelineHandle *handle, uint32_t scan, _Bool epos, _Bool opos)
1268: {
1269:
1270:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1271:
return -
AG903_EINVAL;
1272: }
1273:
1274:
1275:
switch (scan) {
1276:
case AG903_PGP_MGR_SCAN_PROGRESSIVE:
1277:
case AG903_PGP_MGR_SCAN_INTERLACE:
1278:
break;
1279:
default:
1280:
return -
AG903_EINVAL;
1281: }
1282:
1283:
1284:
if (handle->is_assign ==
true) {
1285:
return -
AG903_EBUSY;
1286: }
1287:
1288:
1289: handle->input_scan = scan;
1290: handle->input_epos = epos;
1291: handle->input_opos = opos;
1292: handle->is_dirty =
true;
1293:
return AG903_ENONE;
1294: }
1295:
1296:
1297:
1311: int32_t
AG903_PgpMgrSetConfigOutputFramePadding(
AG903_PgpMgrPipelineHandle *handle, uint32_t pad)
1312: {
1313:
1314:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1315:
return -
AG903_EINVAL;
1316: }
1317:
1318:
1319:
if (pad >
AG903_PGP_MGR_MAX_OUTPUT_PAD) {
1320:
return -
AG903_EINVAL;
1321: }
1322:
1323:
1324: handle->output_pad = pad;
1325: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1326: handle->is_dirty =
true;
1327:
return AG903_ENONE;
1328: }
1329:
1330:
1331:
1342: int32_t
AG903_PgpMgrSetConfigOutputLimit(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit)
1343: {
1344:
1345:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1346:
return -
AG903_EINVAL;
1347: }
1348:
1349:
1350:
switch (limit) {
1351:
case AG903_PGP_MGR_LIMIT_0_255:
1352:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
1353:
break;
1354:
default:
1355:
return -
AG903_EINVAL;
1356: }
1357:
1358:
1359: handle->output_limit = limit;
1360: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1361: handle->is_dirty =
true;
1362:
return AG903_ENONE;
1363: }
1364:
1365:
1366:
1375: int32_t
AG903_PgpMgrEnableConfigOutputFrameInfo(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1376: {
1377:
1378:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1379:
return -
AG903_EINVAL;
1380: }
1381:
1382:
1383: handle->output_fai_enable = enable;
1384: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1385: handle->is_dirty =
true;
1386:
return AG903_ENONE;
1387: }
1388:
1389:
1390:
1399: int32_t
AG903_PgpMgrEnableConfigOutputDither(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1400: {
1401:
1402:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1403:
return -
AG903_EINVAL;
1404: }
1405:
1406:
1407: handle->output_dither_enable = enable;
1408: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1409: handle->is_dirty =
true;
1410:
return AG903_ENONE;
1411: }
1412:
1413:
1414:
1426: int32_t
AG903_PgpMgrSetParamOutputScan(
AG903_PgpMgrPipelineHandle *handle, uint32_t scan)
1427: {
1428:
1429:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1430:
return -
AG903_EINVAL;
1431: }
1432:
1433:
1434:
switch (scan) {
1435:
case AG903_PGP_MGR_SCAN_PROGRESSIVE:
1436:
case AG903_PGP_MGR_SCAN_INTERLACE:
1437:
break;
1438:
default:
1439:
return -
AG903_EINVAL;
1440: }
1441:
1442:
1443:
if (handle->is_assign ==
true) {
1444:
return -
AG903_EBUSY;
1445: }
1446:
1447:
1448: handle->output_scan = scan;
1449: handle->is_dirty =
true;
1450:
return AG903_ENONE;
1451: }
1452:
1453:
1454:
1465: int32_t
AG903_PgpMgrSetParamOutputAddrDim(
AG903_PgpMgrPipelineHandle *handle, uint32_t dim)
1466: {
1467:
1468:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1469:
return -
AG903_EINVAL;
1470: }
1471:
1472:
1473:
switch (dim) {
1474:
case AG903_PGP_MGR_ADDR_DIMENTION_1:
1475:
case AG903_PGP_MGR_ADDR_DIMENTION_2:
1476:
break;
1477:
default:
1478:
return -
AG903_EINVAL;
1479: }
1480:
1481:
1482:
if (handle->is_assign ==
true) {
1483:
return -
AG903_EBUSY;
1484: }
1485:
1486:
1487: handle->output_dim = dim;
1488: handle->is_dirty =
true;
1489:
return AG903_ENONE;
1490: }
1491:
1492:
1493:
1505: int32_t
AG903_PgpMgrSetConfigOutputDataSwap(
AG903_PgpMgrPipelineHandle *handle, _Bool word, _Bool hword, _Bool four_bit, _Bool one_bit)
1506: {
1507:
1508:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1509:
return -
AG903_EINVAL;
1510: }
1511:
1512:
1513: handle->output_word_swap_enable = word;
1514: handle->output_hword_swap_enable = hword;
1515: handle->output_4bit_swap_enable = four_bit;
1516: handle->output_1bit_swap_enable = one_bit;
1517: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1518: handle->is_dirty =
true;
1519:
return AG903_ENONE;
1520: }
1521:
1522:
1523:
1533: int32_t
AG903_PgpMgrSetConfigOutputInterlaceFrame(
AG903_PgpMgrPipelineHandle *handle, uint32_t frame_save)
1534: {
1535:
1536:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1537:
return -
AG903_EINVAL;
1538: }
1539:
1540:
1541:
switch (frame_save) {
1542:
case AG903_PGP_MGR_OUTPUT_FRAME_SAVE_ODD:
1543:
case AG903_PGP_MGR_OUTPUT_FRAME_SAVE_EVEN:
1544:
case AG903_PGP_MGR_OUTPUT_FRAME_SAVE_IGNORE_FIELD:
1545:
case AG903_PGP_MGR_OUTPUT_FRAME_SAVE_FIELD:
1546:
case AG903_PGP_MGR_OUTPUT_FRAME_SAVE_WEAVE:
1547:
break;
1548:
default:
1549:
return -
AG903_EINVAL;
1550: }
1551:
1552:
1553: handle->output_md = frame_save;
1554: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_CTRL] =
true;
1555: handle->is_dirty =
true;
1556:
return AG903_ENONE;
1557: }
1558:
1559:
1560:
1574: int32_t
AG903_PgpMgrSetParamOutputBMU(
AG903_PgpMgrPipelineHandle *handle, uint32_t bmu)
1575: {
1576:
1577:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1578:
return -
AG903_EINVAL;
1579: }
1580:
1581:
1582:
switch (bmu) {
1583:
case AG903_PGP_MGR_OUTPUT_BMU_NONE:
1584:
case AG903_PGP_MGR_OUTPUT_BMU_ENABLE:
1585:
case AG903_PGP_MGR_OUTPUT_BMU_ENABLE_EVEN:
1586:
break;
1587:
default:
1588:
return -
AG903_EINVAL;
1589: }
1590:
1591:
1592:
if (handle->is_assign ==
true) {
1593:
return -
AG903_EBUSY;
1594: }
1595:
1596:
1597: handle->output_bmu = bmu;
1598: handle->is_dirty =
true;
1599:
return AG903_ENONE;
1600: }
1601:
1602:
1603:
1615: int32_t
AG903_PgpMgrSetParamOutputFormat(
AG903_PgpMgrPipelineHandle *handle, uint32_t format)
1616: {
1617:
1618:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1619:
return -
AG903_EINVAL;
1620: }
1621:
1622:
1623:
switch (format) {
1624:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_RGB888_32BIT:
1625:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_RGB888_24BIT:
1626:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_RGB565:
1627:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_ARGB1555:
1628:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_ARGB4444:
1629:
case AG903_PGP_MGR_OUTPUT_FMT_RGB888_TO_RGB888_SEP:
1630:
case AG903_PGP_MGR_OUTPUT_FMT_YCBCR444_TO_YCBCR444_32BIT:
1631:
case AG903_PGP_MGR_OUTPUT_FMT_YCBCR444_TO_YCBCR444_24BIT:
1632:
case AG903_PGP_MGR_OUTPUT_FMT_YCBCR444_TO_YCBCR422:
1633:
case AG903_PGP_MGR_OUTPUT_FMT_YCBCR444_TO_YCBCR444_SEP:
1634:
case AG903_PGP_MGR_OUTPUT_FMT_CLUT8_TO_CLUT8:
1635:
case AG903_PGP_MGR_OUTPUT_FMT_CLUT1_TO_CLUT1:
1636:
break;
1637:
default:
1638:
return -
AG903_EINVAL;
1639: }
1640:
1641:
1642:
if (handle->is_assign ==
true) {
1643:
return -
AG903_EBUSY;
1644: }
1645:
1646:
1647: handle->output_format = format;
1648: handle->is_dirty =
true;
1649:
return AG903_ENONE;
1650: }
1651:
1652:
1653:
1665: int32_t
AG903_PgpMgrEnableConfigOutputColorMask(
AG903_PgpMgrPipelineHandle *handle, _Bool red, _Bool green, _Bool blue)
1666: {
1667:
1668:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) || ((red ==
false) && (green ==
false) && (blue ==
false))) {
1669:
return -
AG903_EINVAL;
1670: }
1671:
1672:
1673: handle->output_red_enable = red;
1674: handle->output_green_enable = green;
1675: handle->output_blue_enable = blue;
1676: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_COLOR_MASK] =
true;
1677: handle->is_dirty =
true;
1678:
return AG903_ENONE;
1679: }
1680:
1681:
1682:
1691: int32_t
AG903_PgpMgrSetConfigOutputBaseAddr(
AG903_PgpMgrPipelineHandle *handle,
void *addr)
1692: {
1693:
1694:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1695:
return -
AG903_EINVAL;
1696: }
1697:
1698:
1699:
if (addr == NULL) {
1700:
return -
AG903_EINVAL;
1701: }
1702:
1703:
1704: handle->output_base_addr = (uint32_t)addr;
1705: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_OUTPUT_BASE_ADDR] =
true;
1706: handle->is_dirty =
true;
1707:
return AG903_ENONE;
1708: }
1709:
1710:
1711:
1728: int32_t
AG903_PgpMgrSetParamOutputStride(
AG903_PgpMgrPipelineHandle *handle, uint32_t stride)
1729: {
1730:
1731:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1732:
return -
AG903_EINVAL;
1733: }
1734:
1735:
1736:
if ((stride == 0) || (stride >
AG903_PGP_MGR_OUTPUT_MAX_STRIDE_BYTE)) {
1737:
return -
AG903_EINVAL;
1738: }
1739:
1740:
1741:
if (handle->is_assign ==
true) {
1742:
return -
AG903_EBUSY;
1743: }
1744:
1745:
1746: handle->output_vram_stride = stride;
1747: handle->is_dirty =
true;
1748:
return AG903_ENONE;
1749: }
1750:
1751:
1752:
1773: int32_t
AG903_PgpMgrGetFrameInfo(
AG903_PgpMgrPipelineHandle *handle, uint32_t *tmstmp, uint32_t *field, uint32_t *port, uint32_t *fnum)
1774: {
1775:
1776:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1777:
return -
AG903_EINVAL;
1778: }
1779:
1780:
1781:
if (handle->is_assign ==
false) {
1782:
return -
AG903_EINVAL;
1783: }
1784:
1785:
if (PgpContext.exec_pipeline[handle->pipeline_no] != handle) {
1786:
return -
AG903_EINVAL;
1787: }
1788:
1789:
1790:
if (tmstmp != NULL) {
1791:
AG903_PgpPrmGetPGPnFAIVAL0(handle->pipeline_no, tmstmp);
1792: }
1793:
if (field != NULL || port != NULL || fnum != NULL) {
1794: uint32_t tmp_field, tmp_port, tmp_fnum;
1795:
AG903_PgpPrmGetPGPnFAIVAL1(handle->pipeline_no, &tmp_field, &tmp_port, &tmp_fnum);
1796:
if (field != NULL) {
1797: *field = tmp_field;
1798: }
1799:
if (port != NULL) {
1800: *port = tmp_port;
1801: }
1802:
if (fnum != NULL) {
1803: *fnum = tmp_fnum;
1804: }
1805: }
1806:
return AG903_ENONE;
1807: }
1808:
1809:
1810:
1822: int32_t
AG903_PgpMgrSetParamFrameCalcOrder(
AG903_PgpMgrPipelineHandle *handle, uint32_t order)
1823: {
1824:
1825:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1826:
return -
AG903_EINVAL;
1827: }
1828:
1829:
1830:
switch (order) {
1831:
case AG903_PGP_MGR_IFCODR_FRAME_TO_OTHER:
1832:
case AG903_PGP_MGR_IFCODR_OTHER_TO_FRAME:
1833:
break;
1834:
default:
1835:
return -
AG903_EINVAL;
1836: }
1837:
1838:
1839:
if (handle->is_assign ==
true) {
1840:
return -
AG903_EBUSY;
1841: }
1842:
1843:
1844: handle->ifc_order = order;
1845: handle->is_dirty =
true;
1846:
return AG903_ENONE;
1847: }
1848:
1849:
1850:
1861: int32_t
AG903_PgpMgrEnableParamThresholdOp(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1862: {
1863:
1864:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1865:
return -
AG903_EINVAL;
1866: }
1867:
1868:
1869:
if (handle->is_assign ==
true) {
1870:
return -
AG903_EBUSY;
1871: }
1872:
1873:
1874: handle->thr_enable = enable;
1875: handle->is_dirty =
true;
1876:
return AG903_ENONE;
1877: }
1878:
1879:
1880:
1891: int32_t
AG903_PgpMgrEnableParamDGC(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1892: {
1893:
1894:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1895:
return -
AG903_EINVAL;
1896: }
1897:
1898:
1899:
if (handle->is_assign ==
true) {
1900:
return -
AG903_EBUSY;
1901: }
1902:
1903:
1904: handle->dgc_enable = enable;
1905: handle->is_dirty =
true;
1906:
return AG903_ENONE;
1907: }
1908:
1909:
1910:
1921: int32_t
AG903_PgpMgrEnableParamHSV(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1922: {
1923:
1924:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1925:
return -
AG903_EINVAL;
1926: }
1927:
1928:
1929:
if (handle->is_assign ==
true) {
1930:
return -
AG903_EBUSY;
1931: }
1932:
1933:
1934: handle->hsv1_enable = enable;
1935: handle->is_dirty =
true;
1936:
return AG903_ENONE;
1937: }
1938:
1939:
1940:
1951: int32_t
AG903_PgpMgrEnableParamSpatialFilter(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1952: {
1953:
1954:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1955:
return -
AG903_EINVAL;
1956: }
1957:
1958:
1959:
if (handle->is_assign ==
true) {
1960:
return -
AG903_EBUSY;
1961: }
1962:
1963:
1964: handle->spf_enable = enable;
1965: handle->is_dirty =
true;
1966:
return AG903_ENONE;
1967: }
1968:
1969:
1970:
1981: int32_t
AG903_PgpMgrEnableParamScaling(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
1982: {
1983:
1984:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
1985:
return -
AG903_EINVAL;
1986: }
1987:
1988:
1989:
if (handle->is_assign ==
true) {
1990:
return -
AG903_EBUSY;
1991: }
1992:
1993:
1994: handle->scale_enable = enable;
1995: handle->is_dirty =
true;
1996:
return AG903_ENONE;
1997: }
1998:
1999:
2000:
2011: int32_t
AG903_PgpMgrEnableParamColorSpace(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
2012: {
2013:
2014:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2015:
return -
AG903_EINVAL;
2016: }
2017:
2018:
2019:
if (handle->is_assign ==
true) {
2020:
return -
AG903_EBUSY;
2021: }
2022:
2023:
2024: handle->csc1_enable = enable;
2025: handle->is_dirty =
true;
2026:
return AG903_ENONE;
2027: }
2028:
2029:
2030:
2041: int32_t
AG903_PgpMgrEnableParamNRF(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
2042: {
2043:
2044:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2045:
return -
AG903_EINVAL;
2046: }
2047:
2048:
2049:
if (handle->is_assign ==
true) {
2050:
return -
AG903_EBUSY;
2051: }
2052:
2053:
2054: handle->nrf_enable = enable;
2055: handle->is_dirty =
true;
2056:
return AG903_ENONE;
2057: }
2058:
2059:
2060:
2073: int32_t
AG903_PgpMgrEnableParamHistogram(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
2074: {
2075:
2076:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2077:
return -
AG903_EINVAL;
2078: }
2079:
2080:
2081:
if (handle->is_assign ==
true) {
2082:
return -
AG903_EBUSY;
2083: }
2084:
2085:
2086: handle->hgm_enable = enable;
2087: handle->is_dirty =
true;
2088:
return AG903_ENONE;
2089: }
2090:
2091:
2092:
2105: int32_t
AG903_PgpMgrEnableParamLabeling(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
2106: {
2107:
2108:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2109:
return -
AG903_EINVAL;
2110: }
2111:
2112:
2113:
if (handle->is_assign ==
true) {
2114:
return -
AG903_EBUSY;
2115: }
2116:
2117:
2118: handle->lbl_enable = enable;
2119: handle->is_dirty =
true;
2120:
return AG903_ENONE;
2121: }
2122:
2123:
2124:
2144: int32_t
AG903_PgpMgrSetConfigIPConversion(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit, uint32_t blky, uint32_t blkc)
2145: {
2146:
2147:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2148:
return -
AG903_EINVAL;
2149: }
2150:
2151:
2152:
switch (limit) {
2153:
case AG903_PGP_MGR_LIMIT_0_255:
2154:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
2155:
break;
2156:
default:
2157:
return -
AG903_EINVAL;
2158: }
2159:
if (blky >
AG903_PGP_MGR_MAX_IP_BLANK) {
2160:
return -
AG903_EINVAL;
2161: }
2162:
if (blkc >
AG903_PGP_MGR_MAX_IP_BLANK) {
2163:
return -
AG903_EINVAL;
2164: }
2165:
2166:
2167: handle->ipc_limit = limit;
2168: handle->ipc_blk_y = blky;
2169: handle->ipc_blk_c = blkc;
2170: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_IP_CONV] =
true;
2171: handle->is_dirty =
true;
2172:
return AG903_ENONE;
2173: }
2174:
2175:
2176:
2196: int32_t
AG903_PgpMgrSetConfigColorSpace(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit, uint32_t shift, int32_t mtx[3][4])
2197: {
2198: int32_t i;
2199:
2200:
2201:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2202:
return -
AG903_EINVAL;
2203: }
2204:
2205:
2206:
switch (limit) {
2207:
case AG903_PGP_MGR_LIMIT_0_255:
2208:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
2209:
break;
2210:
default:
2211:
return -
AG903_EINVAL;
2212: }
2213:
if (shift >
AG903_PGP_MGR_MAX_COLOR_SPACE_SHIFT) {
2214:
return -
AG903_EINVAL;
2215: }
2216:
if (mtx == NULL) {
2217:
return -
AG903_EINVAL;
2218: }
2219:
2220:
2221: handle->csc1_limit = limit;
2222: handle->csc1_shift = shift;
2223:
for (i = 0; i < 3; i++) {
2224: handle->csc1_matrix[i][0] = mtx[i][0] & CSC_MUL_MASK;
2225: handle->csc1_matrix[i][1] = mtx[i][1] & CSC_MUL_MASK;
2226: handle->csc1_matrix[i][2] = mtx[i][2] & CSC_MUL_MASK;
2227: handle->csc1_matrix[i][3] = mtx[i][3] & CSC_ADD_MASK;
2228: }
2229: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_COLOR_SPACE] =
true;
2230: handle->is_dirty =
true;
2231:
return AG903_ENONE;
2232: }
2233:
2234:
2235:
2245: int32_t
AG903_PgpMgrSetConfigPresetColorSpace(
AG903_PgpMgrPipelineHandle *handle, uint32_t format)
2246: {
2247:
2248:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2249:
return -
AG903_EINVAL;
2250: }
2251:
2252:
2253:
switch (format) {
2254:
case AG903_PGP_MGR_CSC_YUV_BT_601_FULL_TO_RGB:
2255:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_601_FULL:
2256:
case AG903_PGP_MGR_CSC_YUV_BT_601_LIMIT_TO_RGB:
2257:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_601_LIMIT:
2258:
case AG903_PGP_MGR_CSC_YUV_BT_709_FULL_TO_RGB:
2259:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_709_FULL:
2260:
case AG903_PGP_MGR_CSC_YUV_BT_709_LIMIT_TO_RGB:
2261:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_709_LIMIT:
2262:
break;
2263:
default:
2264:
return -
AG903_EINVAL;
2265: }
2266:
2267:
2268: PgpMgrGetPresetColorSpaceParameter(format, &handle->csc1_limit, &handle->csc1_shift, &handle->csc1_matrix[0][0]);
2269: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_COLOR_SPACE] =
true;
2270: handle->is_dirty =
true;
2271:
return AG903_ENONE;
2272: }
2273:
2274:
2275:
2301: int32_t
AG903_PgpMgrSetConfigScaling(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit, uint32_t filter, uint32_t nmr_v, uint32_t dnm_v, uint32_t nmr_h, uint32_t dnm_h)
2302: {
2303:
2304:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2305:
return -
AG903_EINVAL;
2306: }
2307:
2308:
2309:
switch (limit) {
2310:
case AG903_PGP_MGR_LIMIT_0_255:
2311:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
2312:
break;
2313:
default:
2314:
return -
AG903_EINVAL;
2315: }
2316:
switch (filter) {
2317:
case AG903_PGP_MGR_FILTER_NEAREST:
2318:
case AG903_PGP_MGR_FILTER_LINEAR:
2319:
break;
2320:
default:
2321:
return -
AG903_EINVAL;
2322: }
2323:
if ((nmr_v == 0) || (nmr_v >
AG903_PGP_MGR_MAX_SCALING_VALUE)) {
2324:
return -
AG903_EINVAL;
2325: }
2326:
if ((dnm_v == 0) || (dnm_v >
AG903_PGP_MGR_MAX_SCALING_VALUE)) {
2327:
return -
AG903_EINVAL;
2328: }
2329:
if ((nmr_h == 0) || (nmr_h >
AG903_PGP_MGR_MAX_SCALING_VALUE)) {
2330:
return -
AG903_EINVAL;
2331: }
2332:
if ((dnm_h == 0) || (dnm_h >
AG903_PGP_MGR_MAX_SCALING_VALUE)) {
2333:
return -
AG903_EINVAL;
2334: }
2335:
2336:
2337: handle->scale_limit = limit;
2338: handle->scale_mtd = filter;
2339: handle->scale_v_nmr = nmr_v;
2340: handle->scale_v_dnm = dnm_v;
2341: handle->scale_h_nmr = nmr_h;
2342: handle->scale_h_dnm = dnm_h;
2343: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_SCALING] =
true;
2344: handle->is_dirty =
true;
2345:
return AG903_ENONE;
2346: }
2347:
2348:
2374: int32_t
AG903_PgpMgrSetConfigSpatialFilter(
AG903_PgpMgrPipelineHandle *handle, uint32_t shift, uint32_t border, uint32_t border_red, uint32_t border_green, uint32_t border_blue, int32_t coeff[9], int32_t offset)
2375: {
2376: int32_t i;
2377:
2378:
2379:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2380:
return -
AG903_EINVAL;
2381: }
2382:
2383:
2384:
if (shift >
AG903_PGP_MGR_MAX_SPF_SHIFT) {
2385:
return -
AG903_EINVAL;
2386: }
2387:
switch (border) {
2388:
case AG903_PGP_MGR_SPF_BORDER_COLOR:
2389:
case AG903_PGP_MGR_SPF_BORDER_NEIGHBOR:
2390:
break;
2391:
default:
2392:
return -
AG903_EINVAL;
2393: }
2394:
if (coeff == NULL) {
2395:
return -
AG903_EINVAL;
2396: }
2397:
2398:
2399: handle->spf_shift = shift;
2400: handle->spf_border_sel = border;
2401: handle->spf_border_red = border_red;
2402: handle->spf_border_green = border_green;
2403: handle->spf_border_blue = border_blue;
2404:
for (i = 0; i < 9; i++) {
2405: handle->spf_coeff[i] = coeff[i] & SPF1_COEFF_MASK;
2406: }
2407: handle->spf_offset = offset & SPF1_OFFSET_MASK;
2408: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_SP_FILTER] =
true;
2409: handle->is_dirty =
true;
2410:
return AG903_ENONE;
2411: }
2412:
2413:
2414:
2424: int32_t
AG903_PgpMgrSetConfigHSVHLSConversion(
AG903_PgpMgrPipelineHandle *handle, uint32_t sel)
2425: {
2426:
2427:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2428:
return -
AG903_EINVAL;
2429: }
2430:
2431:
2432:
switch (sel) {
2433:
case AG903_PGP_MGR_CONVERT_HSV:
2434:
case AG903_PGP_MGR_CONVERT_HLS:
2435:
break;
2436:
default:
2437:
return -
AG903_EINVAL;
2438: }
2439:
2440:
2441: handle->hsv_hls_sel = sel;
2442: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_HSVHSL_CONV] =
true;
2443: handle->is_dirty =
true;
2444:
return AG903_ENONE;
2445: }
2446:
2447:
2459: int32_t
AG903_PgpMgrExecHistogram(
AG903_PgpMgrPipelineHandle *handle, uint32_t cmd)
2460: {
2461:
PGPPrmParamPGPnSTATE state;
2462:
PGPPrmParamPGPnHGMSTAT hgmstat;
2463:
2464:
2465:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2466:
return -
AG903_EINVAL;
2467: }
2468:
2469:
2470:
if (handle->is_assign ==
false) {
2471:
return -
AG903_EINVAL;
2472: }
2473:
2474:
AG903_PgpPrmGetPGPnSTATE(handle->pipeline_no, &state);
2475:
2476:
if ((PgpContext.exec_pipeline[handle->pipeline_no] != handle ) && (state.st !=
AG903_PGP_MGR_STATE_IDLE)) {
2477:
return -
AG903_EBUSY;
2478: }
2479:
AG903_PgpPrmGetPGPnHGMSTAT(handle->pipeline_no, &hgmstat);
2480:
2481:
switch (cmd) {
2482:
case AG903_PGP_MGR_HGM_CMD_EXEC:
2483:
case AG903_PGP_MGR_HGM_CMD_EXEC_WO_VRAM:
2484:
2485:
if ((hgmstat.queue == (
AG903_PGP_MGR_HGM_CMD_MAX_QUEUE - 1)) || ((hgmstat.cmd != 0) && (cmd != hgmstat.cmd))) {
2486:
return -
AG903_EBUSY;
2487: }
2488:
break;
2489:
case AG903_PGP_MGR_HGM_CMD_NONE:
2490:
case AG903_PGP_MGR_HGM_CMD_DELETE:
2491:
case AG903_PGP_MGR_HGM_CMD_RESET:
2492:
break;
2493:
default:
2494:
return -
AG903_EINVAL;
2495: }
2496:
2497:
2498:
2499:
AG903_PgpPrmSetPGPnHGMCMD(handle->pipeline_no, cmd);
2500:
2501:
return AG903_ENONE;
2502: }
2503:
2504:
2530: int32_t
AG903_PgpMgrSetConfigHistogramParameter(
AG903_PgpMgrPipelineHandle *handle, uint32_t inv, uint32_t exc, uint32_t thr, uint32_t shift, uint32_t v_inc, uint32_t h_inc)
2531: {
2532:
2533:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2534:
return -
AG903_EINVAL;
2535: }
2536:
2537:
2538:
if (inv >
AG903_PGP_MGR_MAX_HGM_OUTPUT_INVALIDATE) {
2539:
return -
AG903_EINVAL;
2540: }
2541:
switch (exc) {
2542:
case AG903_PGP_MGR_HGM_EXC_NONE:
2543:
case AG903_PGP_MGR_HGM_EXC_0:
2544:
case AG903_PGP_MGR_HGM_EXC_0_16:
2545:
case AG903_PGP_MGR_HGM_EXC_0_WO_R:
2546:
break;
2547:
default:
2548:
return -
AG903_EINVAL;
2549: }
2550:
if (thr >
AG903_PGP_MGR_MAX_HGM_THR) {
2551:
return -
AG903_EINVAL;
2552: }
2553:
if (shift >
AG903_PGP_MGR_MAX_HGM_SHIFT) {
2554:
return -
AG903_EINVAL;
2555: }
2556:
if (v_inc >
AG903_PGP_MGR_MAX_HGM_INC) {
2557:
return -
AG903_EINVAL;
2558: }
2559:
if (h_inc >
AG903_PGP_MGR_MAX_HGM_INC) {
2560:
return -
AG903_EINVAL;
2561: }
2562:
2563:
2564: handle->hgm_invalidate = inv;
2565: handle->hgm_exc = exc;
2566: handle->hgm_thr = thr;
2567: handle->hgm_shift = shift;
2568: handle->hgm_vinc = v_inc;
2569: handle->hgm_hinc = h_inc;
2570: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_HGM_PARAM] =
true;
2571: handle->is_dirty =
true;
2572:
return AG903_ENONE;
2573: }
2574:
2575:
2591: int32_t
AG903_PgpMgrSetConfigHistogramSize(
AG903_PgpMgrPipelineHandle *handle, uint32_t vsize, uint32_t hsize)
2592: {
2593:
2594:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2595:
return -
AG903_EINVAL;
2596: }
2597:
2598:
2599:
if ((vsize == 0) || (vsize >
AG903_PGP_MGR_MAX_HGM_SIZE)) {
2600:
return -
AG903_EINVAL;
2601: }
2602:
if ((hsize == 0) || (hsize >
AG903_PGP_MGR_MAX_HGM_SIZE)) {
2603:
return -
AG903_EINVAL;
2604: }
2605:
2606:
2607: handle->hgm_vsize = vsize;
2608: handle->hgm_hsize = hsize;
2609: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_HGM_SIZE] =
true;
2610: handle->is_dirty =
true;
2611:
return AG903_ENONE;
2612: }
2613:
2614:
2630: int32_t
AG903_PgpMgrSetConfigHistogramPosition(
AG903_PgpMgrPipelineHandle *handle, uint32_t vpos, uint32_t hpos)
2631: {
2632:
2633:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2634:
return -
AG903_EINVAL;
2635: }
2636:
2637:
2638:
if (vpos >
AG903_PGP_MGR_MAX_HGM_POS) {
2639:
return -
AG903_EINVAL;
2640: }
2641:
if (hpos >
AG903_PGP_MGR_MAX_HGM_POS) {
2642:
return -
AG903_EINVAL;
2643: }
2644:
2645:
2646: handle->hgm_vpos = vpos;
2647: handle->hgm_hpos = hpos;
2648: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_HGM_POS] =
true;
2649: handle->is_dirty =
true;
2650:
return AG903_ENONE;
2651: }
2652:
2653:
2662: int32_t
AG903_PgpMgrSetConfigHistogramBaseAddr(
AG903_PgpMgrPipelineHandle *handle,
void *addr)
2663: {
2664:
2665:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2666:
return -
AG903_EINVAL;
2667: }
2668:
2669:
2670:
if (addr == NULL) {
2671:
return -
AG903_EINVAL;
2672: }
2673:
2674:
2675: handle->hgm_addr = (uint32_t)addr;
2676: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_HGM_BASE_ADDR] =
true;
2677: handle->is_dirty =
true;
2678:
return AG903_ENONE;
2679: }
2680:
2681:
2682:
2693: int32_t
AG903_PgpMgrEnableParamHistogramBMU(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
2694: {
2695:
2696:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2697:
return -
AG903_EINVAL;
2698: }
2699:
2700:
2701:
if (handle->is_assign ==
true) {
2702:
return -
AG903_EBUSY;
2703: }
2704:
2705:
2706: handle->hgm_bmu = enable;
2707: handle->is_dirty =
true;
2708:
return AG903_ENONE;
2709: }
2710:
2711:
2712:
2730: int32_t
AG903_PgpMgrGetHistogramParameter(
AG903_PgpMgrPipelineHandle *handle, uint32_t *most_r, uint32_t *max_r, uint32_t *min_r, uint32_t *most_g, uint32_t *max_g, uint32_t *min_g, uint32_t *most_b, uint32_t *max_b, uint32_t *min_b)
2731: {
2732: uint32_t dummy, tmp_max, tmp_min;
2733:
2734:
2735:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2736:
return -
AG903_EINVAL;
2737: }
2738:
2739:
2740:
if (handle->is_assign ==
false) {
2741:
return -
AG903_EINVAL;
2742: }
2743:
2744:
if (PgpContext.exec_pipeline[handle->pipeline_no] != handle) {
2745:
return -
AG903_EINVAL;
2746: }
2747:
2748:
2749:
if (most_r != NULL) {
2750:
AG903_PgpPrmGetPGPnHGMMOD2(handle->pipeline_no, &dummy, most_r, &dummy);
2751: }
2752:
AG903_PgpPrmGetPGPnHGMRNG2(handle->pipeline_no, &tmp_max, &tmp_min);
2753:
if (max_r != NULL) {
2754: *max_r = tmp_max;
2755: }
2756:
if (min_r != NULL) {
2757: *min_r = tmp_min;
2758: }
2759:
if (most_g != NULL) {
2760:
AG903_PgpPrmGetPGPnHGMMOD1(handle->pipeline_no, &dummy, most_g, &dummy);
2761: }
2762:
AG903_PgpPrmGetPGPnHGMRNG1(handle->pipeline_no, &tmp_max, &tmp_min);
2763:
if (max_g != NULL) {
2764: *max_g = tmp_max;
2765: }
2766:
if (min_g != NULL) {
2767: *min_g = tmp_min;
2768: }
2769:
if (most_b != NULL) {
2770:
AG903_PgpPrmGetPGPnHGMMOD0(handle->pipeline_no, &dummy, most_b, &dummy);
2771: }
2772:
AG903_PgpPrmGetPGPnHGMRNG0(handle->pipeline_no, &tmp_max, &tmp_min);
2773:
if (max_b != NULL) {
2774: *max_b = tmp_max;
2775: }
2776:
if (min_b != NULL) {
2777: *min_b = tmp_min;
2778: }
2779:
return AG903_ENONE;
2780: }
2781:
2782:
2783:
2797: int32_t
AG903_PgpMgrGetHistogramStatus(
AG903_PgpMgrPipelineHandle *handle, _Bool *is_init, _Bool *is_vram_out, _Bool *is_act, uint32_t *queue_cnt, uint32_t *exec_cmd)
2798: {
2799:
PGPPrmParamPGPnHGMSTAT hgmstat;
2800:
2801:
2802:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2803:
return -
AG903_EINVAL;
2804: }
2805:
2806:
2807:
if (handle->is_assign ==
false) {
2808:
return -
AG903_EINVAL;
2809: }
2810:
2811:
AG903_PgpPrmGetPGPnHGMSTAT(handle->pipeline_no, &hgmstat);
2812:
2813:
2814:
if ((PgpContext.exec_pipeline[handle->pipeline_no] != handle) && (hgmstat.cmd !=
AG903_PGP_MGR_HGM_CMD_NONE)) {
2815:
return -
AG903_EINVAL;
2816: }
2817:
if (is_init != NULL) {
2818: *is_init = hgmstat.init;
2819: }
2820:
if (is_vram_out != NULL) {
2821: *is_vram_out = hgmstat.vrmacc;
2822: }
2823:
if (is_act != NULL) {
2824: *is_act = hgmstat.act;
2825: }
2826:
if (queue_cnt != NULL) {
2827: *queue_cnt = hgmstat.queue;
2828: }
2829:
if (exec_cmd != NULL) {
2830: *exec_cmd = hgmstat.cmd;
2831: }
2832:
return AG903_ENONE;
2833: }
2834:
2835:
2836:
2860: int32_t
AG903_PgpMgrSetConfigThreshold(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit, _Bool spf, _Bool mask, _Bool csc, _Bool hsv_hls, _Bool thr8, uint32_t sel_out, uint32_t sel_clut8)
2861: {
2862:
2863:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2864:
return -
AG903_EINVAL;
2865: }
2866:
2867:
2868:
switch (limit) {
2869:
case AG903_PGP_MGR_LIMIT_NONE:
2870:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
2871:
break;
2872:
default:
2873:
return -
AG903_EINVAL;
2874: }
2875:
switch (sel_out) {
2876:
case AG903_PGP_MGR_THR_OUT_SEL_RGB:
2877:
case AG903_PGP_MGR_THR_OUT_SEL_MUX8:
2878:
case AG903_PGP_MGR_THR_OUT_SEL_SPF1:
2879:
case AG903_PGP_MGR_THR_OUT_SEL_LBL:
2880:
break;
2881:
default:
2882:
return -
AG903_EINVAL;
2883: }
2884:
switch (sel_clut8) {
2885:
case AG903_PGP_MGR_THR_CLUT8_OUT_B:
2886:
case AG903_PGP_MGR_THR_CLUT8_OUT_G:
2887:
case AG903_PGP_MGR_THR_CLUT8_OUT_R:
2888:
break;
2889:
default:
2890:
return -
AG903_EINVAL;
2891: }
2892:
2893:
2894: handle->thr_limit = limit;
2895: handle->thr_spf1_enable = spf;
2896: handle->thr_msk_enable = mask;
2897: handle->thr_csc2_enable = csc;
2898: handle->thr_hsv2_enable = hsv_hls;
2899: handle->thr_thr8bit_enable = thr8;
2900: handle->thr_out_sel = sel_out;
2901: handle->thr_clut8_sel = sel_clut8;
2902: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR] =
true;
2903: handle->is_dirty =
true;
2904:
return AG903_ENONE;
2905: }
2906:
2907:
2908:
2918: int32_t
AG903_PgpMgrSetConfigThresholdHSVHLSConversion(
AG903_PgpMgrPipelineHandle *handle, uint32_t sel)
2919: {
2920:
2921:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2922:
return -
AG903_EINVAL;
2923: }
2924:
2925:
2926:
switch (sel) {
2927:
case AG903_PGP_MGR_CONVERT_HSV:
2928:
case AG903_PGP_MGR_CONVERT_HLS:
2929:
break;
2930:
default:
2931:
return -
AG903_EINVAL;
2932: }
2933:
2934:
2935: handle->thr_hsv_hls_sel = sel;
2936: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_HSCHLS_CONV] =
true;
2937: handle->is_dirty =
true;
2938:
return AG903_ENONE;
2939: }
2940:
2941:
2942:
2962: int32_t
AG903_PgpMgrSetConfigThresholdColorSpace(
AG903_PgpMgrPipelineHandle *handle, uint32_t limit, uint32_t shift, int32_t mtx[3][4])
2963: {
2964: int32_t i;
2965:
2966:
2967:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
2968:
return -
AG903_EINVAL;
2969: }
2970:
2971:
2972:
switch (limit) {
2973:
case AG903_PGP_MGR_LIMIT_0_255:
2974:
case AG903_PGP_MGR_LIMIT_16_235_AND_240:
2975:
break;
2976:
default:
2977:
return -
AG903_EINVAL;
2978: }
2979:
if (shift >
AG903_PGP_MGR_MAX_COLOR_SPACE_SHIFT) {
2980:
return -
AG903_EINVAL;
2981: }
2982:
if (mtx == NULL) {
2983:
return -
AG903_EINVAL;
2984: }
2985:
2986:
2987: handle->thr_csc2_limit = limit;
2988: handle->thr_csc2_shift = shift;
2989:
for (i = 0; i < 3; i++) {
2990: handle->thr_csc2_matrix[i][0] = mtx[i][0] & CSC_MUL_MASK;
2991: handle->thr_csc2_matrix[i][1] = mtx[i][1] & CSC_MUL_MASK;
2992: handle->thr_csc2_matrix[i][2] = mtx[i][2] & CSC_MUL_MASK;
2993: handle->thr_csc2_matrix[i][3] = mtx[i][3] & CSC_ADD_MASK;
2994: }
2995: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_COLOR_SPACE] =
true;
2996: handle->is_dirty =
true;
2997:
return AG903_ENONE;
2998: }
2999:
3000:
3001:
3011: int32_t
AG903_PgpMgrSetConfigThresholdPresetColorSpace(
AG903_PgpMgrPipelineHandle *handle, uint32_t format)
3012: {
3013:
3014:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3015:
return -
AG903_EINVAL;
3016: }
3017:
3018:
3019:
switch (format) {
3020:
case AG903_PGP_MGR_CSC_YUV_BT_601_FULL_TO_RGB:
3021:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_601_FULL:
3022:
case AG903_PGP_MGR_CSC_YUV_BT_601_LIMIT_TO_RGB:
3023:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_601_LIMIT:
3024:
case AG903_PGP_MGR_CSC_YUV_BT_709_FULL_TO_RGB:
3025:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_709_FULL:
3026:
case AG903_PGP_MGR_CSC_YUV_BT_709_LIMIT_TO_RGB:
3027:
case AG903_PGP_MGR_CSC_RGB_TO_YUV_BT_709_LIMIT:
3028:
break;
3029:
default:
3030:
return -
AG903_EINVAL;
3031: }
3032:
3033:
3034: PgpMgrGetPresetColorSpaceParameter(format, &handle->thr_csc2_limit, &handle->thr_csc2_shift, &handle->thr_csc2_matrix[0][0]);
3035: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_COLOR_SPACE] =
true;
3036: handle->is_dirty =
true;
3037:
return AG903_ENONE;
3038: }
3039:
3040:
3041:
3064: int32_t
AG903_PgpMgrSetConfigThresholdMask(
AG903_PgpMgrPipelineHandle *handle, uint32_t ch, uint32_t h, uint32_t l, uint32_t x, uint32_t hmax, uint32_t hmin, uint32_t lmax, uint32_t lmin)
3065: {
3066:
3067:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3068:
return -
AG903_EINVAL;
3069: }
3070:
3071:
3072:
switch (ch) {
3073:
case AG903_PGP_MGR_THR_CHANNEL_B:
3074:
case AG903_PGP_MGR_THR_CHANNEL_G:
3075:
case AG903_PGP_MGR_THR_CHANNEL_R:
3076:
break;
3077:
default:
3078:
return -
AG903_EINVAL;
3079: }
3080:
3081:
3082: handle->thr_msk_h[ch] = h & THR_MSK_L_MASK;
3083: handle->thr_msk_l[ch] = l & THR_MSK_H_MASK;
3084: handle->thr_msk_x[ch] = x & THR_MSK_X_MASK;
3085: handle->thr_msk_hmax[ch] = hmax & THR_MSK_HMAX_MASK;
3086: handle->thr_msk_hmin[ch] = hmin & THR_MSK_HMIN_MASK;
3087: handle->thr_msk_lmax[ch] = lmax & THR_MSK_LMAX_MASK;
3088: handle->thr_msk_lmin[ch] = lmin & THR_MSK_LMIN_MASK;
3089: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_MASK] =
true;
3090: handle->is_dirty =
true;
3091:
return AG903_ENONE;
3092: }
3093:
3094:
3095:
3115: int32_t
AG903_PgpMgrSetConfigThreshold8Bit(
AG903_PgpMgrPipelineHandle *handle, uint32_t ch, uint32_t type, uint32_t maxval, uint32_t maxthr, uint32_t minthr)
3116: {
3117:
3118:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3119:
return -
AG903_EINVAL;
3120: }
3121:
3122:
3123:
switch (ch) {
3124:
case AG903_PGP_MGR_THR_CHANNEL_B:
3125:
case AG903_PGP_MGR_THR_CHANNEL_G:
3126:
case AG903_PGP_MGR_THR_CHANNEL_R:
3127:
break;
3128:
default:
3129:
return -
AG903_EINVAL;
3130: }
3131:
switch (type) {
3132:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_BIN:
3133:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_BIN_INV:
3134:
case AG903_PGP_MGR_THR_8BIT_TYPE_TRU:
3135:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_ZERO:
3136:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_ZERO_INV:
3137:
break;
3138:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_BIN_EXT:
3139:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_BIN_INV_EXT:
3140:
case AG903_PGP_MGR_THR_8BIT_TYPE_TRU_EXT:
3141:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_ZERO_EXT:
3142:
case AG903_PGP_MGR_THR_8BIT_TYPE_THR_ZERO_INV_EXT:
3143:
if (minthr > maxthr) {
3144:
return -
AG903_EINVAL;
3145: }
3146:
break;
3147:
default:
3148:
return -
AG903_EINVAL;
3149: }
3150:
3151:
3152: handle->thr_thr8_prm_type[ch] = type;
3153: handle->thr_thr8_prm_maxval[ch] = maxval & THR_8THR_MAXV_MASK;
3154: handle->thr_thr8_prm_maxthr[ch] = maxthr & THR_8THR_MAXTH_MASK;
3155: handle->thr_thr8_prm_minthr[ch] = minthr & THR_8THR_MINTH_MASK;
3156: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_8BIT] =
true;
3157: handle->is_dirty =
true;
3158:
return AG903_ENONE;
3159: }
3160:
3161:
3162:
3183: int32_t
AG903_PgpMgrSetConfigThreshold1Bit(
AG903_PgpMgrPipelineHandle *handle, uint32_t h, uint32_t l, uint32_t x, uint32_t hmax, uint32_t hmin, uint32_t lmax, uint32_t lmin)
3184: {
3185:
3186:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3187:
return -
AG903_EINVAL;
3188: }
3189:
3190:
3191: handle->thr_thr1_h = h & THR_MSK_L_MASK;
3192: handle->thr_thr1_l = l & THR_MSK_H_MASK;
3193: handle->thr_thr1_x = x & THR_MSK_X_MASK;
3194: handle->thr_thr1_hmax = hmax & THR_MSK_HMAX_MASK;
3195: handle->thr_thr1_hmin = hmin & THR_MSK_HMIN_MASK;
3196: handle->thr_thr1_lmax = lmax & THR_MSK_LMAX_MASK;
3197: handle->thr_thr1_lmin = lmin & THR_MSK_LMIN_MASK;
3198: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_1BIT] =
true;
3199: handle->is_dirty =
true;
3200:
return AG903_ENONE;
3201: }
3202:
3203:
3204:
3220: int32_t
AG903_PgpMgrSetConfigThresholdSpatialFilter1Bit(
AG903_PgpMgrPipelineHandle *handle, int32_t coeff[9], int32_t thr)
3221: {
3222: int32_t i;
3223:
3224:
3225:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3226:
return -
AG903_EINVAL;
3227: }
3228:
3229:
3230:
if (coeff == NULL) {
3231:
return -
AG903_EINVAL;
3232: }
3233:
3234:
3235:
for (i = 0; i < 9; i++) {
3236: handle->thr_spf1_coeff[i] = coeff[i] & THR_SPF1_COEFF_MASK;
3237: }
3238: handle->thr_spf1_thr = thr & THR_SPF1_THR_MASK;
3239: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_THR_SP_FILTER_1BIT] =
true;
3240: handle->is_dirty =
true;
3241:
return AG903_ENONE;
3242: }
3243:
3244:
3245:
3256: int32_t
AG903_PgpMgrExecLabeling(
AG903_PgpMgrPipelineHandle *handle, uint32_t cmd)
3257: {
3258:
PGPPrmParamPGPnSTATE state;
3259:
3260:
3261:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3262:
return -
AG903_EINVAL;
3263: }
3264:
3265:
switch (cmd) {
3266:
case AG903_PGP_MGR_LBL_CMD_NONE:
3267:
case AG903_PGP_MGR_LBL_CMD_EXEC:
3268:
case AG903_PGP_MGR_LBL_CMD_DELETE:
3269:
case AG903_PGP_MGR_LBL_CMD_RESET:
3270:
break;
3271:
default:
3272:
return -
AG903_EINVAL;
3273: }
3274:
3275:
3276:
if (handle->is_assign ==
false) {
3277:
return -
AG903_EINVAL;
3278: }
3279:
3280:
AG903_PgpPrmGetPGPnSTATE(handle->pipeline_no, &state);
3281:
3282:
if ((PgpContext.exec_pipeline[handle->pipeline_no] != handle ) && (state.st !=
AG903_PGP_MGR_STATE_IDLE)) {
3283:
return -
AG903_EBUSY;
3284: }
3285:
3286:
PGPPrmParamPGPnLBLSTAT lblstat;
3287:
AG903_PgpPrmGetPGPnLBLSTAT(handle->pipeline_no, &lblstat);
3288:
3289:
if ((cmd ==
AG903_PGP_MGR_LBL_CMD_EXEC) && (lblstat.queue == (
AG903_PGP_MGR_LBL_CMD_MAX_QUEUE - 1))) {
3290:
return -
AG903_EBUSY;
3291: }
3292:
3293:
3294:
AG903_PgpPrmSetPGPnLBLCMD(handle->pipeline_no, cmd);
3295:
3296:
return AG903_ENONE;
3297: }
3298:
3299:
3300:
3316: int32_t
AG903_PgpMgrSetConfigLabelingValidTime(
AG903_PgpMgrPipelineHandle *handle, uint32_t vld, uint32_t inv)
3317: {
3318:
3319:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3320:
return -
AG903_EINVAL;
3321: }
3322:
3323:
3324:
if ((vld == 0) || (vld >
AG903_PGP_MGR_MAX_LBL_OUTPUT_VALIDATE)) {
3325:
return -
AG903_EINVAL;
3326: }
3327:
if (inv >
AG903_PGP_MGR_MAX_LBL_OUTPUT_INVALIDATE) {
3328:
return -
AG903_EINVAL;
3329: }
3330:
3331:
3332: handle->lbl_valid = vld;
3333: handle->lbl_invalid = inv;
3334: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_LBL_PARAM] =
true;
3335: handle->is_dirty =
true;
3336:
return AG903_ENONE;
3337: }
3338:
3339:
3340:
3358: int32_t
AG903_PgpMgrSetConfigLabelingParameter(
AG903_PgpMgrPipelineHandle *handle, uint32_t connect, uint32_t flush_thr, uint32_t max_id)
3359: {
3360:
3361:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3362:
return -
AG903_EINVAL;
3363: }
3364:
3365:
3366:
switch (connect) {
3367:
case AG903_PGP_MGR_LBL_CNCT_8:
3368:
case AG903_PGP_MGR_LBL_CNCT_4:
3369:
break;
3370:
default:
3371:
return -
AG903_EINVAL;
3372: }
3373:
if (flush_thr >
AG903_PGP_MGR_MAX_LBL_FLUSH_THR) {
3374:
return -
AG903_EINVAL;
3375: }
3376:
if (max_id >
AG903_PGP_MGR_MAX_LBL_ID) {
3377:
return -
AG903_EINVAL;
3378: }
3379:
3380:
3381: handle->lbl_connect = connect;
3382: handle->lbl_flush_thr = flush_thr;
3383: handle->lbl_maxid = max_id;
3384: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_LBL_PARAM] =
true;
3385: handle->is_dirty =
true;
3386:
return AG903_ENONE;
3387: }
3388:
3389:
3390:
3406: int32_t
AG903_PgpMgrSetConfigLabelingSize(
AG903_PgpMgrPipelineHandle *handle, uint32_t vsize, uint32_t hsize)
3407: {
3408:
3409:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3410:
return -
AG903_EINVAL;
3411: }
3412:
3413:
3414:
if ((vsize == 0) || (vsize >
AG903_PGP_MGR_MAX_LBL_VSIZE)) {
3415:
return -
AG903_EINVAL;
3416: }
3417:
if ((hsize == 0) || (hsize >
AG903_PGP_MGR_MAX_LBL_HSIZE)) {
3418:
return -
AG903_EINVAL;
3419: }
3420:
3421:
3422: handle->lbl_vsize = vsize;
3423: handle->lbl_hsize = hsize;
3424: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_LBL_SIZE] =
true;
3425: handle->is_dirty =
true;
3426:
return AG903_ENONE;
3427: }
3428:
3429:
3430:
3446: int32_t
AG903_PgpMgrSetConfigLabelingPosition(
AG903_PgpMgrPipelineHandle *handle, uint32_t vpos, uint32_t hpos)
3447: {
3448:
3449:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3450:
return -
AG903_EINVAL;
3451: }
3452:
3453:
3454:
if (vpos >
AG903_PGP_MGR_MAX_LBL_POS) {
3455:
return -
AG903_EINVAL;
3456: }
3457:
if (hpos >
AG903_PGP_MGR_MAX_LBL_POS) {
3458:
return -
AG903_EINVAL;
3459: }
3460:
3461:
3462: handle->lbl_vpos = vpos;
3463: handle->lbl_hpos = hpos;
3464: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_LBL_POS] =
true;
3465: handle->is_dirty =
true;
3466:
return AG903_ENONE;
3467: }
3468:
3469:
3470:
3479: int32_t
AG903_PgpMgrSetConfigLabelingBaseAddr(
AG903_PgpMgrPipelineHandle *handle,
void *addr)
3480: {
3481:
3482:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3483:
return -
AG903_EINVAL;
3484: }
3485:
3486:
3487:
if (addr == NULL) {
3488:
return -
AG903_EINVAL;
3489: }
3490:
3491:
3492: handle->lbl_addr = (uint32_t)addr;
3493: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_LBL_BASE_ADDR] =
true;
3494: handle->is_dirty =
true;
3495:
return AG903_ENONE;
3496: }
3497:
3498:
3499:
3510: int32_t
AG903_PgpMgrEnableParamLabelingBMU(
AG903_PgpMgrPipelineHandle *handle, _Bool enable)
3511: {
3512:
3513:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3514:
return -
AG903_EINVAL;
3515: }
3516:
3517:
3518:
if (handle->is_assign ==
true) {
3519:
return -
AG903_EBUSY;
3520: }
3521:
3522:
3523: handle->lbl_bmu = enable;
3524: handle->is_dirty =
true;
3525:
return AG903_ENONE;
3526: }
3527:
3528:
3529:
3543: int32_t
AG903_PgpMgrGetLabelingStatus(
AG903_PgpMgrPipelineHandle *handle, uint32_t *id, _Bool *is_vram_out, _Bool *is_act, uint32_t *queue_cnt, uint32_t *exec_cmd)
3544: {
3545:
3546:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
3547:
return -
AG903_EINVAL;
3548: }
3549:
3550:
3551:
if (handle->is_assign ==
false) {
3552:
return -
AG903_EINVAL;
3553: }
3554:
3555:
3556:
PGPPrmParamPGPnLBLSTAT lblstat;
3557:
AG903_PgpPrmGetPGPnLBLSTAT(handle->pipeline_no, &lblstat);
3558:
3559:
3560:
if ((PgpContext.exec_pipeline[handle->pipeline_no] != handle) && (lblstat.cmd !=
AG903_PGP_MGR_LBL_CMD_NONE)) {
3561:
return -
AG903_EINVAL;
3562: }
3563:
if (id != NULL) {
3564: *id = lblstat.l_id;
3565: }
3566:
if (is_vram_out != NULL) {
3567: *is_vram_out = lblstat.vrmacc;
3568: }
3569:
if (is_act != NULL) {
3570: *is_act = lblstat.act;
3571: }
3572:
if (queue_cnt != NULL) {
3573: *queue_cnt = lblstat.queue;
3574: }
3575:
if (exec_cmd != NULL) {
3576: *exec_cmd = lblstat.cmd;
3577: }
3578:
return AG903_ENONE;
3579: }
3580:
3581:
3582:
3596: int32_t
AG903_PgpMgrAnalyzeLabelingTable(
void *src, uint32_t tbl_num,
void **dst)
3597: {
3598: uint32_t dst_num;
3599:
3600:
3601:
if (src == NULL) {
3602:
return -
AG903_EINVAL;
3603: }
3604:
if (tbl_num < 1) {
3605:
return -
AG903_EINVAL;
3606: }
3607:
3608:
3609: *dst = PgpMgrAnalyzeLabelingTable(src, tbl_num, &dst_num);
3610:
3611:
3612:
if (dst_num == 0) {
3613:
return 0;
3614: }
3615:
3616:
3617:
if (*dst == NULL) {
3618:
return -
AG903_ENOMEM;
3619: }
3620:
3621:
return dst_num;
3622: }
3623:
3624:
3625:
3633: int32_t
AG903_PgpMgrReleaseLabelingTable(
void *tbl)
3634: {
3635:
if (tbl == NULL) {
3636:
return -
AG903_EINVAL;
3637: }
3638: PgpMgrReleaseLabelingTable(tbl);
3639:
return AG903_ENONE;
3640: }
3641:
3642:
3643:
3658: int32_t
AG903_PgpMgrGetFrameCalcHandle(
AG903_PgpMgrFrameCalcHandle **handle,
AG903_PgpMgrPipelineHandle *master,
void *slave)
3659: {
3660: int32_t i;
3661:
AG903_PgpMgrPipelineHandle *slave_pipeline = (
AG903_PgpMgrPipelineHandle *)slave;
3662:
AG903_PgpMgrVRAMInputHandle *slave_vram = (
AG903_PgpMgrVRAMInputHandle *)slave;
3663:
3664:
3665:
if (PgpContext.pipeline_time_sharing_enable ==
true) {
3666:
if ((PgpContext.num_frame_calc_handles + 1) >
AG903_PGP_MGR_MAX_FRAME_CALC_HANDLE) {
3667:
return -
AG903_ENOMEM;
3668: }
3669: }
else {
3670:
if ((PgpContext.num_frame_calc_handles + 1) >
AG903_PGP_MGR_CALC_PIPELINE_NUM) {
3671:
return -
AG903_ENOMEM;
3672: }
3673: }
3674:
3675:
if ((handle == NULL) || (master == NULL) || (slave == NULL)) {
3676:
return -
AG903_EINVAL;
3677: }
3678:
3679:
3680:
if (master->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
3681:
return -
AG903_EINVAL;
3682: }
3683:
if ((master->is_assign ==
true) || (master->is_used_frame_calc ==
true)) {
3684:
return -
AG903_EBUSY;
3685: }
3686:
3687:
if (slave_pipeline->id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) {
3688:
if ((slave_pipeline->is_assign ==
true) || (slave_pipeline->is_used_frame_calc ==
true)) {
3689:
return -
AG903_EBUSY;
3690: }
3691: slave_pipeline->frame_out_enable =
false;
3692: slave_pipeline->is_used_frame_calc =
true;
3693: slave_pipeline->is_dirty =
true;
3694: }
else if (slave_vram->id ==
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID) {
3695: slave_vram->ref_cnt++;
3696: }
else {
3697:
return -
AG903_EINVAL;
3698: }
3699: master->ifc_enable =
true;
3700: master->is_used_frame_calc =
true;
3701: master->is_dirty =
true;
3702:
3703:
3704:
for (i = 0; i <
AG903_PGP_MGR_MAX_FRAME_CALC_HANDLE; i++) {
3705:
if (PgpContext.frame_calc_handles[i].is_used ==
false) {
3706: PgpContext.frame_calc_handles[i].is_used =
true;
3707: PgpContext.frame_calc_handles[i].master_handle = master;
3708: PgpContext.frame_calc_handles[i].slave_handle = slave;
3709: PgpContext.frame_calc_handles[i].id =
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID;
3710: PgpContext.frame_calc_handles[i].slave_pipeline = (slave_pipeline->id ==
AG903_PGP_MGR_PIPELINE_HANDLE_ID) ?
true :
false;
3711: *handle = &PgpContext.frame_calc_handles[i];
3712:
break;
3713: }
3714: }
3715: PgpContext.num_frame_calc_handles++;
3716:
return AG903_ENONE;
3717: }
3718:
3719:
3720:
3729: int32_t
AG903_PgpMgrReleaseFrameCalcHandle(
AG903_PgpMgrFrameCalcHandle *handle)
3730: {
3731:
AG903_PgpMgrPipelineHandle *slave_pipeline;
3732:
3733:
3734:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
3735:
return -
AG903_EINVAL;
3736: }
3737:
3738:
3739:
if (handle->master_handle->pipeline_no != -1) {
3740:
3741:
if (PgpContext.exec_pipeline[handle->master_handle->pipeline_no] == handle->master_handle) {
3742:
PGPPrmParamPGPnSTATE state;
3743:
AG903_PgpPrmGetPGPnSTATE(handle->master_handle->pipeline_no, &state);
3744:
if (state.st !=
AG903_PGP_MGR_STATE_IDLE) {
3745:
return -
AG903_EBUSY;
3746: }
3747: PgpContext.exec_pipeline[handle->master_handle->pipeline_no] = NULL;
3748: }
3749:
3750:
if (PgpContext.assign_pipeline[handle->master_handle->pipeline_no] == handle->master_handle) {
3751: PgpContext.assign_pipeline[handle->master_handle->pipeline_no] = NULL;
3752: }
3753:
if (handle->slave_pipeline ==
true) {
3754: slave_pipeline = (
AG903_PgpMgrPipelineHandle *)handle->slave_handle;
3755:
if (PgpContext.assign_pipeline[slave_pipeline->pipeline_no] == slave_pipeline) {
3756: PgpContext.assign_pipeline[slave_pipeline->pipeline_no] = NULL;
3757: }
3758: }
3759: }
3760:
3761:
3762: handle->master_handle->ifc_enable =
false;
3763: handle->master_handle->is_used_frame_calc =
false;
3764: handle->master_handle->is_assign =
false;
3765: handle->master_handle->pipeline_no = -1;
3766: handle->master_handle->is_dirty =
true;
3767:
if (handle->slave_pipeline ==
true) {
3768: slave_pipeline = (
AG903_PgpMgrPipelineHandle *)handle->slave_handle;
3769:
if ((slave_pipeline->pipeline_no != -1) && (PgpContext.exec_pipeline[slave_pipeline->pipeline_no] == slave_pipeline)) {
3770: PgpContext.exec_pipeline[slave_pipeline->pipeline_no] = NULL;
3771: }
3772: slave_pipeline->frame_out_enable =
true;
3773: slave_pipeline->is_used_frame_calc =
false;
3774: slave_pipeline->is_assign =
false;
3775: slave_pipeline->pipeline_no = -1;
3776: slave_pipeline->is_dirty =
true;
3777: }
else {
3778:
AG903_PgpMgrVRAMInputHandle *slave_vram = (
AG903_PgpMgrVRAMInputHandle *)handle->slave_handle;
3779: slave_vram->ref_cnt--;
3780: }
3781:
3782: handle->is_used =
false;
3783: handle->id = 0;
3784: PgpContext.num_frame_calc_handles--;
3785:
return AG903_ENONE;
3786: }
3787:
3788:
3789:
3811: int32_t
AG903_PgpMgrSetConfigFrameCalcParameter(
AG903_PgpMgrFrameCalcHandle *handle, uint32_t scan, uint32_t limit, uint32_t slave_src, uint32_t operation)
3812: {
3813:
3814:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
3815:
return -
AG903_EINVAL;
3816: }
3817:
3818:
switch (scan) {
3819:
case AG903_PGP_MGR_SCAN_PROGRESSIVE:
3820:
case AG903_PGP_MGR_SCAN_INTERLACE:
3821:
break;
3822:
default:
3823:
return -
AG903_EINVAL;
3824: }
3825:
switch (limit) {
3826:
case AG903_PGP_MGR_IFC_LIMIT_0_255:
3827:
case AG903_PGP_MGR_IFC_LIMIT_16_235_AND_240:
3828:
case AG903_PGP_MGR_IFC_LIMIT_M128_127:
3829:
break;
3830:
default:
3831:
return -
AG903_EINVAL;
3832: }
3833:
switch (slave_src) {
3834:
case AG903_PGP_MGR_IFC_SLAVE_VRAM_UI:
3835:
case AG903_PGP_MGR_IFC_SLAVE_VRAM_I:
3836:
case AG903_PGP_MGR_IFC_SLAVE_PIPELINE:
3837:
break;
3838:
default:
3839:
return -
AG903_EINVAL;
3840: }
3841:
switch (operation) {
3842:
case AG903_PGP_MGR_IFC_OP_AND:
3843:
case AG903_PGP_MGR_IFC_OP_OR:
3844:
case AG903_PGP_MGR_IFC_OP_XOR:
3845:
case AG903_PGP_MGR_IFC_OP_ADD:
3846:
case AG903_PGP_MGR_IFC_OP_ABS:
3847:
break;
3848:
default:
3849:
return -
AG903_EINVAL;
3850: }
3851:
3852: handle->master_handle->ifc_scan = scan;
3853: handle->master_handle->ifc_limit = limit;
3854: handle->master_handle->ifc_slave_src = (handle->slave_pipeline ==
true) ?
AG903_PGP_MGR_IFC_SLAVE_PIPELINE : slave_src;
3855: handle->master_handle->ifc_operation = operation;
3856: handle->master_handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_IFC_PARAM] =
true;
3857: handle->master_handle->is_dirty =
true;
3858:
return AG903_ENONE;
3859: }
3860:
3861:
3862:
3882: int32_t
AG903_PgpMgrSetConfigFrameCalcGain(
AG903_PgpMgrFrameCalcHandle *handle, int32_t master_gain, int32_t slave_gain, uint32_t master_shift, uint32_t slave_shift)
3883: {
3884:
3885:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_FRAME_CALC_HANDLE_ID)) {
3886:
return -
AG903_EINVAL;
3887: }
3888:
3889:
3890:
if (master_shift >
AG903_PGP_MGR_MAX_IFC_GAIN_SHIFT) {
3891:
return -
AG903_EINVAL;
3892: }
3893:
if (slave_shift >
AG903_PGP_MGR_MAX_IFC_GAIN_SHIFT) {
3894:
return -
AG903_EINVAL;
3895: }
3896:
3897:
3898: handle->master_handle->ifc_master_gain = master_gain & IFC_GAIN_MASK;
3899: handle->master_handle->ifc_slave_gain = slave_gain & IFC_GAIN_MASK;
3900: handle->master_handle->ifc_master_shift = master_shift;
3901: handle->master_handle->ifc_slave_shift = slave_shift;
3902: handle->master_handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_IFC_PARAM] =
true;
3903: handle->master_handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_IFC_GAIN] =
true;
3904: handle->master_handle->is_dirty =
true;
3905:
return AG903_ENONE;
3906: }
3907:
3908:
3909:
3922: int32_t
AG903_PgpMgrGetVRAMInputHandle(int32_t num,
AG903_PgpMgrVRAMInputHandle **handles)
3923: {
3924:
int i, j;
3925:
3926:
3927:
if (PgpContext.pipeline_time_sharing_enable ==
true) {
3928:
if ((num + PgpContext.num_vram_input_handles) >
AG903_PGP_MGR_MAX_VRAMI_HANDLE) {
3929:
return -
AG903_EINVAL;
3930: }
3931: }
else {
3932:
if ((num + PgpContext.num_vram_input_handles) >
AG903_PGP_MGR_VRAMI_NUM) {
3933:
return -
AG903_EINVAL;
3934: }
3935: }
3936:
3937:
if (handles == NULL) {
3938:
return -
AG903_EINVAL;
3939: }
3940:
3941:
3942:
for (i = 0; i < num; i++) {
3943:
for (j = 0; j <
AG903_PGP_MGR_MAX_VRAMI_HANDLE; j++) {
3944:
if (PgpContext.vram_input_handles[j].is_used ==
false) {
3945:
3946: PgpMgrInitVRAMInputHandle(&PgpContext.vram_input_handles[j]);
3947:
3948: PgpContext.vram_input_handles[j].is_used =
true;
3949: PgpContext.vram_input_handles[j].id =
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID;
3950: handles[i] = &PgpContext.vram_input_handles[j];
3951:
break;
3952: }
3953: }
3954: }
3955:
3956: PgpContext.num_vram_input_handles += num;
3957:
3958:
return AG903_ENONE;
3959: }
3960:
3961:
3962:
3971: int32_t
AG903_PgpMgrReleaseVRAMInputHandle(
AG903_PgpMgrVRAMInputHandle *handle)
3972: {
3973:
3974:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
3975:
return -
AG903_EINVAL;
3976: }
3977:
3978:
3979:
if (handle->ref_cnt != 0) {
3980:
return -
AG903_EBUSY;
3981: }
3982:
3983:
if (PgpContext.assign_vram[handle->port_no] == handle) {
3984: PgpContext.assign_vram[handle->port_no] = NULL;
3985: }
3986:
if (PgpContext.exec_vram[handle->port_no] == handle) {
3987: PgpContext.exec_vram[handle->port_no] = NULL;
3988: }
3989:
3990: handle->is_used =
false;
3991: handle->id = 0;
3992: PgpContext.num_vram_input_handles--;
3993:
return AG903_ENONE;
3994: }
3995:
3996:
3997:
4008: int32_t
AG903_PgpMgrExecVRAMInput(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t cmd)
4009: {
4010: uint32_t dummy, queue, st;
4011:
4012:
4013:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4014:
return -
AG903_EINVAL;
4015: }
4016:
4017:
4018:
if (handle->port_no == -1) {
4019:
return -
AG903_EINVAL;
4020: }
4021:
4022:
AG903_PgpPrmGetPGPVInSTATE(handle->port_no, &dummy, &queue, &st);
4023:
4024:
if ((PgpContext.exec_vram[handle->port_no] != handle ) && (st !=
AG903_PGP_MGR_VI_CMD_NONE)) {
4025:
return -
AG903_EBUSY;
4026: }
4027:
4028:
switch (cmd) {
4029:
case AG903_PGP_MGR_VI_CMD_EXEC:
4030:
4031:
if ((queue == (
AG903_PGP_MGR_VI_CMD_MAX_QUEUE - 1)) || ((st != 0) && (cmd != st))) {
4032:
return -
AG903_EBUSY;
4033: }
4034:
break;
4035:
case AG903_PGP_MGR_VI_CMD_EXEC_CONTINUE:
4036:
4037:
if (st != 0) {
4038:
return -
AG903_EBUSY;
4039: }
4040:
break;
4041:
case AG903_PGP_MGR_VI_CMD_NONE:
4042:
case AG903_PGP_MGR_VI_CMD_IDLE:
4043:
case AG903_PGP_MGR_VI_CMD_RESET:
4044:
break;
4045:
default:
4046:
return -
AG903_EINVAL;
4047: }
4048:
4049: PgpMgrExecVRAMInputHandle(handle, cmd);
4050:
return AG903_ENONE;
4051: }
4052:
4053:
4054:
4066: int32_t
AG903_PgpMgrGetVRAMStatus(
AG903_PgpMgrVRAMInputHandle *handle, _Bool *is_vram_out, uint32_t *queue_cnt, uint32_t *exec_cmd)
4067: {
4068: uint32_t tmp_vram, tmp_queue, tmp_st;
4069:
4070:
4071:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4072:
return -
AG903_EINVAL;
4073: }
4074:
4075:
4076:
if (handle->port_no == -1) {
4077:
return -
AG903_EINVAL;
4078: }
4079:
4080:
4081:
AG903_PgpPrmGetPGPVInSTATE(handle->port_no, &tmp_vram, &tmp_queue, &tmp_st);
4082:
4083:
4084:
if ((PgpContext.exec_vram[handle->port_no] != handle) && (tmp_st !=
AG903_PGP_MGR_VI_CMD_NONE)) {
4085:
return -
AG903_EINVAL;
4086: }
4087:
if (is_vram_out != NULL) {
4088: *is_vram_out = tmp_vram;
4089: }
4090:
if (queue_cnt != NULL) {
4091: *queue_cnt = tmp_queue;
4092: }
4093:
if (exec_cmd != NULL) {
4094: *exec_cmd = tmp_st;
4095: }
4096:
return AG903_ENONE;
4097: }
4098:
4099:
4100:
4112: int32_t
AG903_PgpMgrSetParamVRAMInputBMU(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t bmu)
4113: {
4114:
4115:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4116:
return -
AG903_EINVAL;
4117: }
4118:
4119:
4120:
switch (bmu) {
4121:
case AG903_PGP_MGR_VI_BMU_NONE:
4122:
case AG903_PGP_MGR_VI_BMU_ENABLE:
4123:
case AG903_PGP_MGR_VI_BMU_ENABLE_ODD:
4124:
break;
4125:
default:
4126:
return -
AG903_EINVAL;
4127: }
4128:
4129:
4130:
if (handle->port_no != -1) {
4131:
return -
AG903_EBUSY;
4132: }
4133:
4134:
4135: handle->bmu = bmu;
4136: handle->is_dirty =
true;
4137:
return AG903_ENONE;
4138: }
4139:
4140:
4141:
4153: int32_t
AG903_PgpMgrSetParamVRAMInputScan(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t scan)
4154: {
4155:
4156:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4157:
return -
AG903_EINVAL;
4158: }
4159:
4160:
4161:
switch (scan) {
4162:
case AG903_PGP_MGR_SCAN_PROGRESSIVE:
4163:
case AG903_PGP_MGR_SCAN_INTERLACE:
4164:
break;
4165:
default:
4166:
return -
AG903_EINVAL;
4167: }
4168:
4169:
4170:
if (handle->port_no != -1) {
4171:
return -
AG903_EBUSY;
4172: }
4173:
4174:
4175: handle->scan = scan;
4176: handle->is_dirty =
true;
4177:
return AG903_ENONE;
4178: }
4179:
4180:
4181:
4193: int32_t
AG903_PgpMgrSetParamVRAMInputAddrDim(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t dim)
4194: {
4195:
4196:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4197:
return -
AG903_EINVAL;
4198: }
4199:
4200:
4201:
switch (dim) {
4202:
case AG903_PGP_MGR_ADDR_DIMENTION_1:
4203:
case AG903_PGP_MGR_ADDR_DIMENTION_2:
4204:
break;
4205:
default:
4206:
return -
AG903_EINVAL;
4207: }
4208:
4209:
4210:
if (handle->port_no != -1) {
4211:
return -
AG903_EBUSY;
4212: }
4213:
4214:
4215: handle->dim = dim;
4216: handle->is_dirty =
true;
4217:
return AG903_ENONE;
4218: }
4219:
4220:
4221:
4233: int32_t
AG903_PgpMgrSetConfigVRAMDataSwap(
AG903_PgpMgrVRAMInputHandle *handle, _Bool word, _Bool hword, _Bool four_bit, _Bool one_bit)
4234: {
4235:
4236:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4237:
return -
AG903_EINVAL;
4238: }
4239:
4240:
4241: handle->vram_word_swap_enable = word;
4242: handle->vram_hword_swap_enable = hword;
4243: handle->vram_4bit_swap_enable = four_bit;
4244: handle->vram_1bit_swap_enable = one_bit;
4245: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_VI_CTRL] =
true;
4246: handle->is_dirty =
true;
4247:
return AG903_ENONE;
4248: }
4249:
4250:
4251:
4262: int32_t
AG903_PgpMgrSetConfigVRAMInterlaceFrame(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t frame_read, _Bool fai)
4263: {
4264:
4265:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4266:
return -
AG903_EINVAL;
4267: }
4268:
4269:
4270:
switch (frame_read) {
4271:
case AG903_PGP_MGR_VI_FRAME_READ_ODD:
4272:
case AG903_PGP_MGR_VI_FRAME_READ_EVEN:
4273:
case AG903_PGP_MGR_VI_FRAME_READ_FIELD:
4274:
case AG903_PGP_MGR_VI_FRAME_READ_WEAVE:
4275:
break;
4276:
default:
4277:
return -
AG903_EINVAL;
4278: }
4279:
4280:
4281: handle->md = frame_read;
4282: handle->fai_enable = fai;
4283: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_VI_CTRL] =
true;
4284: handle->is_dirty =
true;
4285:
return AG903_ENONE;
4286: }
4287:
4288:
4289:
4307: int32_t
AG903_PgpMgrSetConfigVRAMValidTime(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t div, uint32_t vld, uint32_t inv)
4308: {
4309:
4310:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4311:
return -
AG903_EINVAL;
4312: }
4313:
4314:
4315:
if ((div == 0) || (div >
AG903_PGP_MGR_MAX_VI_DIV)) {
4316:
return -
AG903_EINVAL;
4317: }
4318:
if ((vld == 0) || (vld >
AG903_PGP_MGR_MAX_VI_VALIDATE)) {
4319:
return -
AG903_EINVAL;
4320: }
4321:
if (inv >
AG903_PGP_MGR_MAX_VI_INVALIDATE) {
4322:
return -
AG903_EINVAL;
4323: }
4324:
4325:
4326: handle->div = div;
4327: handle->valid = vld;
4328: handle->invalid = inv;
4329: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_VI_CTRL1] =
true;
4330: handle->is_dirty =
true;
4331:
return AG903_ENONE;
4332: }
4333:
4334:
4335:
4347: int32_t
AG903_PgpMgrSetParamVRAMFormat(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t format)
4348: {
4349:
4350:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4351:
return -
AG903_EINVAL;
4352: }
4353:
4354:
4355:
switch (format) {
4356:
case AG903_PGP_MGR_VI_FMT_RGB888_32:
4357:
case AG903_PGP_MGR_VI_FMT_RGB888_24:
4358:
case AG903_PGP_MGR_VI_FMT_RGB565:
4359:
case AG903_PGP_MGR_VI_FMT_YCBCR444_32:
4360:
case AG903_PGP_MGR_VI_FMT_YCBCR444_24:
4361:
case AG903_PGP_MGR_VI_FMT_YCBCR422:
4362:
case AG903_PGP_MGR_VI_FMT_CLUT8:
4363:
case AG903_PGP_MGR_VI_FMT_CLUT1:
4364:
break;
4365:
default:
4366:
return -
AG903_EINVAL;
4367: }
4368:
4369:
4370:
if (handle->port_no != -1) {
4371:
return -
AG903_EBUSY;
4372: }
4373:
4374:
4375: handle->format = format;
4376: handle->is_dirty =
true;
4377:
return AG903_ENONE;
4378: }
4379:
4380:
4381:
4390: int32_t
AG903_PgpMgrSetConfigVRAMBaseAddr(
AG903_PgpMgrVRAMInputHandle *handle,
void *addr)
4391: {
4392:
4393:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4394:
return -
AG903_EINVAL;
4395: }
4396:
4397:
4398:
if (addr == NULL) {
4399:
return -
AG903_EINVAL;
4400: }
4401:
4402:
4403: handle->addr = (uint32_t)addr;
4404: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_VI_BASE] =
true;
4405: handle->is_dirty =
true;
4406:
return AG903_ENONE;
4407: }
4408:
4409:
4410:
4426: int32_t
AG903_PgpMgrSetParamVRAMStride(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t stride)
4427: {
4428:
4429:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4430:
return -
AG903_EINVAL;
4431: }
4432:
4433:
4434:
if ((stride == 0) || (stride >
AG903_PGP_MGR_VI_MAX_STRIDE_BYTE)) {
4435:
return -
AG903_EINVAL;
4436: }
4437:
4438:
4439:
if (handle->port_no != -1) {
4440:
return -
AG903_EBUSY;
4441: }
4442:
4443:
4444: handle->stride = stride;
4445: handle->is_dirty =
true;
4446:
return AG903_ENONE;
4447: }
4448:
4449:
4450:
4477: int32_t
AG903_PgpMgrSetParamVRAMSyncSignal(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t h_pw, uint32_t h_fp, uint32_t h_bp, uint32_t v_pw, uint32_t v_fp, uint32_t v_bp)
4478: {
4479:
4480:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4481:
return -
AG903_EINVAL;
4482: }
4483:
4484:
4485:
if ((h_pw == 0) || (h_pw >
AG903_PGP_MGR_MAX_VI_H_PULES_WIDTH)) {
4486:
return -
AG903_EINVAL;
4487: }
4488:
if ((h_fp == 0) || (h_fp >
AG903_PGP_MGR_MAX_VI_H_FRONT_PORCH)) {
4489:
return -
AG903_EINVAL;
4490: }
4491:
if ((h_bp == 0) || (h_bp >
AG903_PGP_MGR_MAX_VI_H_BACK_PORCH)) {
4492:
return -
AG903_EINVAL;
4493: }
4494:
if ((v_pw == 0) || (v_pw >
AG903_PGP_MGR_MAX_VI_V_PULES_WIDTH)) {
4495:
return -
AG903_EINVAL;
4496: }
4497:
if ((v_fp == 0) || (v_fp >
AG903_PGP_MGR_MAX_VI_V_FRONT_PORCH)) {
4498:
return -
AG903_EINVAL;
4499: }
4500:
if ((v_bp == 0) || (v_bp >
AG903_PGP_MGR_MAX_VI_V_BACK_PORCH)) {
4501:
return -
AG903_EINVAL;
4502: }
4503:
4504:
4505:
if (handle->port_no != -1) {
4506:
return -
AG903_EBUSY;
4507: }
4508:
4509:
4510: handle->h_pulse_width = h_pw;
4511: handle->h_front_porch = h_fp;
4512: handle->h_back_porch = h_bp;
4513: handle->v_pulse_width = v_pw;
4514: handle->v_front_porch = v_fp;
4515: handle->v_back_porch = v_bp;
4516: handle->is_dirty =
true;
4517:
return AG903_ENONE;
4518: }
4519:
4520:
4521:
4539: int32_t
AG903_PgpMgrSetParamVRAMSize(
AG903_PgpMgrVRAMInputHandle *handle, uint32_t h_size, uint32_t v_size)
4540: {
4541:
4542:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4543:
return -
AG903_EINVAL;
4544: }
4545:
4546:
4547:
if ((h_size == 0) || (h_size >
AG903_PGP_MGR_MAX_VI_H_SIZE)) {
4548:
return -
AG903_EINVAL;
4549: }
4550:
if ((v_size == 0) || (v_size >
AG903_PGP_MGR_MAX_VI_V_SIZE)) {
4551:
return -
AG903_EINVAL;
4552: }
4553:
4554:
4555:
if (handle->port_no != -1) {
4556:
return -
AG903_EBUSY;
4557: }
4558:
4559:
4560: handle->h_frame_size = h_size;
4561: handle->v_frame_size = v_size;
4562: handle->is_dirty =
true;
4563:
return AG903_ENONE;
4564: }
4565:
4566:
4567:
4580: int32_t
AG903_PgpMgrAdjustVRAMFrame(
AG903_PgpMgrVRAMInputHandle *handle, _Bool e_vbp, _Bool e_vfp, _Bool o_vbp, _Bool o_vfp, _Bool o_vsize)
4581: {
4582:
4583:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4584:
return -
AG903_EINVAL;
4585: }
4586:
4587:
4588: handle->adjust_even_vbp = e_vbp;
4589: handle->adjust_even_vfp = e_vfp;
4590: handle->adjust_odd_vbp = o_vbp;
4591: handle->adjust_odd_vfp = o_vfp;
4592: handle->adjust_odd_vsize = o_vsize;
4593: handle->is_config_dirty[
AG903_PGP_MGR_CONFIG_VI_ADJUST_FRAME] =
true;
4594: handle->is_dirty =
true;
4595:
return AG903_ENONE;
4596: }
4597:
4598:
4599:
4608: int32_t
AG903_PgpMgrCheckVRAMParameter(
AG903_PgpMgrVRAMInputHandle *vram,
AG903_PgpMgrPipelineHandle *pipeline)
4609: {
4610:
4611:
if ((vram == NULL) || (vram->id !=
AG903_PGP_MGR_VRAM_INPUT_HANDLE_ID)) {
4612:
return -
AG903_EINVAL;
4613: }
4614:
if ((pipeline == NULL) || (pipeline->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
4615:
return -
AG903_EINVAL;
4616: }
4617:
4618:
4619:
if ((vram->h_pulse_width + vram->h_back_porch) != pipeline->input_hpos) {
4620:
return -
AG903_EINVAL;
4621: }
4622:
4623:
if ((vram->v_pulse_width + vram->v_back_porch) != pipeline->input_vpos) {
4624:
return -
AG903_EINVAL;
4625: }
4626:
4627:
return AG903_ENONE;
4628: }
4629:
4630:
4631:
4642: int32_t
AG903_PgpMgrSetJPEG(
AG903_PgpMgrPipelineHandle *handle)
4643: {
4644:
4645:
if ((handle == NULL) || (handle->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
4646:
return -
AG903_EINVAL;
4647: }
4648:
4649:
4650:
if (handle->is_assign ==
false) {
4651:
return -
AG903_EINVAL;
4652: }
4653:
4654: PgpContext.jpeg_output_pipeline = handle->pipeline_no;
4655:
4656:
return AG903_ENONE;
4657: }
4658:
4659:
4660:
4671: int32_t
AG903_PgpMgrEnableJPEG(_Bool enable)
4672: {
4673:
if ((enable ==
true) && (PgpContext.jpeg_output_enable ==
true)) {
4674:
return -
AG903_EBUSY;
4675: }
4676:
4677: PgpContext.jpeg_output_enable = enable;
4678:
4679:
4680:
AG903_PgpPrmSetPGPJPGOUTSEL(PgpContext.jpeg_output_enable, PgpContext.jpeg_output_pipeline);
4681:
4682:
return AG903_ENONE;
4683: }
4684:
4685:
4686:
#define PACK_LUT(d0, d1, d2, d3) (((d0) << 0) | ((d1) << 8) | ((d2) << 16) | ((d3) << 24))
4687:
4700: int32_t
AG903_PgpMgrGetDGCLUT(uint8_t red[256], uint8_t green[256], uint8_t blue[256],
AG903_PgpMgrDGCLookupTable **table)
4701: {
4702:
int i, j;
4703:
4704:
4705:
if ((red == NULL) || (green == NULL) || (blue == NULL) || (table == NULL)) {
4706:
return -
AG903_EINVAL;
4707: }
4708:
4709:
if ((PgpContext.num_dgc_lut + 1) >
AG903_PGP_MGR_MAX_DGC_LUT) {
4710:
return -
AG903_ENOMEM;
4711: }
4712:
4713:
4714:
for (i = 0; i <
AG903_PGP_MGR_MAX_DGC_LUT; i++) {
4715:
if (PgpContext.dgc_lut[i].is_used ==
false) {
4716: PgpContext.dgc_lut[i].is_used =
true;
4717: PgpContext.dgc_lut[i].id =
AG903_PGP_MGR_DGC_LUT_ID;
4718: PgpContext.dgc_lut[i].ref_cnt = 0;
4719:
4720:
for (j = 0; j < 256; j++) {
4721: PgpContext.dgc_lut[i].lut_data[0][j] = blue[j];
4722: PgpContext.dgc_lut[i].lut_data[1][j] = green[j];
4723: PgpContext.dgc_lut[i].lut_data[2][j] = red[j];
4724: }
4725: *table = &PgpContext.dgc_lut[i];
4726:
break;
4727: }
4728: }
4729:
4730: PgpContext.num_dgc_lut++;
4731:
4732:
return AG903_ENONE;
4733: }
4734:
4735:
4736:
4744: int32_t
AG903_PgpMgrReleaseDGCLUT(
AG903_PgpMgrDGCLookupTable *table)
4745: {
4746:
4747:
if ((table == NULL) || (table->id !=
AG903_PGP_MGR_DGC_LUT_ID)) {
4748:
return -
AG903_EINVAL;
4749: }
4750:
4751:
4752:
if (table->ref_cnt != 0) {
4753:
return -
AG903_EINVAL;
4754: }
4755:
4756:
4757: table->is_used =
false;
4758: table->id = 0;
4759: PgpContext.num_dgc_lut--;
4760:
4761:
return AG903_ENONE;
4762: }
4763:
4764:
4765:
4775: int32_t
AG903_PgpMgrSetConfigDGCLUT(
AG903_PgpMgrPipelineHandle *pipeline,
AG903_PgpMgrDGCLookupTable *dgc_lut)
4776: {
4777:
4778:
if ((pipeline == NULL) || (pipeline->id !=
AG903_PGP_MGR_PIPELINE_HANDLE_ID)) {
4779:
return -
AG903_EINVAL;
4780: }
4781:
if ((dgc_lut != NULL) && (dgc_lut->id !=
AG903_PGP_MGR_DGC_LUT_ID)) {
4782:
return -
AG903_EINVAL;
4783: }
4784:
4785:
4786:
if (pipeline->dgc_lut == dgc_lut) {
4787:
return AG903_ENONE;
4788: }
4789:
4790:
if (pipeline->dgc_lut != NULL) {
4791: pipeline->dgc_lut->ref_cnt--;
4792: pipeline->dgc_lut = NULL;
4793: }
4794:
4795: pipeline->dgc_lut = dgc_lut;
4796:
if (dgc_lut != NULL) {
4797: pipeline->dgc_lut_dirty =
true;
4798: dgc_lut->ref_cnt++;
4799: }
4800:
4801:
return AG903_ENONE;
4802: }