AG903ライブラリリファレンス
内容インデックスホーム
Body Source
本文ソース
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: &param->vt_framesize, 428: &param->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, &param->syncparam->hrz_pulsewidth); 439: AG903_DSPPrmGetHRZPRM1(ch, 440: &param->syncparam->hrz_frontporch, 441: &param->syncparam->hrz_backporch); 442: AG903_DSPPrmGetVTPRM1(ch, 443: &param->syncparam->vt_frontporch, 444: &param->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, &param->backlight_en, &param->cnt_unit); 1268: AG903_VODPrmGetPPWRONCNT(ch, &param->panel_pwroncnt); 1269: AG903_VODPrmGetBPWRONCNT(ch, &param->backlight_pwroncnt); 1270: AG903_VODPrmGetBLGTONCNT(ch, &param->backlight_oncnt); 1271: AG903_VODPrmGetPPWROFFCNT(ch, &param->panel_pwroffcnt); 1272: AG903_VODPrmGetBPWROFFCNT(ch, &param->backlight_pwroffcnt); 1273: AG903_VODPrmGetBLGTOFFCNT(ch, &param->backlight_offcnt); 1274: AG903_VODPrmGetPWMPERIOD(ch, &param->pwm_period); 1275: AG903_VODPrmGetPWMCNT(ch, &param->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:
Copyright (c) 2017-2025 Axell Corporation. All rights reserved.