1:
11:
12:
16:
17:
18:
#include "AG903_common.h"
19:
20:
#include "dsp/dspprm.h"
21:
#include "dsp/vodprm.h"
22:
#include "dsp/dspmgr.h"
23:
24:
25:
26:
29:
typedef struct _DSPChBlock {
30: uint32_t channel;
31: uint32_t *lock[
AG903_DSP_ATTR_MAX];
32: }
DSPChBlock;
33:
34:
35:
36:
39:
static struct {
40:
bool init;
41:
DSPChBlock ch[
AG903_DSP_CH_NUM];
42:
AG903_DSPMgrHandle *lock[
AG903_DSP_CH_NUM];
43: }gDSP;
44:
45:
46:
static void AG903_DSPMgrInitDSP(uint8_t ch);
47:
static void AG903_DSPMgrInitVOD(uint8_t ch);
48:
static int32_t DSPMgrCheckHandle(
AG903_DSPMgrHandle *handle, uint8_t *ch);
49:
50:
57:
static void AG903_DSPMgrInitDSP(uint8_t ch) {
58:
if (ch >
AG903_DSP_CH_NUM)
return;
59:
60:
DSPPrmParamMOD mod = {
61: .de = AG903_DSP_RGBDE_SIGNAL_DATA,
62: .ip = AG903_DSP_VMODE_NONINTERLACE,
63: .upd = AG903_DSP_ATTR_END_OF_VSYNC,
64: .bmr = AG903_DSP_BMU_WINDATA,
65: .lut =
false,
66: .dith =
false,
67: };
68:
DSPPrmParamSYNC sync = {
69: .sel = AG903_DSP_EXSYNC_NONE,
70: .dly =
false,
71: .ip = AG903_DSP_VMODE_NONINTERLACE,
72: .vp = AG903_DSP_POLARITY_NEGA,
73: .fp = AG903_DSP_POLARITY_NEGA,
74: .msk =
true,
75: };
76:
DSPPrmParamVTPRM0 vtprm0 = {
77: .vpw = 2,
78: .ofp =
false,
79: .obp =
false,
80: .efp =
false,
81: .ebp =
false,
82: };
83:
DSPPrmParamCDCTRL cdctrl = {
84: .be =
false,
85: .ge =
false,
86: .re =
false,
87: .ae =
false,
88: };
89:
DSPPrmParamCOLDET coldet = {
90: .b = 0x00000000,
91: .g = 0x00000000,
92: .r = 0x00000000,
93: .a = 0x00000000,
94: };
95:
DSPPrmParamERRCLR errclr = {
96: .line =
true,
97: .ue =
true,
98: .le =
true,
99: .pe =
true,
100: };
101:
DSPPrmParamINT intprm = {
102: .line = 0,
103: .fcnt = 0,
104: .hline = AG903_DSP_INT_START_OF_LINE,
105: .vblk = AG903_DSP_INT_START_OF_VBLANK,
106: };
107:
DSPPrmParamINTMASK intmask = {
108: .vblk =
true,
109: .hline =
true,
110: .doff =
true,
111: .err =
true,
112: };
113:
DSPPrmParamLUTR lutr = {
114: .r0 = 0x00,
115: .r1 = 0x00,
116: .r2 = 0x00,
117: .r3 = 0x00,
118: };
119:
DSPPrmParamLUTG lutg = {
120: .g0 = 0x00,
121: .g1 = 0x00,
122: .g2 = 0x00,
123: .g3 = 0x00,
124: };
125:
DSPPrmParamLUTB lutb = {
126: .b0 = 0x00,
127: .b1 = 0x00,
128: .b2 = 0x00,
129: .b3 = 0x00,
130: };
131:
132:
AG903_DSPPrmSetCTRL(ch, AG903_DSP_CTRL_OFF);
133:
AG903_DSPPrmSetMOD(ch, &mod);
134:
AG903_DSPPrmSetSYNC(ch, &sync);
135:
AG903_DSPPrmSetBGCOL(ch, 0x00000000);
136:
AG903_DSPPrmSetWINNUM(ch, 1);
137:
AG903_DSPPrmSetWATNUM(ch, 1);
138:
AG903_DSPPrmSetWATBASE(ch, 0x00000000);
139:
AG903_DSPPrmSetLSTCTRL(ch,
false,
false);
140:
AG903_DSPPrmSetHRZPRM0(ch, 0x060);
141:
AG903_DSPPrmSetHRZPRM1(ch, 0x010, 0x030);
142:
AG903_DSPPrmSetVTPRM0(ch, &vtprm0);
143:
AG903_DSPPrmSetVTPRM1(ch, 0x00A, 0x021);
144:
AG903_DSPPrmSetFRMSIZE(ch, 0x1E0, 0x280);
145:
AG903_DSPPrmSetCDCTRL(ch, &cdctrl);
146:
AG903_DSPPrmSetCOLDET(ch, &coldet);
147:
AG903_DSPPrmSetDITHAREA0A(ch, 0x7FF, 0x7FF);
148:
AG903_DSPPrmSetDITHAREA0B(ch, 0x000, 0x000);
149:
AG903_DSPPrmSetDITHAREA1A(ch, 0x7FF, 0x7FF);
150:
AG903_DSPPrmSetDITHAREA1B(ch, 0x000, 0x000);
151:
AG903_DSPPrmSetDITHAREA2A(ch, 0x7FF, 0x7FF);
152:
AG903_DSPPrmSetDITHAREA2B(ch, 0x000, 0x000);
153:
AG903_DSPPrmSetDITHAREA3A(ch, 0x7FF, 0x7FF);
154:
AG903_DSPPrmSetDITHAREA3B(ch, 0x000, 0x000);
155:
AG903_DSPPrmSetERRCLR(ch, &errclr);
156:
AG903_DSPPrmSetINT(ch, &intprm);
157:
AG903_DSPPrmSetTRIGGER(ch, AG903_DSP_EVENT_VT,
158: AG903_DSP_TRG_HRZ_START_OF_LINE,
159: AG903_DSP_TRG_VT_START_OF_VBLANK);
160:
AG903_DSPPrmSetINTCLR(ch,
true,
161:
true,
162:
true);
163:
AG903_DSPPrmSetINTMASK(ch, &intmask);
164:
AG903_DSPPrmSetDMAREQ(ch, AG903_DSP_DMA_NONE);
165: int32_t tnum;
166:
for(tnum=0; tnum<
AG903_DSP_LUT_NUM; tnum++)
167: {
168:
AG903_DSPPrmSetLUTR(ch, tnum, &lutr);
169:
AG903_DSPPrmSetLUTG(ch, tnum, &lutg);
170:
AG903_DSPPrmSetLUTB(ch, tnum, &lutb);
171: }
172:
173:
int listno;
174:
for (listno=0; listno<
AG903_DSP_ATTR_MAX; listno++)
175: {
176: gDSP.ch[ch].lock[listno] = NULL;
177: }
178: }
179:
180:
187:
static void AG903_DSPMgrInitVOD(uint8_t ch) {
188:
if (ch >
AG903_DSP_CH_NUM)
return;
189:
190:
VODPrmParamMOD mod = {
191: .dp = AG903_DSP_POLARITY_POSI,
192: .vp = AG903_DSP_POLARITY_NEGA,
193: .hp = AG903_DSP_POLARITY_NEGA,
194: .fp = AG903_DSP_POLARITY_NEGA,
195: .cdp = AG903_DSP_POLARITY_POSI,
196: .dex = AG903_DSP_SIGNAL_ENABLE,
197: .vex = AG903_DSP_SIGNAL_ENABLE,
198: .hex = AG903_DSP_SIGNAL_ENABLE,
199: .fex = AG903_DSP_SIGNAL_ENABLE,
200: .cdex = AG903_DSP_SIGNAL_ENABLE,
201: .pex = AG903_DSP_SIGNAL_ENABLE,
202: .cp = AG903_VOD_DOTCLK_LATCH_RISE,
203: .code =
false,
204: .yuv = AG903_VOD_MOD_YUV_BT601,
205: .fmt = 0,
206: .ct0 = 0,
207: .ct1 = 0,
208: };
209:
210:
if (ch == 0) {
211:
AG903_VODPrmSetPORTSEL(ch, AG903_VOD0_PORTSEL_LVCMOS24);
212: }
else {
213:
AG903_VODPrmSetPORTSEL(ch, AG903_VOD1_PORTSEL_LVDS_DUAL);
214: }
215:
AG903_VODPrmSetMOD(ch, &mod);
216:
AG903_VODPrmSetBPWRMOD(ch,
false, AG903_VOD_BPWR_UNIT_FRAME);
217:
AG903_VODPrmSetPPWRONCNT(ch, 0x00000000);
218:
AG903_VODPrmSetBPWRONCNT(ch, 0x00000000);
219:
AG903_VODPrmSetBLGTONCNT(ch, 0x00000000);
220:
AG903_VODPrmSetPPWROFFCNT(ch, 0x00000000);
221:
AG903_VODPrmSetBPWROFFCNT(ch, 0x00000000);
222:
AG903_VODPrmSetBLGTOFFCNT(ch, 0x00000000);
223:
AG903_VODPrmSetPWMPERIOD(ch, 0x00000000);
224:
AG903_VODPrmSetPWMCNT(ch, 0x00000000);
225:
AG903_VODPrmSetMACRO0(AG903_VOD_FR_8_16MHZ,
226: AG903_VOD_PM_AUTO, AG903_VOD_PDX_PWRDOWN);
227:
AG903_VODPrmSetMACRO1(AG903_VOD_FR_8_16MHZ,
228: AG903_VOD_PM_AUTO, AG903_VOD_PDX_PWRDOWN);
229: }
230:
231:
238: int32_t
AG903_DSPMgrInit(
void)
239: {
240: uint8_t ch;
241: uint32_t attr;
242:
243:
for (ch=0; ch<
AG903_DSP_CH_NUM; ch++) {
244:
if (gDSP.init ==
false) {
245:
246:
AG903_DSPMgrInitDSP(ch);
247:
AG903_DSPMgrInitVOD(ch);
248: }
249:
250: gDSP.ch[ch].channel = ch;
251:
for (attr=0; attr<
AG903_DSP_ATTR_MAX; attr++) {
252: gDSP.ch[ch].lock[attr] = NULL;
253: }
254: gDSP.lock[ch] = NULL;
255: }
256:
257: gDSP.init =
true;
258:
259:
return AG903_ENONE;
260: }
261:
262:
272: int32_t
AG903_DSPMgrGetHandle(uint8_t ch,
AG903_DSPMgrHandle **handle)
273: {
274: int32_t rc =
AG903_ENONE;
275:
276:
if ((ch >
AG903_DSP_CH_NUM) || (handle == NULL)) {
277: rc = -
AG903_EINVAL;
278: }
279:
280:
if (rc ==
AG903_ENONE) {
281:
if (gDSP.init ==
false) {
282:
AG903_DSPMgrInit();
283: }
else {
284:
if (gDSP.lock[ch] != NULL) {
285: rc = -
AG903_EBUSY;
286: }
else {
287:
AG903_DSPMgrInitDSP(ch);
288:
AG903_DSPMgrInitVOD(ch);
289: }
290: }
291: }
292:
293:
if (rc ==
AG903_ENONE) {
294: (*handle) = (
AG903_DSPMgrHandle *)&gDSP.ch[ch];
295: gDSP.lock[ch] = (
AG903_DSPMgrHandle *)(*handle);
296: }
297:
298:
return rc;
299: }
300:
301:
308: int32_t
AG903_DSPMgrReleaseHandle(
AG903_DSPMgrHandle *handle)
309: {
310: int32_t rc =
AG903_ENONE;
311: uint8_t ch;
312:
313:
if (handle == NULL)
314:
return -
AG903_EINVAL;
315:
316: rc = DSPMgrCheckHandle(handle, &ch);
317:
318:
if (rc ==
AG903_ENONE) {
319: rc =
AG903_DSPMgrCheckStopped(handle);
320: }
321:
322:
if (rc ==
AG903_ENONE) {
323:
AG903_DSPMgrIntStat stat;
324:
AG903_DSPMgrGetIntStat(handle, &stat);
325: stat.clr_vt_blank = stat.int_vt_blank;
326: stat.clr_hrz_line = stat.int_hrz_line;
327: stat.clr_dspoff = stat.int_dspoff;
328: rc =
AG903_DSPMgrClearIntStat(handle, &stat);
329: }
330:
331:
if (rc ==
AG903_ENONE) {
332: gDSP.lock[ch] = NULL;
333: }
334:
335:
return rc;
336: }
337:
338:
347: int32_t
AG903_DSPMgrEnable(
AG903_DSPMgrHandle *handle)
348: {
349: int32_t rc =
AG903_ENONE;
350: uint8_t ch;
351:
352:
if (handle == NULL)
353:
return -
AG903_EINVAL;
354:
355: rc = DSPMgrCheckHandle(handle, &ch);
356:
357:
if (rc ==
AG903_ENONE) {
358: uint32_t dspon;
359:
AG903_DSPPrmGetCTRL(ch, &dspon);
360:
if (dspon == AG903_DSP_CTRL_OFF) {
361:
AG903_DSPPrmSetCTRL(ch, AG903_DSP_CTRL_ON);
362: }
else {
363: rc = -
AG903_EBUSY;
364: }
365: }
366:
367:
return rc;
368: }
369:
370:
378: int32_t
AG903_DSPMgrDisable(
AG903_DSPMgrHandle *handle)
379: {
380: int32_t rc =
AG903_ENONE;
381: uint8_t ch;
382:
383:
if (handle == NULL)
384:
return -
AG903_EINVAL;
385:
386: rc = DSPMgrCheckHandle(handle, &ch);
387:
388:
if (rc ==
AG903_ENONE) {
389:
AG903_DSPPrmSetCTRL(ch,
false);
390: }
391:
392:
return rc;
393: }
394:
395:
404: int32_t
AG903_DSPMgrGetCtrlParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrCtrlParam *param)
405: {
406: int32_t rc =
AG903_ENONE;
407: uint8_t ch;
408:
409:
if ((handle == NULL) || (param == NULL))
410:
return -
AG903_EINVAL;
411:
if (param->syncparam == NULL)
412:
return -
AG903_EINVAL;
413:
414: rc = DSPMgrCheckHandle(handle, &ch);
415:
416:
if (rc ==
AG903_ENONE) {
417:
DSPPrmParamMOD mod;
418:
DSPPrmParamSYNC sync;
419:
DSPPrmParamVTPRM0 vtprm0;
420:
421:
AG903_DSPPrmGetMOD(ch, &mod);
422:
AG903_DSPPrmGetSYNC(ch, &sync);
423:
AG903_DSPPrmGetVTPRM0(ch, &vtprm0);
424:
425: param->ip_sel = mod.ip;
426:
AG903_DSPPrmGetFRMSIZE(ch,
427: ¶m->vt_framesize,
428: ¶m->hrz_framesize);
429:
430: param->syncparam->rgbde_sel = mod.de;
431: param->syncparam->vsync_polarity = sync.vp;
432: param->syncparam->field_hsync_polarity = sync.fp;
433: param->syncparam->vt_pulsewidth = vtprm0.vpw;
434: param->syncparam->odd_frontporch_plus1 = vtprm0.ofp;
435: param->syncparam->odd_backporch_plus1 = vtprm0.obp;
436: param->syncparam->even_frontporch_plus1 = vtprm0.efp;
437: param->syncparam->even_backporch_plus1 = vtprm0.ebp;
438:
AG903_DSPPrmGetHRZPRM0(ch, ¶m->syncparam->hrz_pulsewidth);
439:
AG903_DSPPrmGetHRZPRM1(ch,
440: ¶m->syncparam->hrz_frontporch,
441: ¶m->syncparam->hrz_backporch);
442:
AG903_DSPPrmGetVTPRM1(ch,
443: ¶m->syncparam->vt_frontporch,
444: ¶m->syncparam->vt_backporch);
445: }
446:
447:
return rc;
448: }
449:
450:
466: int32_t
AG903_DSPMgrSetWindowParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrWindowParam *param)
467: {
468: int32_t rc =
AG903_ENONE;
469: uint8_t ch;
470:
471:
if ((handle == NULL) || (param == NULL))
472:
return -
AG903_EINVAL;
473:
if (param->window_attr_base & ~0xFFFFFFF8)
474:
return -
AG903_EINVAL;
475:
476: rc = DSPMgrCheckHandle(handle, &ch);
477:
478:
if (rc ==
AG903_ENONE) {
479: rc =
AG903_DSPMgrCheckStopped(handle);
480: }
481:
482:
if (rc ==
AG903_ENONE) {
483:
DSPPrmParamMOD mod;
484: uint32_t act, conf;
485:
486:
AG903_DSPPrmGetMOD(ch, &mod);
487: mod.upd = param->update_timing;
488:
AG903_DSPPrmSetMOD(ch, &mod);
489:
490:
AG903_DSPPrmSetBGCOL(ch, param->background);
491:
AG903_DSPPrmSetWINNUM(ch, param->num_config);
492:
AG903_DSPPrmSetWATNUM(ch, param->num_attr);
493:
AG903_DSPPrmSetWATBASE(ch, param->window_attr_base);
494:
AG903_DSPPrmSetLSTCTRL(ch,
495: param->palette_update,
496: param->window_attr_update);
497:
AG903_DSPPrmGetWINNUM(ch, &act, &conf);
498:
if (param->num_config != act) {
499: rc = -
AG903_ECHRNG;
500: }
501: }
502:
503:
return rc;
504: }
505:
506:
517: int32_t
AG903_DSPMgrSetAttributeList(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrWindowParam *param)
518: {
519: int32_t rc =
AG903_ENONE;
520: uint8_t ch;
521:
522:
if ((handle == NULL) || (param == NULL))
523:
return -
AG903_EINVAL;
524:
if (param->window_attr_base & ~0xFFFFFFF8)
525:
return -
AG903_EINVAL;
526:
527: rc = DSPMgrCheckHandle(handle, &ch);
528:
529:
if (rc ==
AG903_ENONE) {
530:
AG903_DSPPrmSetWATNUM(ch, param->num_attr);
531:
AG903_DSPPrmSetWATBASE(ch, param->window_attr_base);
532: }
533:
534:
return rc;
535: }
536:
537:
548: int32_t
AG903_DSPMgrSetIntParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrIntParam *param)
549: {
550: int32_t rc =
AG903_ENONE;
551: uint8_t ch;
552:
553:
if ((handle == NULL) || (param == NULL))
554:
return -
AG903_EINVAL;
555:
556: rc = DSPMgrCheckHandle(handle, &ch);
557:
558:
if (rc ==
AG903_ENONE) {
559: rc =
AG903_DSPMgrCheckStopped(handle);
560: }
561:
562:
if (rc ==
AG903_ENONE) {
563:
DSPPrmParamMOD mod;
564:
AG903_DSPPrmGetMOD(ch, &mod);
565: mod.bmr = param->bmureq_timing;
566:
AG903_DSPPrmSetMOD(ch, &mod);
567:
568:
DSPPrmParamINT intprm = {
569: .line = param->int_line_no,
570: .fcnt = param->int_framecount,
571: .hline = param->int_hrz_line,
572: .vblk = param->int_vt_blank,
573: };
574:
AG903_DSPPrmSetINT(ch, &intprm);
575:
576:
DSPPrmParamINTMASK intmask = {
577: .vblk = param->mask_vt_blank,
578: .hline = param->mask_hrz_line,
579: .doff = param->mask_dspoff,
580: .err = param->mask_error,
581: };
582:
AG903_DSPPrmSetINTMASK(ch, &intmask);
583:
584:
AG903_DSPPrmSetTRIGGER(ch,
585: param->trigger_out,
586: param->trigger_hrz,
587: param->trigger_vt);
588: }
589:
590:
return rc;
591: }
592:
593:
607: int32_t
AG903_DSPMgrSetIntMask(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrIntParam *param)
608: {
609: int32_t rc =
AG903_ENONE;
610: uint8_t ch;
611:
612:
if ((handle == NULL) || (param == NULL))
613:
return -
AG903_EINVAL;
614:
615: rc = DSPMgrCheckHandle(handle, &ch);
616:
617:
if (rc ==
AG903_ENONE) {
618:
DSPPrmParamINTMASK intmask = {
619: .vblk = param->mask_vt_blank,
620: .hline = param->mask_hrz_line,
621: .doff = param->mask_dspoff,
622: .err = param->mask_error,
623: };
624:
AG903_DSPPrmSetINTMASK(ch, &intmask);
625: }
626:
627:
return rc;
628: }
629:
630:
639: int32_t
AG903_DSPMgrGetIntStat(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrIntStat *stat)
640: {
641: int32_t rc =
AG903_ENONE;
642: uint8_t ch;
643:
644:
if ((handle == NULL) || (stat == NULL))
645:
return -
AG903_EINVAL;
646:
647: rc = DSPMgrCheckHandle(handle, &ch);
648:
649:
if (rc ==
AG903_ENONE) {
650:
DSPPrmParamINTSTAT intstat;
651:
AG903_DSPPrmGetINTSTAT(ch, &intstat);
652: stat->int_vt_blank = intstat.vblk;
653: stat->int_hrz_line = intstat.hline;
654: stat->int_dspoff = intstat.doff;
655: stat->dreq = intstat.dreq;
656: }
657:
658:
return rc;
659: }
660:
661:
672: int32_t
AG903_DSPMgrClearIntStat(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrIntStat *stat)
673: {
674: int32_t rc =
AG903_ENONE;
675: uint8_t ch;
676:
677:
if ((handle == NULL) || (stat == NULL))
678:
return -
AG903_EINVAL;
679:
680: rc = DSPMgrCheckHandle(handle, &ch);
681:
682:
if (rc ==
AG903_ENONE) {
683:
AG903_DSPPrmSetINTCLR(ch,
684: stat->clr_vt_blank,
685: stat->clr_hrz_line,
686: stat->clr_dspoff);
687: }
688:
689:
return rc;
690: }
691:
692:
707: int32_t
AG903_DSPMgrGetStat(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrStat *stat)
708: {
709: int32_t rc =
AG903_ENONE;
710: uint8_t ch;
711:
712:
if ((handle == NULL) || (stat == NULL))
713:
return -
AG903_EINVAL;
714:
715: rc = DSPMgrCheckHandle(handle, &ch);
716:
717:
if (rc ==
AG903_ENONE) {
718:
DSPPrmParamERRSTAT errstat;
719:
AG903_DSPPrmGetERRSTAT(ch, &errstat);
720: stat->err_line = errstat.line;
721: stat->err_ue = errstat.ue;
722: stat->err_le = errstat.le;
723: stat->err_pe = errstat.pe;
724:
AG903_DSPPrmGetVTSTAT(ch, &stat->work_line, &stat->vt_status, &stat->frameconut);
725:
AG903_DSPPrmGetHRZSTAT(ch, &stat->work_pix, &stat->hrz_status);
726:
727: uint32_t state;
728:
AG903_VODPrmGetSTAT(ch, &state);
729:
if (state == 0)
730: stat->ctrl_status = AG903_DSP_CTRL_OFF;
731:
else
732: stat->ctrl_status = AG903_DSP_CTRL_ON;
733: }
734:
735:
return rc;
736: }
737:
738:
752: int32_t
AG903_DSPMgrClearStat(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrStat *stat)
753: {
754: int32_t rc =
AG903_ENONE;
755: uint8_t ch;
756:
757:
if ((handle == NULL) || (stat == NULL))
758:
return -
AG903_EINVAL;
759:
760: rc = DSPMgrCheckHandle(handle, &ch);
761:
762:
if (rc ==
AG903_ENONE) {
763:
DSPPrmParamERRCLR errclr;
764: errclr.line = stat->errclr_line;
765: errclr.ue = stat->errclr_ue;
766: errclr.le = stat->errclr_le;
767: errclr.pe = stat->errclr_pe;
768:
AG903_DSPPrmSetERRCLR(ch, &errclr);
769: }
770:
771:
return rc;
772: }
773:
774:
788: int32_t
AG903_DSPMgrGetAttribute(
AG903_DSPMgrHandle *handle, uint8_t listno,
AG903_DSPMgrWinAttribute **attr)
789: {
790: int32_t rc =
AG903_ENONE;
791: uint32_t addr;
792: uint8_t ch;
793: uint32_t watnum;
794:
795:
if ((handle == NULL) || (attr == NULL))
796:
return -
AG903_EINVAL;
797:
798: rc = DSPMgrCheckHandle(handle, &ch);
799:
800:
if (rc ==
AG903_ENONE) {
801:
AG903_DSPPrmGetWATNUM(ch, &watnum);
802:
803:
if (listno >= watnum) {
804: rc = -
AG903_EINVAL;
805: }
806: }
807:
808:
if (rc ==
AG903_ENONE) {
809:
if (gDSP.ch[ch].lock[listno] != NULL) {
810: rc = -
AG903_EBUSY;
811: }
812: }
813:
814:
if (rc ==
AG903_ENONE) {
815:
AG903_DSPPrmGetWATBASE(ch, &addr);
816: (*attr) = ((
AG903_DSPMgrWinAttribute *)addr + listno);
817: gDSP.ch[ch].lock[listno] = (uint32_t *)(*attr);
818: }
819:
820:
return rc;
821: }
822:
823:
833: int32_t
AG903_DSPMgrSetAttribute(
AG903_DSPMgrHandle *handle, uint8_t listno)
834: {
835: int32_t rc =
AG903_ENONE;
836: uint8_t ch;
837: uint32_t watnum;
838:
839:
if (handle == NULL)
840:
return -
AG903_EINVAL;
841:
842: rc = DSPMgrCheckHandle(handle, &ch);
843:
844:
if (rc ==
AG903_ENONE) {
845:
AG903_DSPPrmGetWATNUM(ch, &watnum);
846:
847:
if ((listno >= watnum)
848: || (gDSP.ch[ch].lock[listno] == NULL)) {
849: rc = -
AG903_EINVAL;
850: }
851: }
852:
853:
if (rc ==
AG903_ENONE) {
854: gDSP.ch[ch].lock[listno] = NULL;
855: }
856:
857:
return rc;
858: }
859:
860:
871: int32_t
AG903_DSPMgrSetExSyncParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrExSyncParam *param)
872: {
873: int32_t rc =
AG903_ENONE;
874: uint8_t ch;
875:
876:
if ((handle == NULL) || (param == NULL))
877:
return -
AG903_EINVAL;
878:
879: rc = DSPMgrCheckHandle(handle, &ch);
880:
881:
if (rc ==
AG903_ENONE) {
882: rc =
AG903_DSPMgrCheckStopped(handle);
883: }
884:
885:
if (rc ==
AG903_ENONE) {
886:
DSPPrmParamSYNC sync;
887: sync.sel = param->sync_sel;
888: sync.dly = param->delay_ctrl_en;
889: sync.ip = param->ip_sel;
890: sync.vp = param->vsync_polarity;
891: sync.fp = param->field_hsync_polarity;
892: sync.msk = param->sync_mask_en;
893:
AG903_DSPPrmSetSYNC(ch, &sync);
894: }
895:
896:
return rc;
897: }
898:
899:
910: int32_t
AG903_DSPMgrSetLutParam(
AG903_DSPMgrHandle *handle, _Bool en,
AG903_DSPMgrLutParam *param)
911: {
912: int32_t rc =
AG903_ENONE;
913: uint8_t ch;
914: uint32_t cnt;
915:
DSPPrmParamMOD mod;
916:
917:
if (handle == NULL)
918:
return -
AG903_EINVAL;
919:
920: rc = DSPMgrCheckHandle(handle, &ch);
921:
922:
if (rc ==
AG903_ENONE) {
923:
if (param != NULL) {
924:
DSPPrmParamLUTR lutr = {0};
925:
DSPPrmParamLUTG lutg = {0};
926:
DSPPrmParamLUTB lutb = {0};
927:
for (cnt = 0;cnt <
AG903_DSP_LUT_NUM;cnt++) {
928: lutr.r0 = param->LUTR[cnt].r0;
929: lutr.r1 = param->LUTR[cnt].r1;
930: lutr.r2 = param->LUTR[cnt].r2;
931: lutr.r3 = param->LUTR[cnt].r3;
932: lutg.g0 = param->LUTG[cnt].g0;
933: lutg.g1 = param->LUTG[cnt].g1;
934: lutg.g2 = param->LUTG[cnt].g2;
935: lutg.g3 = param->LUTG[cnt].g3;
936: lutb.b0 = param->LUTB[cnt].b0;
937: lutb.b1 = param->LUTB[cnt].b1;
938: lutb.b2 = param->LUTB[cnt].b2;
939: lutb.b3 = param->LUTB[cnt].b3;
940:
AG903_DSPPrmSetLUTR(ch, cnt, &lutr);
941:
AG903_DSPPrmSetLUTG(ch, cnt, &lutg);
942:
AG903_DSPPrmSetLUTB(ch, cnt, &lutb);
943: }
944: }
945:
AG903_DSPPrmGetMOD(ch, &mod);
946: mod.lut = en ?
true :
false;
947:
AG903_DSPPrmSetMOD(ch, &mod);
948: }
949:
950:
return rc;
951: }
952:
953:
964: int32_t
AG903_DSPMgrSetDithParam(
AG903_DSPMgrHandle *handle, _Bool en,
AG903_DSPMgrDithParam *param)
965: {
966: int32_t rc =
AG903_ENONE;
967: uint8_t ch;
968:
DSPPrmParamMOD mod;
969:
970:
if (handle == NULL)
971:
return -
AG903_EINVAL;
972:
973: rc = DSPMgrCheckHandle(handle, &ch);
974:
975:
if (rc ==
AG903_ENONE) {
976:
if (param != NULL) {
977:
AG903_DSPPrmSetDITHAREA0A(ch, param->DITHAREA[0].x0, param->DITHAREA[0].y0);
978:
AG903_DSPPrmSetDITHAREA0B(ch, param->DITHAREA[0].x1, param->DITHAREA[0].y1);
979:
AG903_DSPPrmSetDITHAREA1A(ch, param->DITHAREA[1].x0, param->DITHAREA[1].y0);
980:
AG903_DSPPrmSetDITHAREA1B(ch, param->DITHAREA[1].x1, param->DITHAREA[1].y1);
981:
AG903_DSPPrmSetDITHAREA2A(ch, param->DITHAREA[2].x0, param->DITHAREA[2].y0);
982:
AG903_DSPPrmSetDITHAREA2B(ch, param->DITHAREA[2].x1, param->DITHAREA[2].y1);
983:
AG903_DSPPrmSetDITHAREA3A(ch, param->DITHAREA[3].x0, param->DITHAREA[3].y0);
984:
AG903_DSPPrmSetDITHAREA3B(ch, param->DITHAREA[3].x1, param->DITHAREA[3].y1);
985: }
986:
AG903_DSPPrmGetMOD(ch, &mod);
987: mod.dith = en ?
true :
false;
988:
AG903_DSPPrmSetMOD(ch, &mod);
989: }
990:
991:
return rc;
992: }
993:
994:
1004: int32_t
AG903_DSPMgrSetCDParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrCDParam *param)
1005: {
1006: int32_t rc =
AG903_ENONE;
1007: uint8_t ch;
1008:
1009:
if (handle == NULL)
1010:
return -
AG903_EINVAL;
1011:
1012: rc = DSPMgrCheckHandle(handle, &ch);
1013:
1014:
if (rc ==
AG903_ENONE) {
1015:
DSPPrmParamCOLDET coldet;
1016:
DSPPrmParamCDCTRL cdctrl;
1017:
if (param == NULL) {
1018:
AG903_DSPPrmGetCDCTRL(ch, &cdctrl);
1019: cdctrl.be =
false;
1020: cdctrl.ge =
false;
1021: cdctrl.re =
false;
1022: cdctrl.ae =
false;
1023:
AG903_DSPPrmSetCDCTRL(ch, &cdctrl);
1024: }
else {
1025: cdctrl.be = param->colordetect_en_b;
1026: cdctrl.ge = param->colordetect_en_g;
1027: cdctrl.re = param->colordetect_en_r;
1028: cdctrl.ae = param->colordetect_en_a;
1029: coldet.b = param->colordetect_color_b;
1030: coldet.g = param->colordetect_color_g;
1031: coldet.r = param->colordetect_color_r;
1032: coldet.a = param->colordetect_color_a;
1033:
AG903_DSPPrmSetCOLDET(ch, &coldet);
1034:
AG903_DSPPrmSetCDCTRL(ch, &cdctrl);
1035: }
1036: }
1037:
1038:
return rc;
1039: }
1040:
1041:
1050: int32_t
AG903_DSPMgrSetDMAReq(
AG903_DSPMgrHandle *handle, uint8_t req)
1051: {
1052: int32_t rc =
AG903_ENONE;
1053: uint8_t ch;
1054:
1055:
if (handle == NULL)
1056:
return -
AG903_EINVAL;
1057:
1058: rc = DSPMgrCheckHandle(handle, &ch);
1059:
1060:
if (rc ==
AG903_ENONE) {
1061:
AG903_DSPPrmSetDMAREQ(ch, req);
1062: }
1063:
1064:
return rc;
1065: }
1066:
1067:
1078: int32_t
AG903_DSPMgrSetCMOSParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrCtrlParam *ctrl,
AG903_DSPMgrCMOSParam *param)
1079: {
1080: int32_t rc =
AG903_ENONE;
1081: uint8_t ch;
1082:
1083:
if ((handle == NULL) || (ctrl == NULL) || (param == NULL))
1084:
return -
AG903_EINVAL;
1085:
1086: rc = DSPMgrCheckHandle(handle, &ch);
1087:
1088:
if (rc ==
AG903_ENONE) {
1089: rc =
AG903_DSPMgrCheckStopped(handle);
1090: }
1091:
1092:
if (rc ==
AG903_ENONE) {
1093:
DSPPrmParamMOD mod;
1094:
DSPPrmParamSYNC sync;
1095:
DSPPrmParamVTPRM0 vtprm0;
1096:
1097:
AG903_DSPPrmGetMOD(ch, &mod);
1098:
if (NULL != ctrl->syncparam) {
1099: mod.de = ctrl->syncparam->rgbde_sel;
1100: }
1101: mod.ip = ctrl->ip_sel;
1102:
AG903_DSPPrmSetMOD(ch, &mod);
1103:
1104:
if (NULL != ctrl->syncparam) {
1105:
AG903_DSPPrmGetSYNC(ch, &sync);
1106: sync.vp = ctrl->syncparam->vsync_polarity;
1107: sync.fp = ctrl->syncparam->field_hsync_polarity;
1108:
AG903_DSPPrmSetSYNC(ch, &sync);
1109:
1110: vtprm0.vpw = ctrl->syncparam->vt_pulsewidth;
1111: vtprm0.ofp = ctrl->syncparam->odd_frontporch_plus1;
1112: vtprm0.obp = ctrl->syncparam->odd_backporch_plus1;
1113: vtprm0.efp = ctrl->syncparam->even_frontporch_plus1;
1114: vtprm0.ebp = ctrl->syncparam->even_backporch_plus1;
1115:
AG903_DSPPrmSetVTPRM0(ch, &vtprm0);
1116:
1117:
AG903_DSPPrmSetHRZPRM0(ch, ctrl->syncparam->hrz_pulsewidth);
1118:
AG903_DSPPrmSetHRZPRM1(ch, ctrl->syncparam->hrz_frontporch,
1119: ctrl->syncparam->hrz_backporch);
1120:
AG903_DSPPrmSetVTPRM1(ch, ctrl->syncparam->vt_frontporch,
1121: ctrl->syncparam->vt_backporch);
1122: }
1123:
AG903_DSPPrmSetFRMSIZE(ch, ctrl->vt_framesize, ctrl->hrz_framesize);
1124:
1125:
if (rc ==
AG903_ENONE) {
1126:
VODPrmParamMOD mod;
1127:
AG903_VODPrmGetMOD(ch, &mod);
1128: mod.dp = param->rgbde_polarity;
1129: mod.vp = param->vsync_polarity;
1130: mod.hp = param->hsync_polarity;
1131: mod.fp = param->field_polarity;
1132: mod.cdp = param->colordetect_polarity;
1133: mod.dex = param->rgbde_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1134: mod.vex = param->vsync_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1135: mod.hex = param->hsync_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1136: mod.fex = param->field_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1137: mod.cdex = param->colordetect_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1138: mod.pex = param->pixeldata_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1139: mod.cp = param->dotclk_polarity;
1140: mod.code = param->code_en;
1141: mod.yuv = param->yuv_mode;
1142:
AG903_VODPrmSetMOD(ch, &mod);
1143: }
1144: }
1145:
1146:
return rc;
1147: }
1148:
1149:
1161: int32_t
AG903_DSPMgrSetLVDSParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrCtrlParam *ctrl,
AG903_DSPMgrLVDSParam *param)
1162: {
1163: int32_t rc =
AG903_ENONE;
1164: uint8_t ch;
1165:
1166:
if ((handle == NULL) || (ctrl == NULL) || (param == NULL))
1167:
return -
AG903_EINVAL;
1168:
1169: rc = DSPMgrCheckHandle(handle, &ch);
1170:
1171:
if (rc ==
AG903_ENONE) {
1172: rc =
AG903_DSPMgrCheckStopped(handle);
1173: }
1174:
1175:
if (rc ==
AG903_ENONE) {
1176:
DSPPrmParamMOD mod;
1177:
DSPPrmParamSYNC sync;
1178:
DSPPrmParamVTPRM0 vtprm0;
1179:
1180:
AG903_DSPPrmGetMOD(ch, &mod);
1181:
if (NULL != ctrl->syncparam) {
1182: mod.de = ctrl->syncparam->rgbde_sel;
1183: }
1184: mod.ip = ctrl->ip_sel;
1185:
AG903_DSPPrmSetMOD(ch, &mod);
1186:
1187:
if (NULL != ctrl->syncparam) {
1188:
AG903_DSPPrmGetSYNC(ch, &sync);
1189: sync.vp = ctrl->syncparam->vsync_polarity;
1190: sync.fp = ctrl->syncparam->field_hsync_polarity;
1191:
AG903_DSPPrmSetSYNC(ch, &sync);
1192:
1193: vtprm0.vpw = ctrl->syncparam->vt_pulsewidth;
1194: vtprm0.ofp = ctrl->syncparam->odd_frontporch_plus1;
1195: vtprm0.obp = ctrl->syncparam->odd_backporch_plus1;
1196: vtprm0.efp = ctrl->syncparam->even_frontporch_plus1;
1197: vtprm0.ebp = ctrl->syncparam->even_backporch_plus1;
1198:
AG903_DSPPrmSetVTPRM0(ch, &vtprm0);
1199:
1200:
AG903_DSPPrmSetHRZPRM0(ch, ctrl->syncparam->hrz_pulsewidth);
1201:
AG903_DSPPrmSetHRZPRM1(ch, ctrl->syncparam->hrz_frontporch,
1202: ctrl->syncparam->hrz_backporch);
1203:
AG903_DSPPrmSetVTPRM1(ch, ctrl->syncparam->vt_frontporch,
1204: ctrl->syncparam->vt_backporch);
1205: }
1206:
AG903_DSPPrmSetFRMSIZE(ch, ctrl->vt_framesize, ctrl->hrz_framesize);
1207: }
1208:
1209:
if (rc ==
AG903_ENONE) {
1210:
VODPrmParamMOD mod;
1211: uint32_t portsel;
1212:
AG903_VODPrmGetMOD(ch, &mod);
1213: mod.dp = param->rgbde_polarity;
1214: mod.vp = param->vsync_polarity;
1215: mod.hp = param->hsync_polarity;
1216: mod.fp = param->field_polarity;
1217: mod.cdp = param->colordetect_polarity;
1218: mod.dex = param->rgbde_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1219: mod.vex = param->vsync_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1220: mod.hex = param->hsync_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1221: mod.fex = param->field_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1222: mod.cdex = param->colordetect_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1223: mod.pex = param->pixeldata_en ? AG903_DSP_SIGNAL_ENABLE : AG903_DSP_SIGNAL_DISABLE;
1224: mod.fmt = param->format;
1225: mod.ct0 = param->ctrl0;
1226: mod.ct1 = param->ctrl1;
1227:
AG903_VODPrmSetMOD(ch, &mod);
1228:
AG903_VODPrmGetPORTSEL(1, &portsel);
1229:
if (portsel == 0 || ch == 0) {
1230:
AG903_VODPrmSetMACRO0(param->freq_range,
1231: param->auto_powermanage,
1232: param->macro_power);
1233: }
1234:
if (ch == 1) {
1235:
AG903_VODPrmSetMACRO1(param->freq_range,
1236: param->auto_powermanage,
1237: param->macro_power);
1238: }
1239: }
1240:
1241:
return rc;
1242: }
1243:
1244:
1253: int32_t
AG903_DSPMgrGetBPwrModeParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrBPwrModeParam *param)
1254: {
1255: int32_t rc =
AG903_ENONE;
1256: uint8_t ch;
1257:
1258:
if ((handle == NULL) || (param == NULL)) {
1259: rc = -
AG903_EINVAL;
1260: }
1261:
1262:
if (rc ==
AG903_ENONE) {
1263: rc = DSPMgrCheckHandle(handle, &ch);
1264: }
1265:
1266:
if (rc ==
AG903_ENONE) {
1267:
AG903_VODPrmGetBPWRMOD(ch, ¶m->backlight_en, ¶m->cnt_unit);
1268:
AG903_VODPrmGetPPWRONCNT(ch, ¶m->panel_pwroncnt);
1269:
AG903_VODPrmGetBPWRONCNT(ch, ¶m->backlight_pwroncnt);
1270:
AG903_VODPrmGetBLGTONCNT(ch, ¶m->backlight_oncnt);
1271:
AG903_VODPrmGetPPWROFFCNT(ch, ¶m->panel_pwroffcnt);
1272:
AG903_VODPrmGetBPWROFFCNT(ch, ¶m->backlight_pwroffcnt);
1273:
AG903_VODPrmGetBLGTOFFCNT(ch, ¶m->backlight_offcnt);
1274:
AG903_VODPrmGetPWMPERIOD(ch, ¶m->pwm_period);
1275:
AG903_VODPrmGetPWMCNT(ch, ¶m->pwm_cnt);
1276: }
1277:
1278:
return rc;
1279: }
1280:
1281:
1290: int32_t
AG903_DSPMgrSetBPwrModeParam(
AG903_DSPMgrHandle *handle,
AG903_DSPMgrBPwrModeParam *param)
1291: {
1292: int32_t rc =
AG903_ENONE;
1293: uint8_t ch;
1294:
1295:
if ((handle == NULL) || (param == NULL)) {
1296: rc = -
AG903_EINVAL;
1297: }
1298:
1299:
if (rc ==
AG903_ENONE) {
1300: rc = DSPMgrCheckHandle(handle, &ch);
1301: }
1302:
1303:
if (rc ==
AG903_ENONE) {
1304:
AG903_VODPrmSetBPWRMOD(ch, param->backlight_en, param->cnt_unit);
1305:
AG903_VODPrmSetPPWRONCNT(ch, param->panel_pwroncnt);
1306:
AG903_VODPrmSetBPWRONCNT(ch, param->backlight_pwroncnt);
1307:
AG903_VODPrmSetBLGTONCNT(ch, param->backlight_oncnt);
1308:
AG903_VODPrmSetPPWROFFCNT(ch, param->panel_pwroffcnt);
1309:
AG903_VODPrmSetBPWROFFCNT(ch, param->backlight_pwroffcnt);
1310:
AG903_VODPrmSetBLGTOFFCNT(ch, param->backlight_offcnt);
1311:
AG903_VODPrmSetPWMPERIOD(ch, param->pwm_period);
1312:
AG903_VODPrmSetPWMCNT(ch, param->pwm_cnt);
1313: }
1314:
1315:
return rc;
1316: }
1317:
1318:
1327: int32_t
AG903_DSPMgrGetVODStat(
AG903_DSPMgrHandle *handle, uint32_t *stat)
1328: {
1329: int32_t rc =
AG903_ENONE;
1330: uint8_t ch;
1331:
1332:
if ((handle == NULL) || (stat == NULL))
1333:
return -
AG903_EINVAL;
1334:
1335: rc = DSPMgrCheckHandle(handle, &ch);
1336:
1337:
if (rc ==
AG903_ENONE) {
1338:
AG903_VODPrmGetSTAT(ch, stat);
1339: }
1340:
1341:
return rc;
1342: }
1343:
1344:
1352: int32_t
AG903_DSPMgrGetPortSel(
AG903_DSPMgrHandle *handle, uint8_t *sel)
1353: {
1354: int32_t rc =
AG903_ENONE;
1355: uint8_t ch;
1356: uint32_t portsel;
1357:
1358:
if ((handle == NULL) || (sel == NULL))
1359:
return -
AG903_EINVAL;
1360:
1361: rc = DSPMgrCheckHandle(handle, &ch);
1362:
1363:
if (rc ==
AG903_ENONE) {
1364:
AG903_VODPrmGetPORTSEL(ch, &portsel);
1365: *sel = portsel & 0xFF;
1366: }
1367:
1368:
return rc;
1369: }
1370:
1371:
1379: int32_t
AG903_DSPMgrSetPortSel(
AG903_DSPMgrHandle *handle, uint8_t sel)
1380: {
1381: int32_t rc =
AG903_ENONE;
1382: uint8_t ch;
1383:
1384:
if (handle == NULL)
1385:
return -
AG903_EINVAL;
1386:
1387: rc = DSPMgrCheckHandle(handle, &ch);
1388:
1389:
if (ch == 0) {
1390:
if (sel > AG903_VOD0_PORTSEL_LVDS_SINGLE)
1391: rc = -
AG903_EINVAL;
1392: }
else {
1393:
if (sel > AG903_VOD1_PORTSEL_LVDS_SINGLE)
1394: rc = -
AG903_EINVAL;
1395: }
1396:
1397:
if (rc ==
AG903_ENONE) {
1398:
AG903_VODPrmSetPORTSEL(ch, sel);
1399: }
1400:
1401:
return rc;
1402: }
1403:
1404:
1413:
static int32_t DSPMgrCheckHandle(
AG903_DSPMgrHandle *handle, uint8_t *ch)
1414: {
1415: uint32_t channel = ((uint32_t)handle - (uint32_t)gDSP.ch) /
sizeof(
DSPChBlock);
1416:
1417:
if ((channel >=
AG903_DSP_CH_NUM) ||
1418: (gDSP.lock[channel] != handle)) {
1419:
return -
AG903_EINVAL;
1420: }
1421:
1422: *ch = (uint8_t)channel;
1423:
1424:
return AG903_ENONE;
1425: }
1426:
1427:
1438: int32_t
AG903_DSPMgrCheckStopped(
AG903_DSPMgrHandle *handle)
1439: {
1440: int32_t rc =
AG903_ENONE;
1441: uint8_t ch;
1442: uint32_t stat;
1443:
1444:
if (handle == NULL)
1445:
return -
AG903_EINVAL;
1446:
1447: rc = DSPMgrCheckHandle(handle, &ch);
1448:
1449:
if (rc ==
AG903_ENONE) {
1450:
AG903_VODPrmGetSTAT(ch, &stat);
1451:
if (stat != 0)
1452: rc = -
AG903_EBUSY;
1453: }
1454:
1455:
return rc;
1456: }
1457: